Make (Integromat)

Connect Convoy to 1,800+ apps using Make. Build visual automation scenarios that send prompts and receive AI-generated results — no code required.

Use Case: Automated Content Generation Pipeline

A powerful workflow: new rows in Google Sheets trigger AI content generation via Convoy, and results flow back to your sheet, Slack, Notion, or any destination — all orchestrated visually in Make.

Example scenarios:

• New Airtable records → AI generates product descriptions → results saved back to Airtable
• Typeform submissions → AI drafts personalized responses → sent via Gmail
• RSS feed items → AI summarizes articles → posted to Slack channel
• Scheduled trigger → AI generates daily social media posts → queued in Buffer

How This Works (in plain English)

Convoy is asynchronous — when you POST a prompt, you don’t get the AI response back in the same request. Convoy batches your prompt with others, processes it, and then calls you back with the result later. That means a complete Make setup is two scenarios, one for each direction:

       ┌─ SCENARIO 1 (Sender) ─┐                ┌─ SCENARIO 2 (Receiver) ─┐
       │                       │                │                         │
You ─▶ │ New Sheet row         │ ──── POST ───▶ Convoy ──── POST ──▶ │ Custom Webhook ──▶ Save │
       │ → HTTP: Make a Request│                                     │ to Sheet/Slack/etc.     │
       └───────────────────────┘                                     └─────────────────────────┘
                  ↑                                                              │
                  │                                                              │
                  └────────────── Scenario 2's webhook URL ──────────────────────┘
                                  goes here as `callback_url`

You’ll build them in the same order the data flows: Step 1 sends the prompt, Step 2 catches the response, Step 3 wires them together. It’s normal for the very first Step 1 test to never produce a callback — Step 2 doesn’t exist yet. That’s expected.

Anatomy of the Convoy POST

This is the actual HTTP request Scenario 1 makes. The Make “HTTP — Make a request” module is just a visual wrapper around it — knowing this makes everything else click.

Endpoint: POST https://api.cnvy.ai/cargo/load

Headers:

Body (annotated):

{
  "params": {
    "model": "convoy-mock",             // ← test model — free, ~1 min, no charge
                                         //   Swap to "claude-3-haiku" etc. for production
    "max_tokens": 1024,                  // ← hardcoded
    "messages": [
      {
        "role": "user",
        "content": "{{2.Topic}}"        // ← MAPPED from Scenario 1's trigger module
                                         //   (e.g. the Sheet row's "Topic" column)
      }
    ],
    "system": "{{2.System Prompt}}"     // ← optional, mapped or hardcoded
  },
  "callback_url": "PASTE_AFTER_STEP_2"  // ← Scenario 2's Custom Webhook URL goes here.
                                         //   Leave as a placeholder for Step 1 — you'll
                                         //   come back and paste the real URL in Step 3.
}

The four things you fill in:

1. X-API-Key header — your Convoy project API key, once.
2. messages[0].content — mapped from a field your trigger module produces (the prompt itself).
3. params.model — keep as convoy-mock while testing.
4. callback_url — left as a placeholder for now. You’ll fill this in during Step 3, after Scenario 2 exists.

When Scenario 1 fires, Convoy responds immediately with a cargo_id (an acknowledgement). The actual AI text arrives later via POST to your callback_url — which is why Scenario 2 exists.

Prerequisites

• A Convoy account with an active project
• A project API key (starts with convoy_sk_) — see Authentication
• A Make account (free tier includes 1,000 operations/month)
• A trigger source — Google Sheets, Airtable, Typeform, RSS, schedule, or anything Make supports

Step 1: Build Scenario 1 — Send Prompts to Convoy

This is the scenario that watches your trigger source and POSTs each new prompt to Convoy. It’s the first thing in your data flow.

1a. Create a New Scenario

1. Go to make.com  and click Create a new scenario
2. Name it “Convoy — Send AI Prompts”

1b. Add Your Trigger Module

This is your source of new prompts.

Google Sheets example:

1. Add a Google Sheets → Watch Rows module
2. Connect your Google account
3. Select your spreadsheet and worksheet
4. Set the Limit to process rows in batches (e.g., 10 at a time)

Your sheet might look like this:

The trigger fields you pull in here (Topic, System Prompt) are what you’ll map into the Convoy POST body in the next step.

1c. Add an HTTP Module (Make a Request)

This module is the Convoy POST from the Anatomy section — you’re filling in those fields here.

1. Add an HTTP → Make a request module
2. Configure it:

URL:

https://api.cnvy.ai/cargo/load

Method: POST

Headers:

Body type: Raw

Content type: JSON (application/json)

Request content:

{
  "params": {
    "model": "convoy-mock",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "{{2.Topic}}"
      }
    ],
    "system": "{{2.System Prompt}}"
  },
  "callback_url": "https://example.com/placeholder-fill-in-step-3"
}

Map the values:

• {{2.Topic}} — Map to your trigger’s prompt/topic column
• {{2.System Prompt}} — Map to your system prompt column (or hardcode a default)
• model — keep as convoy-mock for testing
• callback_url — leave as the placeholder URL for now. You’ll come back and replace it in Step 3 after Scenario 2 exists. (A bogus URL won’t break Scenario 1 — Convoy still accepts the request.)

Also enable Parse response in the module settings so you can use the returned cargo_id in later modules.

1d. Test the Module

1. Click Run once to send a real request to Convoy
2. The HTTP module should return:

   {
     "cargo_id": "crg_abc123def456",
     "status": "success",
     "message": "Cargo loaded successfully"
   }

   This means Convoy received your prompt. The actual AI response is not in this response — it’ll arrive later via callback.
3. If you get an error, check:
   • Your API key is correct and active
   • The Content-Type header is exactly application/json
   • The body is valid JSON
   • The model is convoy-mock

1e. (Optional) Update the Source Row

After the HTTP module, add a Google Sheets → Update a Row module to mark the row as submitted:

1. Map the Row number from the trigger
2. Set the Status column to Submitted
3. Set a Cargo ID column to {{3.data.cargo_id}} (you’ll need this in Step 2 to find the row when the callback arrives)

1f. Activate Scenario 1

1. Toggle the scenario ON (bottom-left switch)
2. Set the schedule (e.g., every 15 minutes, or immediately on paid plans)

It’s now sending every new sheet row to Convoy. None of those results will reach you yet — that’s what Step 2 is for.

Step 2: Build Scenario 2 — Receive AI Results

This is the scenario that catches Convoy’s callback and routes the AI result back to your sheet (or wherever you want it).

2a. Create a New Scenario

1. Click Create a new scenario
2. Name it “Convoy — Receive AI Results”

2b. Add a Webhooks Trigger (Custom Webhook)

1. Click the + button to add a module
2. Search for Webhooks and select Custom webhook
3. Click Add to create a new webhook
4. Give it a name like “Convoy Callback Receiver”
5. Click Save — Make generates a unique URL like:

   https://hook.us1.make.com/abc123def456ghi789

6. Copy this URL. This is the value you’ll paste into Scenario 1’s callback_url in Step 3.

2c. Determine the Data Structure

Make needs to know the shape of incoming data. The simplest way is to paste a sample now so you can map fields without waiting:

1. Click Custom webhook → Redetermine data structure
2. Paste this sample payload and click OK:

{
  "cargo_id": "crg_abc123def456",
  "success": true,
  "response": {
    "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
    "type": "message",
    "role": "assistant",
    "content": [
      {
        "type": "text",
        "text": "Here is the generated content..."
      }
    ],
    "model": "convoy-mock",
    "stop_reason": "end_turn",
    "usage": {
      "input_tokens": 150,
      "output_tokens": 500
    }
  },
  "error": null
}

2d. Add a Router (Optional but Recommended)

If you want to handle successes and failures differently:

1. Add a Router module after the webhook
2. Create two paths:
   • Path 1 (Success): Filter where success equals true
   • Path 2 (Error): Filter where success equals false

2e. Add Your Destination Module

Where should the AI result go? Some popular choices:

Option A: Update the original Google Sheets row

1. Add a Google Sheets → Update a Row module
2. Look up the row by {{1.cargo_id}} (you wrote the Cargo ID into the sheet in Step 1e)
3. Map:
   • AI Response column → {{1.response.content[].text}}
   • Status column → Completed

Option B: Append a new row (simpler)

1. Add a Google Sheets → Add a Row module
2. Map:
   • Cargo ID → {{1.cargo_id}}
   • AI Response → {{1.response.content[].text}}
   • Model → {{1.response.model}}
   • Tokens Used → {{1.response.usage.output_tokens}}

Option C: Post to Slack

1. Add a Slack → Create a Message module
2. Set the message:

   ✅ AI Result Ready ({{1.cargo_id}})
   
   {{1.response.content[].text}}
   
   Model: {{1.response.model}} | Tokens: {{1.response.usage.output_tokens}}

Option D: Save to Notion

1. Add a Notion → Create a Database Item module
2. Map properties to the callback payload fields

2f. Activate Scenario 2

1. Toggle the scenario ON
2. Scheduling is automatically set to Immediately (the default for webhook triggers)

It’s now listening for callbacks from Convoy. But Convoy doesn’t know about it yet — that’s Step 3.

Step 3: Wire Them Together

The two scenarios are connected by one value: Scenario 2’s Custom Webhook URL (copied in Step 2b) goes into Scenario 1’s callback_url field. That’s the entire connection.

3a. Edit Scenario 1

1. Open Scenario 1 (the Sender)
2. Click the HTTP → Make a request module
3. In the Request content body, replace the placeholder callback_url with the real Custom Webhook URL from Step 2b:

   "callback_url": "https://hook.us1.make.com/abc123def456ghi789"

4. Click OK and Save the scenario

3b. Test the Full Pipeline

1. Add a new row to your Google Sheet with a prompt
2. Either wait for the schedule or click Run once on Scenario 1
3. Confirm Scenario 1 executed successfully (check the execution log — you should see a cargo_id)
4. Wait ~1 minute for the convoy-mock test model to finish processing
5. Confirm Scenario 2 fired — its execution log should show an incoming callback with the AI text
6. Verify the result arrived at your destination (Sheet, Slack, etc.)

If Scenario 1 fires but Scenario 2 doesn’t, the most common cause is a wrong callback_url — go back to 3a and re-paste the URL exactly from 2b.

3c. Switch to a Production Model

Once the full pipeline works end-to-end on convoy-mock, you can swap in a real model:

1. Open Scenario 1 → HTTP → Make a request
2. Change "model": "convoy-mock" to e.g. "model": "claude-3-haiku"
3. Save the scenario

Production models take longer (minutes to hours, depending on queue volume) and are billed based on tokens used.

Verifying Status

You can check the status of any request directly via the API:

curl -H "X-API-Key: convoy_sk_your_key_here" \
  https://api.cnvy.ai/cargo/crg_abc123def456/tracking

Status progression: PENDING → BATCHED → PROCESSING → COMPLETED → callback_delivered

If you see callback_failed, your callback_url was wrong, the receiver scenario was off, or the webhook timed out.

Advanced Configuration

Using Multiple Models

Pick a model that matches the workload:

See Supported Models for the full list.

Conditional Model Selection

Use Make’s ifempty function to default to convoy-mock when a column is blank:

{{ifempty(2.Model; "convoy-mock")}}

Error Handling with Router

Add robust error handling to Scenario 2:

[Webhook] → [Router]
                ├── Path 1 (success = true) → [Google Sheets: Update Row]
                └── Path 2 (success = false) → [Slack: Send Alert]

Set up the filters:

• Path 1 — success → Equal to → true
• Path 2 — success → Equal to → false

Using Make’s Data Store for Tracking

Track all submitted prompts and their results:

1. Create a Data Store in Make with these fields:

   • cargo_id (text, key)
   • prompt (text)
   • status (text)
   • result (text)
   • submitted_at (date)

