Make (Integromat) Integration Guide

Make (formerly Integromat) lets you connect Bearconnect to thousands of apps without writing code. Whenever a lead accepts a connection, a message is sent, or another tracked event occurs, Bearconnect sends a JSON payload to your Make Custom Webhook URL, which triggers a Make scenario. This is ideal for routing leads to CRMs, enriching contact data, sending notifications, and building multi-step automation workflows.

What You Need
Setting Up the Make Webhook
Connecting Make in Bearconnect
After Connecting
Connecting Make to a Campaign
Exporting Leads via Make
Payload Format
Testing Your Connection
Working with Data in Make
Use Cases
Managing Your Make Integration
Troubleshooting

Quick Start

Already familiar with Make? Here is the fastest path:

In Make: Create a scenario with Webhooks > Custom webhook trigger. Copy the webhook URL.
Toggle the scenario ON (this is required - inactive scenarios reject events).
In Bearconnect: Go to Integrations > Make > Connect. Paste the URL, select events, click Connect.
In Bearconnect: Click Test Connection to send sample data and trigger Make's data structure detection.
In Bearconnect: Open a campaign > Integrations tab > Connect Integration > select your Make integration and enable events.
In Make: Add modules after the webhook trigger and use the mapping panel to reference Bearconnect fields.

What You Need

A Bearconnect account with an active subscription.
A Make account (Free or paid plan).
A Make scenario with a Custom Webhook module as the trigger.

Setting Up the Make Webhook

Before connecting in Bearconnect, you need to create a Custom Webhook in Make to get a URL.

Log in to your Make account at make.com.
Click Create a new scenario.
Click the + button to add the first module.
Search for Webhooks and select the Webhooks app.
Choose Custom webhook as the trigger type.
Click Add to create a new webhook. Give it a name (e.g., "Bearconnect Events").
Click Save.
Make displays a URL in the format https://hook.{region}.make.com/... - copy this URL.
Toggle the scenario ON using the switch at the bottom of the scenario editor.

Important: The webhook URL must be on hook.*.make.com and must use HTTPS. Bearconnect will not accept URLs that do not match this pattern.

Important: The scenario must be toggled ON for Bearconnect to deliver events. If the scenario is inactive, Make returns a 400 error and deliveries will fail.

Connecting Make in Bearconnect

Go to Integrations in the left sidebar of your Bearconnect dashboard.
Find Make in the Available Integrations section and click Connect.
A dialog opens with the following fields:

Required Fields

Field	Description
Name	A label to identify this connection (e.g., "Make - Lead Routing").
Custom Webhook URL	The webhook URL you copied from Make (must be `https://hook.*.make.com/...`).

Event Selection

Choose which event types this integration is allowed to handle:

Category	Events
Connection Events	Connection Request Sent, Connection Accepted
Message Events	Message Sent, Message Replied

You can:

Click All to select every event.
Click None to clear the selection.
Expand a category to select individual events.
Use the category checkbox to toggle all events within that category.

Advanced Settings (Optional)

Click Advanced Settings to reveal additional options:

Setting	Default	Range	Description
Custom Headers	None	-	Add custom HTTP headers to every request sent to Make (e.g., `X-Source: bearconnect`).
Timeout (ms)	30000	5000–60000	How long to wait for Make to respond before marking the delivery as failed.

Click Connect.

After Connecting

Your Make integration now appears in the Connected Integrations section. Click on it to open the detail panel, which shows:

Webhook URL

Your configured Make webhook URL is displayed and can be copied with the copy button.

Status & Delivery Statistics

Status - Active or Error.
Delivered - Total number of successful deliveries.
Failed - Total number of failed deliveries.
Last Delivery - Timestamp of the most recent delivery.

If there is a recent error, the error message is displayed in red.

Allowed Events

A read-only list showing which event types this integration is configured to handle, organized by category.

Connection Details

When the integration was created.
Provider type (Make).
Integration ID.
Last updated timestamp.

Connecting Make to a Campaign

To receive events from a specific campaign, you must map the Make integration to that campaign.

