To set up real-time Keap automation with webhooks and Make.com, create a new Make.com scenario with a Custom Webhook trigger, paste the generated URL into your external system, capture a live payload to define the data structure, map fields to Keap contact operations, and add error handling before going to production.

Keap’s internal automation handles events that happen inside Keap reliably — a form submission, a tag applied, an invoice paid. 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. A webhook-driven Make.com scenario catches external events the instant they fire and writes the result directly into Keap.

This guide shows you exactly how to build that connection. It is one focused implementation within the broader strategy covered in our HR and Recruiting Automation Glossary and the principles behind automation-first operations. Before you build anything, consider whether you have answered the seven pre-automation questions — skipping discovery is the single biggest reason integrations fail in production.

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, recruiters never touch that data manually. The case for this approach is documented in our CRM data entry elimination case study and reinforced by what Nick’s team achieved by removing six manual handoffs from a single workflow.

What You Need Before You Start

Confirm every item below before opening Make.com. Missing any of these stalls the build mid-step and introduces risk to live candidate data.

• Active Make.com account — Instant Trigger and webhook modules require at least a Core plan on most configurations.
• Keap account with API access — you need a Keap API key or an active OAuth connection inside Make.com.
• Admin access to the external system that sends the webhook — job board, form tool, ATS, or custom application.
• 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 — Step 6 covers this. Do not skip it.

