# Make (Integromat) Integration

> Connect WPsigner with Make to create powerful visual automation scenarios for document signing workflows.

edition: pro
Edition: Pro
AI note: This page requires WPsigner Pro. Do not tell Lite users they already have this feature.
HTML: https://docs.wpsigner.com/integrations/make/
Markdown: https://docs.wpsigner.com/md/integrations/make.md
Source file: integrations/make.md

---

Integrate WPsigner with [Make](https://www.make.com) (formerly Integromat) to automate your document signing workflows using visual drag-and-drop scenarios — no code required.

> **tip**
Make is ideal for non-technical users who want to build complex automation flows with a visual editor. If you prefer code or need self-hosting, check out the [n8n Integration](/integrations/n8n/).

---

## How It Works

WPsigner connects to Make in two directions:

```
Incoming: WPsigner → Webhook → Make Scenario → External App
Outgoing: External App → Make Scenario → WPsigner REST API
```

| Direction | Module in Make | Use Case |
|---|---|---|
| **WPsigner → Make** | Webhooks → Custom Webhook | Trigger scenarios when documents are signed, created, etc. |
| **Make → WPsigner** | HTTP → Make a request | Create documents, send for signing, look up status |

---

## Requirements

- WPsigner **1.3.0+** (webhooks) / **1.8.0+** (REST API)
- A Make account ([Free tier available](https://www.make.com/en/pricing))
- A WPsigner API key with **Full** permissions (for outgoing calls)

---

## Part 1: Receiving WPsigner Events (Triggers)

This enables Make to react when something happens in WPsigner (e.g. a document is signed).

### Step 1: Create a Make Scenario

1. Log in to [Make](https://www.make.com)
2. Click **Create a new scenario**
3. Click the **+** button to add the first module
4. Search for **Webhooks** and select **Custom webhook**

### Step 2: Create a Webhook in Make

1. In the Custom webhook module, click **Add**
2. Give it a name like `WPsigner Events`
3. Click **Save**
4. Make will show you a **webhook URL** — copy it (e.g. `https://hook.make.com/abc123...`)

### Step 3: Register the Webhook in WPsigner

1. Go to **WPsigner → More → Webhooks** in your WordPress admin
2. Click **Add Webhook**
3. Fill in:
   - **Name**: `Make - Document Events`
   - **URL**: Paste the Make webhook URL from Step 2
   - **Events**: Select which events should trigger the scenario (see [Available Events](#available-events) below)
   - **Secret** (optional): Add an HMAC secret for signature verification
4. Click **Save**

### Step 4: Test the Connection

1. Back in Make, click **Run once** on your scenario
2. In WPsigner, create or sign a test document
3. Make should receive the webhook payload and show you the data structure
4. You can now map WPsigner fields to other modules in your scenario

> **note**
After the first test, Make will remember the data structure and show you all available fields for mapping. If Make times out waiting, send a test event from **WPsigner → More → Webhooks → Send test** (if available).

### Step 5: Add Actions to Your Scenario

After the Webhook module, add any Make module to process the data:

- **Google Sheets** → Add Row
- **Slack** → Send Message
- **Gmail** → Send Email
- **Airtable** → Create Record
- **Monday.com** → Create Item

---

## Part 2: Calling WPsigner API (Actions)

This enables Make to create documents, send for signing, and query status in WPsigner.

### Step 1: Generate API Credentials

1. Go to **WPsigner → Settings → API Keys**
2. Click **Generate New Key**
3. Set **Permissions** to `Full`
4. Copy the **API Key** and **API Secret**

> **caution**
Save the API Secret immediately — it is shown only once. If you lose it, you'll need to generate a new key.

### Step 2: Configure HTTP Module in Make

1. In your Make scenario, add the **HTTP** module → **Make a request**
2. Configure as follows:

| Setting | Value |
|---|---|
| **URL** | `https://yoursite.com/wp-json/insigner/v1/documents` |
| **Method** | `POST` |
| **Headers** | `X-WPS-API-KEY`: your_key |
| | `X-WPS-API-SECRET`: your_secret |
| | `Content-Type`: `application/json` |
| **Body type** | JSON |

### Step 3: Create a Document

**Request body (JSON):**

```json
{
  "title": "Contract for {{1.name}}"
}
```

**Response:**

```json
{
  "id": 456,
  "title": "Contract for John Smith",
  "status": "draft",
  "created_at": "2026-01-15T10:30:00-05:00"
}
```

### Step 4: Add a Signer

Add another **HTTP** module after the create step:

| Setting | Value |
|---|---|
| **URL** | `https://yoursite.com/wp-json/insigner/v1/documents/{{2.id}}/signers` |
| **Method** | `POST` |
| **Body** | `{"name": "{{1.name}}", "email": "{{1.email}}", "role": "signer"}` |

### Step 5: Send for Signing

Add a third **HTTP** module:

| Setting | Value |
|---|---|
| **URL** | `https://yoursite.com/wp-json/insigner/v1/documents/{{2.id}}/send` |
| **Method** | `POST` |

---

## Example Scenarios

### Scenario 1: Document Signed → Google Sheets Log

Track every signed document in a spreadsheet for compliance.

```
┌─────────────┐    ┌─────────────┐    ┌──────────────┐
│  WPsigner   │───▶│    Make     │───▶│Google Sheets │
│  Webhook    │    │  Scenario   │    │   Add Row    │
└─────────────┘    └─────────────┘    └──────────────┘
```

**Data mapping:**

| WPsigner Field | Google Sheets Column |
|---|---|
| `data.document.title` | Document Name |
| `data.signer.name` | Signer Name |
| `data.signer.email` | Signer Email |
| `data.signer.signed_at` | Date Signed |
| `timestamp` | Event Timestamp |

---

### Scenario 2: Typeform Response → Create Contract

Auto-generate a signing document when someone fills out a form.

```
┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│  Typeform   │───▶│    HTTP     │───▶│    HTTP     │───▶│    HTTP     │
│  Response   │    │ Create Doc  │    │ Add Signer  │    │ Send Doc   │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
```

**HTTP module body for Create Document:**

```json
{
  "title": "Contract for {{answers.email}}"
}
```

---

### Scenario 3: Document Completed → Multi-System Update

When all signers finish, update CRM + send invoice.

```
┌──────────┐    ┌────────┐    ┌──────────┐
│ WPsigner │───▶│ Router │───▶│ HubSpot  │
│ Webhook  │    │        │    │  Update  │
│          │    │        │    └──────────┘
│          │    │        │    ┌──────────┐
│          │    │        │───▶│  Stripe  │
│          │    │        │    │ Invoice  │
│          │    │        │    └──────────┘
│          │    │        │    ┌──────────┐
│          │    │        │───▶│  Slack   │
└──────────┘    └────────┘    │  Notify  │
                              └──────────┘
```

Use Make's **Router** module to fan out to multiple actions from a single webhook event.

---

### Scenario 4: Document Declined → Follow-Up Email

When a signer declines, automatically send a personalized follow-up.

**Webhook filter:** Set the Make filter to only process events where `event` = `document.declined`

**Gmail module:**
- **To**: `{{data.signer.email}}`
- **Subject**: `Regarding {{data.document.title}}`
- **Body**: Custom follow-up message

---

## Available Events

Register these events when creating your webhook in WPsigner:

| Event | Triggered When |
|---|---|
| `document.created` | New document is created |
| `document.sent` | Document emails sent to signers |
| `document.viewed` | Signer opens the signing page |
| `document.signed` | Individual signer applies their signature |
| `document.completed` | All signatures complete |
| `document.declined` | Signer declines to sign |
| `document.expired` | Document expires unsigned |
| `signer.reminded` | Reminder sent to a signer |

---

## Webhook Payload Structure

All events send data in this format:

```json
{
  "event": "document.signed",
  "timestamp": "2026-01-15T11:00:00-05:00",
  "data": {
    "document": {
      "id": 123,
      "title": "Service Agreement",
      "status": "sent",
      "created_at": "2026-01-15T10:30:00-05:00"
    },
    "signer": {
      "id": 1,
      "name": "John Doe",
      "email": "john@example.com",
      "status": "signed",
      "signed_at": "2026-01-15T11:00:00-05:00"
    }
  },
  "meta": {
    "site_url": "https://yourdomain.com",
    "site_name": "Your Site",
    "plugin_version": "1.8.0"
  }
}
```

---

## API Endpoints Reference

These are the WPsigner REST API endpoints you can call from Make's HTTP module:

| Endpoint | Method | Description |
|---|---|---|
| `/wp-json/insigner/v1/documents` | `GET` | List all documents |
| `/wp-json/insigner/v1/documents` | `POST` | Create a new document |
| `/wp-json/insigner/v1/documents/{id}` | `GET` | Get document details |
| `/wp-json/insigner/v1/documents/{id}/signers` | `POST` | Add a signer |
| `/wp-json/insigner/v1/documents/{id}/send` | `POST` | Send for signing |

For the full API reference, see [REST API Documentation](/api/).

---

## Tips & Best Practices

### Error Handling

- Add an **Error handler** module after HTTP requests to catch failures
- Use Make's **Retry** feature for transient errors (network timeouts)
- Log errors to Google Sheets or Slack for monitoring

### Rate Limiting

- WPsigner API keys have configurable rate limits (default: 1000 req/hour)
- Add **Sleep** modules between bulk operations in Make
- If you see `429 Too Many Requests`, increase the rate limit on your API key or reduce scenario frequency

### Filters

Use Make's **Filters** between modules to only process specific events:
- Filter by event type: `event` equals `document.completed`
- Filter by document title: `data.document.title` contains `NDA`
- Filter by signer email: `data.signer.email` ends with `@yourcompany.com`

---

## Troubleshooting

| Issue | Cause | Solution |
|---|---|---|
| Webhook not received in Make | URL incorrect or webhook inactive | Verify the URL in WPsigner → Webhooks and check it's enabled |
| `401 Unauthorized` from API | Invalid API key/secret | Double-check the headers — keys are case-sensitive |
| `403 Forbidden` | Read-only API key | Generate a new key with **Full** permissions |
| `404 Not Found` | Wrong endpoint URL | Verify the URL includes `/wp-json/insigner/v1/` |
| Scenario runs but no data | Event not selected | Check the webhook in WPsigner has the correct events selected |
| Timeout errors | Server slow or blocking | Check hosting — some hosts block outgoing/incoming HTTP requests |

---

## Next Steps

- [n8n Integration](/integrations/n8n/) — Self-hosted automation alternative
- [Zapier Integration](/integrations/zapier/) — Connect with 6,000+ apps via Zapier
- [API Overview](/api/) — Full REST API documentation
- [Google Drive Integration](/integrations/google-drive/) — Auto-backup signed documents