2. In Scenario 1, after the HTTP module, add Data Store → Add/Replace a Record:

   • cargo_id: {{3.data.cargo_id}}
   • prompt: {{2.Topic}}
   • status: submitted
   • submitted_at: {{now}}

3. In Scenario 2, add Data Store → Update a Record:

   • Find by cargo_id: {{1.cargo_id}}
   • status: completed
   • result: {{1.response.content[].text}}

Rate Limiting with Sleep Module

If you’re processing many rows, add a Tools → Sleep module after the HTTP module:

1. Set the delay to 1 second
2. This stays within Convoy’s rate limits (60 requests/minute)

Temperature Control

Add a “Temperature” column to your sheet and map it:

{
  "params": {
    "model": "{{2.Model}}",
    "max_tokens": 1024,
    "temperature": {{ifempty(2.Temperature; 0.7)}},
    "messages": [
      {"role": "user", "content": "{{2.Topic}}"}
    ]
  },
  "callback_url": "https://hook.us1.make.com/..."
}

Callback Payload Reference

When Convoy finishes processing, it sends this payload to your webhook — i.e., this is what Scenario 2 receives:

{
  "cargo_id": "crg_abc123def456",
  "success": true,
  "response": {
    "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
    "type": "message",
    "role": "assistant",
    "content": [
      {
        "type": "text",
        "text": "Here is the generated content..."
      }
    ],
    "model": "convoy-mock",
    "stop_reason": "end_turn",
    "usage": {
      "input_tokens": 150,
      "output_tokens": 500
    }
  },
  "error": null
}

Key fields for Make mapping:

Make vs. Zapier

Troubleshooting

Scenario 1 succeeds but Scenario 2 never fires

Almost always a callback_url issue:

• Confirm Scenario 2 is active (toggle ON)
• Re-copy Scenario 2’s Custom Webhook URL and paste it back into Scenario 1’s HTTP module body (Step 3a) — make sure no quotes, spaces, or trailing slashes were lost
• Hit the tracking endpoint — callback_failed means the URL was wrong or the receiver timed out

”Invalid API key” error in HTTP module

• Verify your key starts with convoy_sk_
• Check that the key hasn’t been revoked in the Convoy dashboard
• Header name must be exactly X-API-Key (case-sensitive)
• No extra spaces in the header value

”Unknown model” error

• Use convoy-mock for testing, or check the Supported Models page
• Model IDs are case-sensitive (claude-3-haiku, not Claude-3-Haiku)

Result is taking a long time

• convoy-mock should return in ~1 minute. If it doesn’t, check the tracking endpoint
• Production models batch and may take minutes to hours — that’s normal

”Connection error” in HTTP module

• Verify the URL is https://api.cnvy.ai/cargo/load
• Check that the method is POST
• Ensure the body is valid JSON (use Make’s JSON validator)

Scenario runs but no data appears

• Check the execution log for each module — click on the bubble numbers
• Verify field mappings are correct (look for empty values)
• Ensure the data structure was properly detected in the webhook module

Rate limit errors (429)

• Add a Sleep module (1–2 seconds) between HTTP requests
• Reduce the batch size in your trigger module
• Convoy allows 60 requests per minute and 500 per hour per project

Make operations running out

• Each module execution counts as one operation
• A scenario with 4 modules processing 10 rows = 40 operations
• Process rows less frequently but in larger groups, or upgrade your Make plan

Tips for Production Use

1. Test on convoy-mock first. Always end-to-end test the full pipeline with the test model before swapping in a billed production model.
2. Add a “Cargo ID” column to your sheet. Write cargo_id from Scenario 1 into the row so Scenario 2 can update the correct row when the callback arrives.
3. Add a “Status” column updated by Scenario 2 (Submitted, Completed, Failed) so you can see what’s still in flight.
4. Enable error notifications — Scenario settings → Notifications → “If a scenario fails”
5. Set up incomplete executions — configure what happens when a module fails (retry, ignore, or break)
6. Use scenario blueprints — export a working scenario as a blueprint for backup or sharing
7. Monitor operations usage — keep an eye on your Make plan’s operation limits, especially with high-volume workflows