How to Set Up Real-Time Keap Automation: Webhooks & Make.com™ Integration

Keap’s internal automation is built around events that happen inside Keap. A form submission, a tag applied, an invoice paid — these fire reliably. But the moment a candidate interacts with anything outside Keap — a third-party job board, an external assessment, a custom landing page — the automation chain breaks. The fix is a webhook-driven Make.com™ scenario that catches external events the instant they fire and writes the result directly into Keap. This guide shows you exactly how to build that connection, step by step. It is one focused implementation within the broader strategy covered in our Integrate Make.com and Keap: The Complete Guide to Recruiting Automation.

According to Asana’s Anatomy of Work research, knowledge workers spend more than a quarter of their week on work about work — status updates, manual data moves, and duplicate entry. Webhook-triggered automation attacks that category directly. When your automation platform detects a candidate event the moment it happens, your recruiters never touch that data manually.

Before You Start

Before building the scenario, confirm you have everything in place. Missing any of these will stall the build mid-step.

• Active Make.com™ account with at least a Core plan (Instant Trigger / webhook modules require a paid plan on most configurations).
• Keap account with API access — you’ll need a Keap API key or an active OAuth connection inside Make.com™.
• Admin access to the external system that will send the webhook (your job board, form tool, ATS, or custom app).
• A test environment or sandbox record in the sending system so you can fire real events without polluting live candidate data.
• 15–30 minutes for initial setup; 30–60 minutes if payload mapping is complex.
• Risk acknowledgment: Webhook scenarios run continuously. An error in production silently drops data unless you add error handling — which Step 6 covers. Do not skip it.

Step 1 — Create a New Make.com™ Scenario and Add a Webhook Trigger

The webhook URL is the entry point for all external data. Generate it first before touching the sending system.

1. Log into Make.com™ and click Create a new scenario.
2. Click the large + icon to add your first module.
3. Search for Webhooks in the module library and select it.
4. Choose Custom webhook (not “Custom mailhook” or any other variant).
5. Click Add to create a new webhook, give it a descriptive name (e.g., “Keap — External Candidate Intake”), and click Save.
6. Make.com™ generates a unique webhook URL. Copy it immediately. This URL is the address your external system will POST data to.

At this stage, the scenario is paused, waiting for its first payload. Do not click Run yet — you need to send a real payload first so Make.com™ can detect the data structure.

Step 2 — Configure the External System to Send the Webhook

Every sending system has a different webhook configuration interface, but the core requirement is identical: POST a JSON payload to the Make.com™ webhook URL when the target event fires.

1. Navigate to the webhook or integration settings in your external system (job board, form builder, ATS, or custom application).
2. Paste the Make.com™ webhook URL into the destination field.
3. Set the trigger event — for example: “New application submitted,” “Assessment completed,” or “Form filled.”
4. Set the payload format to JSON if the system allows format selection.
5. If the system supports custom headers, add a secret token header (e.g., X-Webhook-Secret: your-token-here). You’ll validate this in Step 3.
6. Save the configuration in the external system.

Do not trigger the test event yet — wait until Make.com™ is actively listening in the next step.

Step 3 — Capture a Real Payload to Define the Data Structure

Make.com™ cannot map fields it hasn’t seen. Sending a real payload lets the platform auto-detect your JSON schema and make every field available in subsequent modules.

1. Return to your Make.com™ scenario. The webhook module should show a message like “Waiting for data…”
2. In your external system, fire a real test event — submit an actual test application, complete a test assessment, or trigger the event manually using the system’s “Send test” function if available. Use a real event, not a synthetic ping, because synthetic pings often omit fields that appear in production payloads.
3. Watch the Make.com™ webhook module. Within seconds, it should display a green checkmark and show the payload it received.
4. Click the webhook module to inspect the detected data structure. Confirm that every field you need — candidate name, email, phone, status, score, or whatever your use case requires — is present and correctly typed.
5. If fields are missing, check the sending system’s payload configuration and re-send. Do not proceed until the payload contains all required fields.
6. Optional but recommended: Add a Webhooks > Webhook Response module immediately after the trigger to return an HTTP 200 OK to the sender. Some systems retry the payload if they don’t receive a success response, causing duplicate records in Keap.

Step 4 — Map the Payload to Keap Fields

This step translates the incoming data into Keap contact and tag operations. Field mapping precision determines whether candidate records are created cleanly or corrupted.

