How to Integrate Keap SMS & Chat Automation with Make.com for Recruiting

To integrate Keap SMS and chat automation with Make.com for recruiting, map your pipeline events to trigger points, configure Keap webhooks to fire outbound HTTP posts, build Make.com scenarios with opt-in checks and Twilio SMS modules, and log every send back to the contact record for full communication history.

What This Integration Does and Who It’s For

Email alone is not enough. Candidates read texts within minutes and ignore recruiting emails for days. This guide shows exactly how to connect Keap to SMS gateways and chat platforms using Make.com — building automated touchpoints that fire at every meaningful pipeline stage without manual recruiter effort.

This integration is for recruiting teams already using Keap as a CRM who want to layer real-time SMS outreach on top of their existing pipeline without rebuilding their entire stack. If you are evaluating whether Make.com is the right platform for this work, the Make.com FAQ for Zapier users covers the core capability questions before you commit. For teams new to scenario-based automation, building a Make scenario with Claude removes most of the technical barrier.

Recruiters who build this stack report direct reductions in interview no-shows and candidate ghosting — two of the highest-cost problems in high-volume hiring pipelines. Nick, a recruiter at a small firm, reclaimed 15 hours per week and eliminated more than 150 hours per month of manual follow-up across his team of three after implementing a comparable automated outreach architecture. See how Nick cut six manual handoffs with one Make workflow for the full account.

What You Need Before You Start

This integration assumes a working Keap CRM with defined pipeline stages, at minimum one active tag-based automation, and a Make.com account at the Core plan or above — webhooks are required at this tier. You also need an active SMS gateway account. Twilio is the recommended gateway for its two-way messaging support and native Make.com module.

• Tools required: Keap (any paid tier), Make.com (Core plan or above), Twilio or ClickSend account, optional chat platform with outbound webhook support
• Keap prerequisites: Defined pipeline tags for each candidate stage — for example, Application Received, Interview Scheduled, Offer Extended — plus at least one native Keap automation per stage capable of firing a webhook
• Compliance prerequisite: SMS opt-in consent stored as a Keap custom field or tag for every contact before any SMS scenario runs — TCPA compliance is non-negotiable and must be confirmed at the scenario level, not assumed
• Estimated time: 3–5 hours for a three-scenario basic stack; 8–15 hours for a full multi-channel build
• Key risk: A misconfigured filter step sends SMS messages to unintended contacts — always test on a sandbox contact before activating in production

If your Keap pipeline tags are inconsistently applied or your stage definitions are unclear, fix that first. Automation built on a messy pipeline produces messy outreach. The OpsMap™ audit process is the right pre-build step for teams whose pipeline hygiene is uncertain.

Step 1: Map Your Pipeline Events to SMS and Chat Triggers

Before opening Make.com or your SMS gateway, document every candidate-facing event in your Keap pipeline that warrants a real-time outreach. These become the trigger points for your scenarios.

Open a spreadsheet and list each pipeline stage in column A. In column B, write the Keap tag that signals entry into that stage. In column C, write the specific message the candidate should receive — not a generic template, a real message tied to that stage. In column D, note whether the outreach should be SMS, chat, or both.

A minimal recruiting pipeline yields five to eight trigger points worth automating:

• Application Received → SMS: “Thanks [First Name] — we received your application for [Role]. Expect to hear from us by [Date].”
• Interview Scheduled → SMS: “Your interview is confirmed for [Date/Time]. Reply YES to confirm or RESCHEDULE to request a new time.”
• 24-Hour Interview Reminder → SMS: Triggered by a time-delay automation in Keap, not a tag change
• Application Under Review → SMS or chat follow-up if no engagement after 72 hours
• Offer Extended → SMS: Personalized congratulatory message with next-step link
• Application Closed (Not Selected) → SMS: Respectful close with optional talent community invite

Rank these by candidate drop-off risk. Application confirmation and interview reminders have the highest ROI because they directly reduce no-shows and ghosting. Build those first.

Step 2: Configure Keap Webhooks to Signal Make.com