Open a campaign from your dashboard.
Go to the Integrations tab.
Click Connect Integration.
Select your Make integration from the dropdown.
Choose which events to enable for this campaign (only events that are in the integration's allowed events list appear here).
Click Connect.

Managing the Mapping

On the campaign's Integrations tab:

Toggle switch - Pause or resume event forwarding.
Settings icon - Change which events are enabled for this campaign.
Trash icon - Remove the mapping (the Make integration itself is not deleted).

Exporting Leads via Make

You can manually export a lead to Make.

Go to the Leads page.
Find the lead you want to export and click the three-dot action menu on that row.
Click Export.
Select your Make integration from the dropdown.
Click Export.

The lead data is sent immediately as a JSON payload to your Make webhook URL, which triggers the scenario.

Payload Format

Every delivery to Make is an HTTP POST request with a JSON body. The payload format is identical to Custom Webhooks - all integration providers receive the exact same structure.

Event Payload

{
    "event": "connection_request_accepted",
    "timestamp": "2026-02-13T10:30:00.000Z",
    "data": {
        "lead": {
            "id": "65abc123def4567890ghij01",
            "firstName": "Jane",
            "lastName": "Smith",
            "email": "jane.smith@example.com",
            "phone": "+1-555-0123",
            "profileUrl": "https://www.linkedin.com/in/janesmith",
            "profileHeadline": "VP of Sales at Acme Corp",
            "profileImageUrl": "https://media.licdn.com/...",
            "position": "VP of Sales",
            "companyName": "Acme Corp",
            "location": "San Francisco, CA",
            "website": "https://acme.com",
            "education": "Stanford University",
            "publicIdentifier": "janesmith",
            "connectionCount": 500,
            "followerCount": 1200,
            "isPremium": true,
            "memberUrn": "urn:li:member:123456789",
            "stage": "connected",
            "createdAt": "2026-01-15T08:00:00.000Z"
        },
        "campaign": {
            "id": "65abc123def4567890ghij02",
            "name": "Q1 Outreach",
            "status": "running"
        },
        "linkedInAccount": {
            "id": "65abc123def4567890ghij03",
            "name": "Sales Team Account",
            "email": "john.smith@example.com"
        }
    },
    "metadata": {
        "eventId": "evt_abc123def456",
        "userId": "65abc123def4567890ghij04",
        "integrationId": "65abc123def4567890ghij05"
    }
}

Field Availability (Nullable Fields)

Not all lead fields are guaranteed to have a value. Only id and firstName are always present. All other lead fields may be null or absent depending on what data is available on the LinkedIn profile.

Field	Always Present?	Notes
`data.lead.id`	Yes	Bearconnect internal lead ID.
`data.lead.firstName`	Yes	Always available from LinkedIn.
`data.lead.lastName`	No	May be `null` if not available on LinkedIn.
`data.lead.email`	No	Only present if the lead's email has been found or enriched.
`data.lead.phone`	No	Only present if the lead's phone has been found or enriched.
`data.lead.profileUrl`	No	May be `null` in rare cases.
`data.lead.profileHeadline`	No	May be `null` if the lead has no LinkedIn headline.
`data.lead.profileImageUrl`	No	May be `null` if the lead has no profile photo.
`data.lead.position`	No	May be `null` if no current position is listed.
`data.lead.companyName`	No	May be `null` if no company is listed.
`data.lead.location`	No	May be `null` if no location is listed.
`data.lead.website`	No	May be `null` if no website is listed.
`data.lead.education`	No	May be `null` if no education is listed.
`data.lead.publicIdentifier`	No	The LinkedIn vanity URL slug. May be `null`.
`data.lead.connectionCount`	No	Defaults to `0` if not available.
`data.lead.followerCount`	No	May be `null` if not available.
`data.lead.isPremium`	No	Defaults to `false` if not available.
`data.lead.memberUrn`	No	LinkedIn member URN. May be `null`.
`data.lead.stage`	No	Bearconnect lead stage. May be `null`.
`data.lead.createdAt`	No	ISO timestamp. May be `null`.
`data.campaign`	No	May be absent if the event is not campaign-specific.
`data.linkedInAccount`	No	May be absent if no LinkedIn account is associated.
`data.linkedInAccount.email`	Yes (if present)	Login email of the LinkedIn account used for outreach.

Tip: In Make, use the ifempty() function in field mappings to provide fallback values for nullable fields. For example: {{ifempty(1.data.lead.email; "no-email@placeholder.com")}}.

Lead Export Payload

When you manually export a lead, the payload follows the same structure. The event field is set to lead_added_to_campaign.

HTTP Headers

Every request to Make includes:

Header	Value
`Content-Type`	`application/json`
`User-Agent`	`Bearconnect/1.0`
Custom headers	Any headers you configured in Advanced Settings.

Testing Your Connection

Testing serves two purposes: it verifies that Bearconnect can reach your Make webhook, and it triggers Make's data structure detection so Make knows the shape of the incoming data.

Go to Integrations in the left sidebar.
Click on your Make integration to open the detail panel.
Click Test Connection.
If successful, you will see "Test successful" with the HTTP status code (e.g., 200).
If it fails, the error message will indicate the problem (timeout, connection refused, non-2xx status code, etc.).

The test sends a real payload to your Make webhook. After a successful test, go back to Make - the Custom Webhook module will show "Successfully determined" with the detected data structure. This allows you to use the mapping panel in subsequent modules.

Tip: If you add the Make integration and skip the test, Make will not know the data structure. You can still run the scenario, but the mapping panel will be empty until Make receives at least one request.

Working with Data in Make

Data Structure Detection

After the first successful test or live event, Make automatically detects the payload structure. You will see this in the Custom Webhook module as "Successfully determined." From that point on, all fields are available in the mapping panel of subsequent modules.

Referencing Fields in Modules

In any module after the Custom Webhook trigger, use the mapping panel to select fields. The fields follow the payload structure:

Make Field Path	Example Value
`event`	`connection_request_accepted`
`timestamp`	`2026-02-13T10:30:00.000Z`
`data.lead.firstName`	`Jane`
`data.lead.lastName`	`Smith`
`data.lead.email`	`jane.smith@example.com`
`data.lead.companyName`	`Acme Corp`
`data.lead.profileUrl`	`https://www.linkedin.com/in/janesmith`
`data.lead.profileHeadline`	`VP of Sales at Acme Corp`
`data.lead.position`	`VP of Sales`
`data.lead.location`	`San Francisco, CA`
`data.lead.stage`	`connected`
`data.campaign.name`	`Q1 Outreach`
`data.campaign.status`	`running`
`data.linkedInAccount.name`	`Sales Team Account`
`data.linkedInAccount.email`	`john.smith@example.com`
`metadata.eventId`	`evt_abc123def456`

Using Routers and Filters

Make's Router module lets you send data down different paths based on conditions. For example:

Route connection_request_accepted events to a CRM module.
Route message_replied events to a Slack notification module.
Filter by data.campaign.name to handle different campaigns differently.

Use Cases

Route Leads to Different CRMs by Campaign

Use a Router module after the Custom Webhook trigger. Add a filter on each path that checks data.campaign.name, then connect each path to the appropriate CRM module (HubSpot, Salesforce, Pipedrive, etc.).

Enrich Leads Before Adding to CRM

Chain modules in sequence: Custom Webhook trigger, then a Clearbit or Apollo enrichment module using data.lead.email, then a CRM module that combines the Bearconnect data with the enriched data.

Send Slack Notifications When Leads Reply

Add a filter after the Custom Webhook trigger that checks for event equals message_replied. Connect it to a Slack module that posts a message like: "Jane Smith from Acme Corp replied to your Q1 Outreach campaign."

Multi-Step Workflows

Build scenarios that react to sequential events. For example: when a connection is accepted, add the lead to a Google Sheet. When a message reply comes in later, update the same row and send a Slack notification to the sales team.

Visual Lead Qualification Pipeline

Take advantage of Make's visual scenario builder to create a qualification pipeline:

Custom Webhook trigger receives a Connection Accepted event.
Router module splits the flow by data.lead.companyName or data.lead.position.
Path A: Enterprise leads (VP, Director, C-level in title) go to your CRM with a "High Priority" tag.
Path B: All other leads go to a Google Sheet for batch review.
Add a Slack notification on Path A so your sales team is alerted immediately.

This visual approach makes it easy to adjust routing rules without writing code.

Managing Your Make Integration

Editing the Integration

To change the name, URL, events, or other settings:

Go to Integrations in the left sidebar.
Click on the Make integration you want to edit.
Make your changes in the detail panel.
Save.

Deleting the Integration

Go to Integrations in the left sidebar.
Click on the Make integration you want to delete.
Click Delete and confirm.

When you delete a Make integration:

All campaign mappings using it are removed.
Event forwarding stops immediately.
Delivery history is no longer tracked.

Troubleshooting

"Make webhook expired (410)"

Make webhook URLs expire after 5 days of inactivity. When this happens, Make returns a 410 Gone response and deliveries fail.

To fix:

Open your scenario in Make.
Click on the Custom Webhook module.
The webhook may show as expired. Click to re-enable it or create a new webhook.
If the URL changed, update it in the Bearconnect integration settings.
Toggle the scenario back ON.

"Make scenario is inactive (400)"

Make returns a 400 error when the scenario is not running.