1. Click the + icon after the webhook module to add a new module.
2. Search for Keap and select the appropriate action. For most recruiting use cases, start with Create or Update a Contact to prevent duplicate records.
3. Connect your Keap account using OAuth if you haven’t already (Make.com™ walks you through the authorization flow).
4. In the module configuration, map each Keap field to the corresponding value from the webhook payload. Click into each field and select the payload variable from the data picker — for example, map Email to {{1.email}} from your webhook data.
5. Map all required fields: First Name, Last Name, Email at minimum. Add Phone, Source, and any custom fields relevant to your recruiting pipeline.
6. For custom Keap fields (job title applied for, candidate score, source system), use the Custom Fields section and match each field ID from Keap to the correct payload variable.

For a full reference on which Keap fields to prioritize and how to structure custom field logic, see our guide on automating Keap tags and custom fields with Make.com™.

Step 5 — Apply Tags and Route the Contact

A contact created in Keap without tags is invisible to your automation campaigns. This step ensures every inbound webhook fires the correct downstream sequences.

1. After the Create/Update Contact module, add another Keap module: Apply a Tag to a Contact.
2. Use the Contact ID output from Step 4’s module as the input (available in the data picker as the ID returned by the create/update action).
3. Select the tag that should fire your candidate nurture or qualification sequence in Keap. If the tag doesn’t exist yet, create it in Keap first, then return to this step.
4. For conditional routing — for example, applying different tags based on a candidate score field — add a Router module between the webhook trigger and the Keap modules. Each router path can have its own filter condition and its own set of Keap actions.
5. Test the router logic by re-running a test payload and confirming the correct path is taken for each condition value.

This tag-based routing pattern is the foundation of the broader automation architectures covered in our list of essential Make.com™ modules for Keap recruitment automation.

Step 6 — Add Error Handling and a Fallback Notification Route

Error handling is not optional for any scenario that writes candidate data. A missing error handler means a Keap API timeout or a schema mismatch silently drops records with no indication that anything failed.

1. Right-click the Keap module (Create/Update Contact) and select Add error handler.
2. Choose Ignore only if you genuinely don’t care about failures — which you don’t, for candidate data. Choose Resume or Rollback for controlled handling, or route the error to a notification.
3. In the error handler route, add an Email or messaging module to alert your team immediately when a failure occurs. Include the full error message and the raw payload in the notification so you can diagnose without hunting through logs.
4. Add a data store write (or a connected spreadsheet row) to log every failed payload. This creates a recoverable queue — when the underlying issue is fixed, you can re-process the stored payloads manually.
5. Repeat this error handler setup for every Keap module in the scenario, not just the first one.

Parseur’s Manual Data Entry Report estimates that manual data processing costs organizations roughly $28,500 per employee per year in wasted time. Error handling preserves the value of automation by ensuring failures surface and get resolved rather than silently compounding into data quality debt — a risk detailed in our guide to common Make.com™ Keap integration errors and how to fix them.

Step 7 — Activate the Scenario and Set the Scheduling Mode

Webhook-triggered scenarios do not need a polling schedule — they run on demand, the moment a payload arrives. Confirm the scenario is configured correctly before going live.

1. Review all modules in sequence: Webhook trigger → (Optional) Webhook Response → Router (if applicable) → Create/Update Contact → Apply Tag → Error Handler.
2. Click Run once and trigger one more real test event from the external system. Confirm the full execution completes with green checkmarks on every module.
3. In the scenario settings, ensure Scheduling is set to Immediately (not on a schedule). Webhook scenarios must run on incoming data, not on a timer.
4. Toggle the scenario ON using the active/inactive switch at the bottom of the scenario editor.
5. Submit a live candidate event from the external system and verify within 30 seconds that the contact appears or updates in Keap with the correct tags applied.

How to Know It Worked

The scenario is working correctly when all four of these conditions are true simultaneously:

• Make.com™ execution history shows a completed run (green status) within seconds of the external event firing — not minutes.
• The Keap contact record exists with all mapped fields populated accurately, including custom fields and source data.
• The correct tag is applied in Keap, and any sequence tied to that tag has started (confirm in the contact’s activity history).
• No error notification was sent to your alert channel — meaning the error handler route did not fire.

If any of these four conditions is false, check Make.com™ execution history for the specific module that failed, review the error message, and cross-reference with Keap’s API activity log.

Common Mistakes and Troubleshooting

Mistake 1 — Testing with Synthetic Payloads

Synthetic test data omits optional fields and nested objects. Always trigger a real event from the source system during setup. Map the full schema before activating.

Mistake 2 — No HTTP 200 Response to the Sender

Without a Webhook Response module returning 200 OK, some external systems retry the POST, creating duplicate Keap contacts or applying tags multiple times. Add the response module immediately after the trigger.

Mistake 3 — Hardcoding Tag IDs Instead of Using Dynamic Lookup