Make.com cannot poll Keap efficiently at scale. The correct architecture uses Keap’s native automation builder to fire an outbound webhook the moment a pipeline event occurs. Use one webhook URL per scenario — do not share endpoints across scenario types, as mixing payloads creates mapping errors that are hard to debug.

1. In Make.com, create a new scenario. Add a Webhooks → Custom Webhook module as the trigger. Copy the generated webhook URL.
2. In Keap, open Automation → Campaign Builder. Create or edit the automation for your first trigger event — for example, the tag “Interview Scheduled” applied.
3. Add a Send HTTP Post action to the automation sequence. Paste the Make.com webhook URL into the endpoint field.
4. Map the Keap merge fields required in the SMS — at minimum: Contact ID, First Name, Email, Phone, and any stage-specific fields such as Interview Date/Time. Send these as JSON in the POST body.
5. Save and activate the Keap automation. Back in Make.com, run the webhook module and apply the tag to a test contact in Keap to capture a sample payload. Make.com auto-maps the incoming fields.

Repeat this process for each pipeline trigger mapped in Step 1. For teams building multiple scenarios simultaneously, setting up routed error handling in Make.com prevents a single failed webhook from silently breaking the entire stack.

Step 3: Build the SMS Sending Scenario in Make.com

With the webhook trigger live and payload captured, build the rest of the scenario. The structure is: Webhook → Opt-In Check → Router → SMS Send → Tag Update → Error Handler.

1. Add a Keap “Get a Contact” module after the webhook trigger, using the Contact ID from the webhook payload. This pulls the full, current contact record including custom fields and tags. Do not rely solely on the webhook payload data, which reflects the state at fire time and may be stale.
2. Add a Router module. The first route checks the SMS opt-in field: if the opt-in flag is false or empty, route to a “Log No SMS — No Consent” path that updates a Keap note and stops. Never proceed past this check without confirmed consent.
3. On the opted-in route, add a Twilio “Send an SMS” module. Map the recipient phone number from the Keap contact record. Build the message body using the mapped fields from the webhook payload — First Name, Role, Date/Time — to produce a genuinely personalized message, not a generic blast.
4. Add a Keap “Apply Tag” module after the SMS send step. Apply a tag such as “SMS Sent — Interview Reminder” to the contact. This tag acts as a state flag that prevents duplicate sends if the scenario runs again for the same contact.
5. Add a Keap “Create a Note” module to log the SMS content and timestamp on the contact record. This preserves the full communication history in Keap regardless of what happens in external platforms.
6. Add an error handler route at the scenario level. Configure it to catch Twilio delivery failures, log the error details to a Keap note, and apply a “SMS Failed — Retry” tag so the contact is flagged for manual follow-up. Silent failures are the most dangerous failure mode in candidate communication automation.

For teams building this without a developer, these automations are now buildable without developer support using Make.com’s visual builder and AI-assisted module configuration.

Step 4: Add Two-Way SMS Handling for Candidate Replies

One-way SMS is useful. Two-way SMS closes the loop. When a candidate replies YES or RESCHEDULE to an interview confirmation, that reply should trigger an action in Keap — not sit unread in a Twilio inbox.

1. In Twilio, configure your SMS number to forward inbound messages to a Make.com webhook URL. In Make.com, create a separate scenario with a Webhooks trigger to receive these inbound payloads.
2. Add a Text Parser or Router module to evaluate the reply body. Define routes for expected keywords: YES, CONFIRM, RESCHEDULE, STOP, CANCEL.
3. For a YES/CONFIRM reply: add a Keap “Apply Tag” module to apply “Interview Confirmed — Candidate Reply” and a Keap “Create a Note” to log the confirmation with timestamp.
4. For a RESCHEDULE reply: add a Keap tag for “Reschedule Requested” and trigger a follow-up task assigned to the recruiter. Optionally, send an automatic SMS reply with a scheduling link.
5. For a STOP reply: immediately apply a Keap tag removing SMS consent and send no further automated texts to that contact. This is a legal requirement under TCPA, not an optional courtesy.
6. For unrecognized replies: log the message to a Keap note and create a recruiter task to review and respond manually.

Step 5: Layer in Chat Platform Touchpoints

