Skip to content
RocketLead Developers

Integrate with Make.com

Make.com (formerly Integromat) is a no-code workflow automation platform. This guide wires it up to RocketLead in both directions:

  • RocketLead → Make — fire a Make scenario whenever a lead lands or a booking is made, by adding an HTTP Request action to a RocketLead automation.
  • Make → RocketLead — push leads from Make into RocketLead by calling an Ingress webhook.

Both are covered below.

Direction 1: RocketLead → Make

Section titled “Direction 1: RocketLead → Make”

Trigger a Make scenario from any RocketLead automation event (Neuer Lead hinzugefügt, Termin gebucht, Leadstatus geändert, etc.). The bridge is RocketLead’s HTTP Request automation node and Make’s Webhooks trigger module.

Step 1 — Create a webhook trigger in Make

Section titled “Step 1 — Create a webhook trigger in Make”
  1. In Make, create a new scenario.
  2. Add a module → search Webhooks → pick Custom webhook.
  3. Click Add → name the webhook → Make generates a unique URL like https://hook.eu2.make.com/abc123def456....
  4. Copy this URL. Leave the Make tab open — Make needs to receive a sample request to learn the payload shape.

Step 2 — Create an automation in RocketLead

Section titled “Step 2 — Create an automation in RocketLead”
  1. In the RocketLead console, go to Automations → New automation.
  2. Add the trigger that should fire the Make scenario, e.g.:
    • Auslöser → Neuer Lead hinzugefügt — every time a lead is created in a chosen Lead Pool.
    • Auslöser → Neuer Termin gebucht — every time a booking is made.
    • Auslöser → Leadstatus geändert — every time a lead’s pipeline state changes.
  3. Configure the trigger’s filters (which Lead Pool, which appointment types, etc.).
  4. From the Aktionen sidebar, drag in HTTP Request and connect it to the trigger.

Step 3 — Configure the HTTP Request node

Section titled “Step 3 — Configure the HTTP Request node”

Click the HTTP Request node and fill it in:

FieldValue
MethodPOST
URLthe Make webhook URL from Step 1
Headers{"Content-Type": "application/json"} (optional — auto-added when a body is set)
Bodya JSON payload using {{...}} placeholders (see below)
Raw datesEnable for Make integrations

Step 4 — Build the body with placeholders

Section titled “Step 4 — Build the body with placeholders”

The body is a JSON template. Anything inside {{...}} is substituted with live data from the trigger.

Example for a Neuer Lead hinzugefügt trigger:

{
    "leadId": "{{<triggerNodeId>.tableEntry.id}}",
    "createdAt": "{{<triggerNodeId>.tableEntry.createdAt}}",
    "firstName": "{{<triggerNodeId>.tableEntry.data.firstName}}",
    "lastName": "{{<triggerNodeId>.tableEntry.data.lastName}}",
    "email": "{{<triggerNodeId>.tableEntry.data.email}}",
    "phone": "{{<triggerNodeId>.tableEntry.data.phone}}",
    "studio": "{{$studio.name}}"
}

Replace <triggerNodeId> with the actual ID of your trigger node (visible in the editor when the node is selected). The variable picker in the RocketLead editor builds these paths for you — drag a variable from the right-hand panel into the body to insert the placeholder.

Step 5 — Activate and test

Section titled “Step 5 — Activate and test”
  1. Save and activate the RocketLead automation.
  2. Trigger it once (e.g., create a test lead).
  3. Switch to Make — the webhook trigger now shows the captured payload. Click Determine data structure to lock in the schema.
  4. Build the rest of your Make scenario from there (route to a CRM, send Slack notification, write to a Google Sheet, etc.).

Available variables by trigger

Section titled “Available variables by trigger”

Each trigger exposes different objects. Common paths:

Neuer Lead hinzugefügt / Leadstatus geändert:

{{<id>.tableEntry.id}}
{{<id>.tableEntry.createdAt}}
{{<id>.tableEntry.leadStateId}}
{{<id>.tableEntry.data.<columnName>}}              // any data column
{{<id>.tableEntry.customFieldData.<customFieldId>}} // any custom field
{{<id>.previousLeadState.name}}                    // leadState changes only
{{<id>.newLeadState.name}}                         // leadState changes only

Neuer Termin gebucht / Termin beginnt / Termin endet / Termin gelöscht:

{{<id>.calendarBooking.id}}
{{<id>.calendarBooking.startDateTime}}
{{<id>.calendarBooking.endDateTime}}
{{<id>.calendar.name}}
{{<id>.appointmentType.name}}
{{<id>.resource.name}}
{{<id>.tableEntry.data.email}}                     // when booking is linked to a lead

Cross-trigger globals:

{{$studio.name}}
{{$studio.email}}
{{$studio.phone}}
{{$global.<varName>}}                              // set via the "Variable setzen" helper node

A typo in a placeholder path silently resolves to an empty string — no error is thrown. Test your scenarios end-to-end and check the captured Make payload to verify every field arrived.

Direction 2: Make → RocketLead

Section titled “Direction 2: Make → RocketLead”

Pushing data from Make into RocketLead is straightforward — use an Ingress webhook, no automation engine needed.

  1. In RocketLead → Settings → Ingress Webhooks → Create, pick the destination Lead Pool. Copy the URL and the token (shown once).
  2. In Make, add an HTTP module → Make a request:
    • URL: https://api.rocketlead.io/public/ingress_webhooks/<webhook-id>
    • Method: POST
    • Headers:
      • x-rocketlead-ingress-token: <token>
      • Content-Type: application/json
    • Body type: Raw → JSON, with whatever data you want to land in the Lead Pool: 
      {
          "data": {
              "firstName": "{{firstName}}",
              "lastName": "{{lastName}}",
              "email": "{{email}}",
              "phone": "{{phone}}",
              "source": "make-scenario"
          }
      }

The default lead state is applied automatically. The submission fires table.entry.added in RocketLead — your other automations run as if the lead came from any other channel.

For richer integrations (read leads, create bookings, update lead states), use the Connect API instead — Make’s HTTP module supports the Authorization: Bearer rocketlead_live_* header pattern natively.

Common gotchas

Section titled “Common gotchas”
SymptomCause
Make scenario receives an empty payloadPlaceholder path has a typo — resolves to empty string silently. Trigger the automation and check the Make scenario’s captured payload field-by-field.
Dates arrive as 12. Januar 2026 um 14:00 instead of ISO”Raw dates” toggle is off on the HTTP Request node. Enable it.
4xx / 5xx from Make’s webhook URLMake scenario isn’t active, or the URL is wrong. Check the URL in Make’s webhook settings.
Automation runs but Make never receivesNetwork failure on RocketLead’s side — these get retried automatically. Check the run history (flowRuns) in the console for the actual outcome.
Run history shows “retrying” foreverMake webhook returns 5xx repeatedly. Fix the Make scenario or rotate the webhook URL.

Caveats

Section titled “Caveats”
  • No HMAC signature. Make has no way to cryptographically verify the call came from RocketLead. Treat the webhook URL as a shared secret and rotate it (in Make → Webhook settings → Reset URL) if it leaks.
  • Max automation chain depth: 5. If a Make scenario calls back into RocketLead via the Connect API, which fires another flow, which calls Make again, etc. — once the chain hits depth 5 the next-level run is blocked. Keep cycles simple.
  • Headers must be valid JSON. Invalid JSON in the headers field returns 400 Invalid headers JSON format and the run records success: false (no retry).
Section titled “Related”