If you hardcode a Keap tag ID in the module and that tag is later deleted or replaced, the scenario fails silently. Reference tags by searching for them dynamically in the module configuration where possible, or document every hardcoded ID in your scenario notes.

Mistake 4 — No Error Handler on the Keap Modules

Keap API rate limits and temporary outages are real. Without an error handler, failed Keap writes are lost permanently. This is the single most common cause of missing candidate data in production scenarios.

Mistake 5 — Forgetting to Re-Test After Source System Changes

When the external system updates its payload schema — adding, removing, or renaming fields — your Make.com™ mapping breaks. Subscribe to change notifications from the sending platform and schedule a quarterly mapping review. See also our guide to syncing Keap contacts with Make.com™ to eliminate manual data entry for ongoing maintenance patterns.

What This Enables Across Your Recruiting Stack

Once the core webhook-to-Keap pattern is established, the same architecture extends to every external touchpoint in your recruiting pipeline:

• Job board applications → instant Keap contact creation with source tag and qualification sequence start.
• Assessment completions → score written to a custom Keap field, routing to an interview invite sequence or a rejection sequence based on threshold.
• Offer letter e-signatures → tag applied in Keap triggering onboarding automation, documented in our guide to automating candidate onboarding with Make.com™ and Keap.
• Background check status updates → Keap contact status field updated in real time, eliminating manual status checks by recruiters.

McKinsey Global Institute research finds that roughly 60% of occupations have at least 30% of their activities automatable with current technology. Webhook-driven automation is the mechanism that makes that potential real for recruiting operations — each connected external event is a manual task eliminated.

For a broader view of how this webhook pattern fits into a full recruiting automation strategy, return to Integrate Make.com and Keap: The Complete Guide to Recruiting Automation. To measure whether these scenarios are delivering quantifiable ROI, see our guide to measuring Keap and Make.com™ metrics to prove automation ROI. For a full library of proven scenario architectures, see nine Make.com™ scenarios for Keap HR automation success.

Frequently Asked Questions

What is a webhook and how does it differ from a scheduled trigger?

A webhook is an HTTP callback that fires the moment a specific event occurs in a source system, pushing data to a destination URL instantly. A scheduled trigger polls for changes at fixed intervals — meaning it can introduce delays of minutes or hours. For recruiting workflows where candidate response speed matters, webhooks are significantly faster.

Does Keap support incoming webhooks natively?

Keap does not have a native incoming webhook listener. It can send outgoing HTTP posts via its internal automation, but to receive and act on data from external systems in real time, you need an intermediary like Make.com™ to catch the payload and translate it into Keap API calls.

How many webhook-triggered scenarios can I run simultaneously in Make.com™?

Make.com™ supports multiple active webhook listeners concurrently. Each scenario with a webhook trigger runs independently. The practical limit depends on your plan’s operation count and the complexity of each scenario, not a hard cap on simultaneous listeners.

What data formats do Make.com™ webhooks accept?

Make.com™ webhook modules accept JSON, XML, and form-encoded payloads. For Keap integrations, JSON is the standard format. The platform auto-detects structure from your first test payload and generates a data schema you can reference in subsequent modules.

What happens if the webhook fires but Keap is temporarily unavailable?

Make.com™ queues failed operations and retries them based on your error-handling configuration. For critical recruiting data, add an error handler route that logs the raw payload to a fallback store so no candidate record is lost during an outage.

Can I filter webhook payloads so only certain events update Keap?

Yes. Use a Make.com™ Router module immediately after the webhook trigger to evaluate payload fields. Route only payloads where the candidate status field equals the target value to the Keap update path, and discard or log all others.

Is it possible to trigger outbound webhooks FROM Keap via Make.com™?

Yes. An outbound flow uses a Keap-native trigger (such as tag applied or contact updated) as the Make.com™ scenario starting point, then uses an HTTP module to POST data to any external endpoint. This is the reverse direction of the inbound webhook pattern described in this guide.

How do I secure my Make.com™ webhook URL so it cannot be abused?

Make.com™ allows IP allowlisting and custom header validation on webhook modules. Restrict the webhook URL to known sender IPs where possible, and require a secret token in the request header. Validate that token in a filter before any data reaches Keap.

Will this integration break if the external system changes its payload structure?

Yes — payload schema changes in the source system will break field mappings downstream. Establish a change-management agreement with the owner of the sending system and re-run the Make.com™ payload detection step whenever the schema is updated.

How do I know the webhook scenario is working correctly in production?

Check Make.com™ scenario execution history after each live event. Every run logs the full input payload, each module’s output, and any errors. Set up a Make.com™ email or notification alert for failed runs so issues surface immediately rather than silently dropping candidate data.