For recruiting teams using Slack, Microsoft Teams, or a web chat widget as candidate-facing channels, the same Keap webhook architecture supports chat notifications with a module swap. Replace the Twilio SMS module with the appropriate chat connector in Make.com.

• Internal recruiter notifications: When a high-priority candidate hits a specific pipeline stage, fire a Slack message to the assigned recruiter with candidate name, role, and a direct link to the Keap contact record. This replaces email notifications that get buried.
• Candidate-facing chat: If your careers page uses a chat widget with webhook support, Make.com can push a personalized status update when a candidate’s application advances. Confirm the widget vendor supports outbound webhook triggers before building this path.
• Cross-channel deduplication: Apply a “Chat Notified” tag in Keap after each chat send, parallel to the “SMS Sent” tag pattern from Step 3. This prevents candidates from receiving the same message across both channels simultaneously.

Teams managing complex multi-channel outreach at scale benefit from a structured workflow audit before building additional layers. The OpsMap™ discovery framework identifies which channels and touchpoints to automate first based on actual drop-off data, not assumptions.

Step 6: Test Every Scenario Before Going Live

Automation testing in recruiting is not optional — a misconfigured scenario that sends 50 candidates the wrong message at 2 AM is a brand and legal problem, not just a technical one. Follow this testing sequence before activating any scenario in production.

1. Create a dedicated sandbox contact in Keap with your own mobile number in the phone field and a clearly fake name. Apply each pipeline tag manually and verify the correct SMS fires with the correct merged fields.
2. Test the opt-in gate explicitly. Remove the SMS consent flag from the sandbox contact and apply the trigger tag again. Confirm the scenario routes to the “No Consent” path and no SMS is sent.
3. Test the duplicate prevention tag. Apply the trigger tag a second time after the first scenario run. Confirm the “SMS Already Sent” tag blocks the second send.
4. Test the error handler. Temporarily enter an invalid phone number and run the scenario. Confirm the error is caught, logged to a Keap note, and the retry tag is applied.
5. Test two-way reply handling by sending a reply from the sandbox number for each keyword route: YES, RESCHEDULE, STOP, and a random unrecognized string. Verify each routes correctly in Make.com and updates Keap as expected.
6. Review the scenario execution log in Make.com after each test run. Confirm all modules show green status and all field mappings resolved correctly with no null values.

Reviewing AI-built or rapidly assembled scenarios before production is a discipline with a specific checklist. The guide on evaluating a Make scenario before it goes to production covers the exact checks to run.

How to Know It Worked

A functioning Keap SMS automation stack produces observable, measurable signals within the first two weeks of production operation:

• SMS delivery confirmations appear in Twilio’s message log for every outbound send, with delivered status — not just sent status
• Keap contact records show the “SMS Sent — [Stage]” tags applied after each scenario run and timestamped notes with the exact message content
• Interview confirmation rates improve within the first two to three hiring cycles — the gap between scheduled interviews and actual attendees narrows when candidates receive a text confirmation and a 24-hour reminder
• Recruiter manual outreach volume drops — the team sends fewer individual confirmation texts and follow-up emails because the scenarios handle them automatically
• No duplicate sends appear on any contact record — the deduplication tags are working if you never see two identical timestamped SMS notes on the same contact for the same pipeline stage
• Two-way replies are logged in Keap within seconds of receipt, with recruiter tasks created for any reply requiring human follow-up

If delivery rates are low, the problem is almost always phone number formatting. Twilio requires E.164 format (+1XXXXXXXXXX for US numbers). Build a Make.com text formatter step between the Keap contact pull and the Twilio send to normalize phone numbers before they reach the SMS module.

Common Mistakes to Avoid

These are the errors that appear most frequently in first builds of this integration — not edge cases, but predictable failure points that every team hits without forewarning.