If your team is new to Make.com concepts, review what a Make scenario actually is before proceeding. If you are migrating from Zapier, the Make.com FAQ for Zapier users answers the most common pre-build questions.

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 (for example, “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 automatically.

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 (for example, X-Webhook-Secret: your-token-here). You 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 has not 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 shows 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 frequently omit fields that appear in production payloads.
3. Watch the Make.com webhook module. Within seconds it displays a green checkmark and shows 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 — 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. 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 do not receive a success response, causing duplicate records in Keap.

Step 4 — Map the Payload to Keap Fields

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

1. Click the + icon after the webhook module to add a new module.
2. Search for Keap and select the appropriate action — typically Create/Update Contact for new candidate records.
3. Connect your Keap account using API key or OAuth when prompted.
4. Map each Keap field to the corresponding variable from the webhook payload:
   • First Name → {{1.firstName}} (or whatever your payload names the field)
   • Last Name → {{1.lastName}}
   • Email → {{1.email}}
   • Phone → {{1.phone}}
   • Any custom Keap fields → map to corresponding payload values
5. Use Make.com’s built-in string functions to clean data where needed — for example, trim() to remove whitespace, formatDate() to normalize date formats.
6. If your use case requires tagging the contact (for example, “External Applicant” or “Assessment Complete”), add a second Keap module after the contact creation: Keap > Add Tag to Contact.

If you are handling a process with no native Keap module for a specific operation, review how to feed API docs into Claude to build Make HTTP modules for custom API calls.

Step 5 — Add Filtering and Conditional Logic

Not every payload should create or update a Keap record. Filters prevent junk data, test submissions, and duplicate processing from reaching your CRM.

1. Click the small filter icon (the funnel) between your webhook trigger and the Keap module.
2. Set a condition to validate the payload before it processes — for example:
   • email exists AND is not empty
   • status equals “submitted” (not “draft” or “test”)
   • source does not contain “test” or “sandbox”
3. If your workflow requires different Keap actions based on the event type — for example, new application versus assessment score — add a Router module after the webhook trigger. Each route handles a specific event type with its own Keap operations.
4. For workflows with multiple routes, label each route clearly so the scenario is readable six months later when someone else debugs it.

Step 6 — Add Error Handling Before Going to Production

Skipping error handling is the most expensive mistake in webhook automation. When Make.com encounters an API error, rate limit, or malformed payload with no error handler configured, it drops the data silently. That candidate record disappears with no alert.

1. Right-click the Keap module in your scenario and select Add error handler.
2. Choose the appropriate handler type:
   • Resume — continues the scenario despite the error (use only when the failed operation is non-critical)
   • Ignore — skips the module and continues (rarely the right choice for CRM writes)
   • Rollback — undoes all operations in the current cycle (use for transactional workflows)
   • Break — stops the scenario and saves the bundle for retry (the correct choice for most Keap write operations)
3. After the error handler, add a notification action — an email, a Slack message, or a log entry — so your team knows when a record failed to write.
4. Set the maximum number of auto-retries to at least 3 in the scenario settings. Keap’s API occasionally returns transient errors that resolve on retry.

For a detailed walkthrough of production-grade error handling, see how to set up routed error handling in Make. The AI-built error handler case study shows what happens when this step is done right.

Step 7 — Test the Full Scenario End to End

Unit testing individual modules is not sufficient. The scenario must be tested as a complete chain before it handles real candidate data.

1. Turn on the scenario using the toggle at the bottom of the scenario editor.
2. Fire a real test event from the external system using a disposable test email address and clearly labeled test data (for example, “Test Candidate — DELETE”).
3. Watch the scenario execution in real time. Each module should display a green checkmark. Click any module to inspect its input and output data.
4. Log into Keap and verify the contact was created or updated with the correct field values and tags.
5. Intentionally trigger an error condition — submit a payload with a missing required field — and confirm the error handler fires the notification you configured.
6. Delete the test records from Keap before enabling for production traffic.
7. Set the scenario scheduling to Instantly (or the appropriate interval) and confirm it is active.

If you want a framework for evaluating any Make scenario before it touches production, the Make scenario pre-production evaluation guide applies directly — even for manually built scenarios.

How to Know It Worked

The integration is working correctly when all four conditions are true:

• Zero manual touches: A candidate submits an external form and appears in Keap within seconds without any recruiter action.
• Field accuracy: Every mapped field in Keap matches the source payload exactly — no truncation, no encoding artifacts, no mistyped values.
• Tag accuracy: Any tags applied by the scenario appear on the correct contacts only, not on unrelated records.
• Error visibility: When you force an error condition, the notification fires within the expected timeframe and includes enough context to diagnose the issue.

Run a spot-check of ten real submissions against their source payloads in the first 48 hours of production. This catches edge cases — unusual characters in names, international phone formats, optional fields that some senders include and others omit — before they accumulate into a data quality problem.

Common Mistakes That Break This Integration

These are the failure modes that appear most often in production webhook builds, in order of frequency:

• Using a synthetic payload for schema detection. Synthetic payloads omit optional fields. When a real submission includes those fields, Make.com has no mapping for them and drops the data. Always use a real triggered event.
• No HTTP 200 response to the sender. Systems that do not receive a success acknowledgment retry the webhook, often multiple times. The result is duplicate contacts in Keap. Add the Webhook Response module immediately after the trigger.
• Skipping error handling entirely. Production API calls fail. Rate limits exist. Network timeouts happen. Without error handling, failed records disappear silently. The Break handler with notification is the minimum acceptable configuration.
• Mapping fields without data cleaning. Phone numbers arrive with and without country codes, dashes, and parentheses. Names arrive with leading spaces. Dates arrive in inconsistent formats. Use Make.com’s built-in string and date functions to normalize before writing to Keap.
• No filter for test submissions. Most external systems send test events when you configure the webhook. Those test records pollute your Keap contact database. Always add a filter that excludes payloads flagged as tests or that lack a valid email address.
• Leaving the scenario on manual scheduling. Make.com defaults new scenarios to manual execution. If you forget to switch to Instant or a scheduled interval, the scenario never runs automatically in production.

Frequently Asked Questions

Does this work with any external system, or only specific integrations?

Any system that can send an HTTP POST request with a JSON payload works as the webhook source. This includes job boards, form builders, ATS platforms, custom web applications, and third-party tools with webhook output. If the system only supports email notifications, use a mailhook trigger instead of a custom webhook.

What happens if the external system sends a payload and Make.com is not running?

Make.com queues incoming webhooks for up to 5 minutes while the scenario is inactive. Payloads that arrive outside that window are lost unless the sending system retries. For high-volume or time-sensitive integrations, keep the scenario active continuously rather than relying on a scheduled interval.

How do I prevent duplicate contacts in Keap?

Use the Keap Create/Update Contact action, which performs an upsert — it creates a new contact if no match exists and updates the existing record if it finds one. Make sure you are matching on a unique identifier like email address, not on name fields, which are not unique.

Can Make.com handle webhook payloads with nested JSON objects?

Yes. Make.com parses nested JSON automatically after the schema detection step. Nested fields appear as dot-notation variables in the module mapping interface. The key is ensuring your test payload includes the nested objects — synthetic payloads frequently omit them, which is why using a real triggered event during setup is mandatory.

What plan does Make.com require for instant webhook triggers?

Instant triggers, including custom webhooks, are available on the Core plan and above. The Free plan supports scheduled scenarios but does not support instant webhook execution. Check Make.com’s current plan documentation for the latest tier details, as plan structures change periodically.

How do I secure the webhook so unauthorized senders cannot post data to it?

Add a secret token header to requests from the sending system (for example, X-Webhook-Secret), then use a filter in Make.com to check that the header value matches your expected token. Reject any payload where the header is missing or incorrect. This prevents unauthorized parties from injecting data into your Keap instance by discovering the webhook URL.

Additional Reading

• What Is a Make Scenario? The Plain-English Guide for Zapier Users
• Make.com FAQ: Everything Zapier Users Ask Before Switching
• 7 Questions to Ask Before You Automate Anything (The OpsMap Checklist)
• 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 an AI-Built Error Handler Reduced Technician Research Time From 20 Minutes to a Glance
• How to Feed API Docs Into Claude to Build Make HTTP Modules Without Native Connectors
• How We Used Make and Claude to Automate a Process That Had No Native Module
• How David Eliminated 3 Hours of Daily CRM Entry With a Single Make Scenario
• How Nick Cut 6 Manual Handoffs From Proposal Generation With One Make Workflow
• What Is Automation-First? Why You Should Automate Before You Add AI
• Make vs Zapier: A Straight Pricing and Feature Breakdown for 2026
• How to Build a Make Scenario With Claude: A Step-by-Step Walkthrough
• 7 Things an AI-Built Make Scenario Gets Wrong (And How to Catch Them)
• What Is OpsMap? The Discovery Step That Prevents Automation Mistakes