Rémi KokabiNovember 4, 20267 min read

Make and lemlist integration, native sync and MCP workflows

A lead fills out your demo form at 11pm. The data lands in Make. HubSpot gets updated. Nobody tells lemlist. The sequence that should start that night waits until a rep opens their laptop the next morning, if they remember to check at all.

This happens because the make lemlist integration runs great for data sync but needs someone to design the logic that turns a trigger into outreach. Most teams never get past the native connection to build the flows that actually catch replies, route leads, or fix themselves when something breaks.

I’ll show you how to use the lemlist MCP alongside Make to close that gap. You’ll get prompts you can copy right now to route replies to Slack and HubSpot, add form leads to campaigns automatically, and debug a flow that stopped working without digging through scenario logs yourself.

This matters because every hour a lead sits unrouted is an hour your competitor might already be talking to them.

Native integration or MCP, what each one does

lemlist connects natively with Make through a built-in Make integration that syncs data between both platforms on a schedule or trigger you define. The MCP adds a conversational layer on top: you describe what you need, and an AI agent configures the lemlist side (webhooks, campaigns, lead imports) and the Make side together, from the same chat window.

The native integration runs in the background once you set it up. It watches for events in lemlist (a reply, an unsubscribe, a new activity) and pushes data into Make scenarios, or pulls data from other apps into lemlist campaigns. The MCP does something different. It lets an agent read both tools, cross-check what exists, and build or adjust automations on demand. One runs continuously, the other runs when you ask.

Here is how they compare side by side:

Native integration

MCP

What it does

Syncs data between lemlist and Make through triggers and actions

Lets an AI agent read, create, and update automations in both tools from a conversation

When it runs

Continuously, on a schedule or event trigger

On demand, when you prompt the agent

Who sets it up

You, inside the Make scenario builder

The agent, guided by your prompt in Claude, ChatGPT, or Cursor

Best for

Ongoing data flows (lead sync, reply routing, CRM updates)

Designing new flows, debugging broken ones, one-off cross-checks

The MCP does not replace the native integration. It gives you a faster way to build, test, and fix the automations that rely on it.

What you need before you start

  • The lemlist MCP connected in Claude, ChatGPT, or Cursor. If you have not done this yet, follow the guide on how to set up the lemlist MCP.

  • The Make MCP connected in the same client. Make is a built-in connector on Claude, so you can add it in a few clicks through the Connectors settings. For other clients, paste the Make MCP server URL and authenticate with OAuth or an API key.

  • Permissions scoped to what your use cases need. Both MCPs let you choose which actions the agent can access. Grant only the scopes you plan to use.

Start with read-only prompts. Ask the agent to list your Make scenarios or pull lemlist campaign stats before you let it create or edit anything. That way you confirm both connections work and see exactly what the agent can access.

1. Route every reply to the right place

Positive replies sit in the inbox until someone manually checks, copies the contact, and updates the CRM. That delay costs you. Leads contacted the same day as a signal reply at 21.3%, against 8.1% after a week, according to lemlist internal data. Every hour between a reply and a follow-up action shrinks your odds of booking a meeting, which is why speed to lead matters so much.

Copy this prompt into your AI client with both MCPs connected:

Create a lemlist webhook for replies and build a Make flow that sends positive ones to HubSpot and posts them in Slack.

The agent registers a webhook in lemlist that fires on every reply event. Then it builds a Make scenario that receives the webhook payload, filters for positive sentiment, creates or updates a contact in HubSpot, and posts a summary in a Slack channel you specify. You get the full flow without switching between tabs.

Before you turn this on for your full list, check that the webhook URL in lemlist matches the one in the Make scenario, and confirm the HubSpot field mapping is correct by running it on a single test reply.

2. Add leads from a form automatically

Inbound demo requests land in a CRM, but nobody adds them to an outreach sequence. The lead waits in a queue while your reps work through yesterday’s list. By the time someone reaches out, the prospect has already talked to a competitor.

Copy this prompt:

Build a Make flow that adds every new demo form submission to lemlist campaign X within minutes.

The agent creates a Make scenario with your form tool (Typeform, HubSpot Forms, or whatever you use) as the trigger. It maps the form fields to lemlist lead fields and adds each submission to the campaign you name. If the campaign does not exist yet, the agent can create it in lemlist with the sequence steps you describe.

Before letting it run on live submissions, verify the field mapping by submitting a test entry and confirming the lead appears in the correct lemlist campaign with the right data.

3. Debug a broken automation

A Make scenario that was adding leads to lemlist stops working. No error email, no alert. You only notice when pipeline numbers drop and someone asks why no new leads entered the sequence this week.

Copy this prompt:

Look at my Make flow that adds leads to lemlist, tell me why leads stopped arriving yesterday, and fix it.

The agent reads the recent execution history in Make, checks for failed runs or skipped modules, and cross-references with lemlist to see when the last lead was added. It might find an expired API key, a changed campaign ID, or a filter that started catching every record. Once it identifies the issue, it proposes a fix and can apply it if you approve.

Before letting the agent push the fix to production, review the proposed change and run the scenario manually on one record to confirm leads flow through again.

Guardrails when an agent works in lemlist and Make

Giving an agent write access to two tools at once is powerful, but it needs boundaries. Follow these rules:

  • Review every campaign the agent creates before you launch it. The agent can build sequences across email, LinkedIn, calls, and WhatsApp, but you should read the copy and check the timing before any message goes out.

  • Test on 10 leads first. Run the full flow on a small batch, confirm the data lands correctly in both tools, then scale up.

  • Keep unsubscribes and exclusion lists active. The agent respects these lists when adding leads, but verify they are turned on in your lemlist account before any automation runs.

  • Limit who on the team can connect the MCPs. Not every rep needs agent-level write access to Make scenarios and lemlist campaigns. Restrict MCP connections to ops leads or admins.

  • Log what the agent changed. After each session, ask the agent to summarize every action it took. Save that summary so you have an audit trail if something breaks later.

These guardrails apply whether you are routing replies, importing leads from forms, or debugging a broken flow. The agent moves fast, so your review process needs to keep up.

Run it in lemlist

The lemlist MCP server works in Claude, ChatGPT, and Cursor. Once connected, the agent can do more than manage Make automations.

It can search the People database (650M+ contacts, 65M+ companies), enrich leads with waterfall enrichment across 14+ providers, and create campaigns with sequences across email, LinkedIn, calls, and WhatsApp. It reads the unified inbox and campaign stats so you can audit performance from the same chat. And it can act on intent signals, adding leads to campaigns the moment a buying signal fires.

When you combine the lemlist MCP with the Make MCP, you get an agent that finds the right leads, builds the outreach, and wires the operational plumbing between your tools. For a full walkthrough of what the agent can do on the lemlist side, see the lemlist MCP use cases.

If you want to explore other automation platforms alongside Make, lemlist also connects with tools like n8n for outbound automation with n8n.

Final takeaway

The Make and lemlist integration gives you continuous data sync between your automation layer and your outreach platform. The MCP adds a conversational shortcut: describe what you need, and an agent builds, tests, or fixes the flow across both tools. Together, they remove the manual work that sits between a signal and a sent message.

Build your first signal-based sequence in lemlist.

Launch AI outbound campaigns

Automate prospecting and personalize AI-powered sequences to book more meetings.

Frequently asked questions

Keep both. The native integration syncs data continuously. The MCP lets an agent cross-check both tools and act on demand. They solve different problems and work better together.

Any client that supports remote MCP servers, such as Claude, ChatGPT, or Cursor, with both the lemlist and Make servers connected.

It can create and update campaigns, but review each campaign before launch and test on a small batch first. The agent builds fast, so your review step is the quality gate.

No. You connect both MCP servers in your AI client, then write your requests in plain language.
Rémi Kokabi

Rémi Kokabi

Co-founder @GTM Club

Share this post