• Skipping the opt-in gate entirely. Some teams treat the TCPA compliance check as an optional filter and plan to add it later. There is no “later” — build the consent gate before the first SMS module in every scenario, without exception.
• Using the webhook payload as the source of truth. The webhook fires at the moment of tag application. If a recruiter updates the contact record a second later, the webhook payload is already stale. Always use a “Get a Contact” module after the webhook trigger to pull current data.
• Sharing webhook URLs across scenarios. One webhook endpoint per scenario type. A shared endpoint that receives payloads from both “Application Received” and “Offer Extended” automations will produce field mapping collisions that are extremely difficult to debug in production.
• Building outbound SMS without building inbound reply handling. Every outbound message that invites a reply — YES/RESCHEDULE prompts especially — requires a corresponding inbound scenario. Deploy both together.
• Not logging SMS sends back to Keap. If the message history lives only in Twilio, recruiters working in Keap have no visibility into what candidates received. Every send gets a Keap note.
• Testing only the happy path. Most teams test the scenario with a valid opted-in contact and call it done. Test the no-consent path, the duplicate prevention path, and the error handler before activating in production.

For teams evaluating whether to build this stack internally or work with a specialist, the DIY vs. Make partner decision guide maps the tradeoffs honestly based on team technical capacity and pipeline complexity.

Frequently Asked Questions

Does this integration work with any SMS gateway, or is Twilio required?

Make.com has a native Twilio module, which makes Twilio the lowest-friction choice. ClickSend also has a Make.com module and works for one-way sends. Any gateway with an API accessible via Make.com’s HTTP module is technically compatible, but two-way reply handling requires a gateway that supports inbound webhook forwarding to a Make.com URL — confirm that capability before selecting an alternative.

What happens if a candidate has no phone number in Keap?

The scenario hits the Twilio module with a null phone value and fails. Prevent this by adding a filter step after the “Get a Contact” module: if the phone field is empty, route to a “No Phone — Skip SMS” path that creates a Keap note and optionally sends an email instead. Never let a null field reach the SMS send module.

How do I handle candidates who opt out mid-pipeline?

When a candidate replies STOP or an equivalent opt-out keyword, the inbound reply scenario removes the SMS consent tag and applies a “SMS Opt-Out” tag in Keap. Every outbound scenario checks for the consent tag before sending. Once the opt-out tag is applied, no subsequent scenario sends an SMS to that contact — the consent gate blocks it automatically.

Can this architecture support multiple roles or departments with different message templates?

Yes. The most scalable approach uses Keap custom fields to store role name, department, and hiring manager name, then references those fields in the Make.com message body template. One scenario handles all roles — the message content personalizes dynamically based on what is stored on the contact record. Separate scenarios per role only become necessary when the trigger logic or timing differs substantially between roles.

How many Make.com operations does this stack consume per candidate?

A basic three-scenario stack (application confirmation, interview scheduled, interview reminder) runs approximately 8–12 Make.com operations per candidate per touchpoint: webhook trigger, contact lookup, router evaluation, SMS send, tag apply, and note create. At typical recruiting volumes for a small team, this is well within the Make.com Core plan operation limits. Monitor consumption in the Make.com dashboard and upgrade the plan before hitting limits, not after.

Additional Reading

• What Is a Make Scenario? The Plain-English Guide for Zapier Users
• How to Build a Make Scenario With Claude: A Step-by-Step Walkthrough
• How to Set Up Routed Error Handling in Make With AI Assistance
• How to Evaluate a Make Scenario Built by AI Before It Goes to Production
• How to Run an OpsMap Audit Before Automating Anything
• What Is OpsMap? The Discovery Step That Prevents Automation Mistakes
• How Nick Cut 6 Manual Handoffs From Proposal Generation With One Make Workflow
• DIY Automation vs. Hiring a Make Partner in 2026: When to Do Each
• Make.com FAQ: Everything Zapier Users Ask Before Switching
• 10 Automations That Are Finally Easy to Build With Make + AI — No Developer Needed
• 7 Questions to Ask Before You Automate Anything (The OpsMap Checklist)
• AI-Assisted Make Builds vs. Manual Builds (2026): Which Is Better for Your Automation?
• Recruiting Automation: Transforming Hidden Costs into Measurable ROI
• How HR Can Fix Broken Hiring Processes: Reducing Candidate Frustration Without Slowing Down the Business
• What Is Automation-First? Why You Should Automate Before You Add AI