To enrich Keap candidate data with Make.com, you connect a webhook or polling trigger to external verification and enrichment APIs, route results through conditional branches, and write validated data back to custom Keap fields—transforming static contact records into segmentation-ready profiles that drive personalized recruiting campaigns.

Keap stores what candidates tell you. The application form, the resume upload, the opt-in field—that is the extent of a default Keap contact record. Static snapshots power generic campaigns. When your recruiting outreach needs to reflect a candidate’s actual seniority level, current employer size, or verified contact details, you need a data enrichment workflow sitting between candidate entry and campaign fire. That workflow lives in Make.com—and this guide builds it step by step.

This guide drills into one specific capability within the broader recruiting automation stack. Before you build the enrichment layer, review how AI-powered recruitment extends beyond basic ATS workflows and why manual data entry creates hidden recruiting costs. If you are evaluating the automation platform itself, see the Make vs. Zapier feature breakdown before committing to a build.

Poor data quality is one of the primary drivers of failed automation initiatives. The steps below are sequenced to prevent the most common failure modes before they reach your live pipeline.

What You Need Before You Start

Data enrichment scenarios connect Keap to external data services through Make.com. Confirm every prerequisite below before opening a single scenario canvas. Missing one item mid-build costs far more time than the upfront check.

• Make.com account with sufficient operations budget for your pipeline volume. Enrichment scenarios consume one to four operations per contact depending on how many external API calls you make.
• Keap account with API access enabled and at least one custom field created for each enrichment data point you intend to capture—company size, seniority, email validity score, and so on.
• External data service credentials—at minimum an email verification API key. Additional enrichment sources such as company data lookups or professional profile APIs require separate accounts and keys.
• A test contact in Keap with a known email address so you can validate field writes without touching live pipeline records.
• Time allocation: Plan two to four hours for a single-source enrichment scenario. Multi-source scenarios with conditional routing require one to two focused build days.
• Risk awareness: Enrichment scenarios that write to Keap contact fields overwrite existing manually entered data if not scoped correctly. Scope writes to empty fields only during testing.

If you have never built a Make.com scenario from scratch, start with the plain-English guide to Make scenarios before continuing. Understanding modules, routers, and filters is a prerequisite for every step below.

Step 1: Map the Enrichment Fields You Actually Need

Define your target fields before you open Make.com. Every field you enrich must connect directly to a campaign decision. If a data point does not drive segmentation logic or personalization tokens, remove it from your map. Unused fields create maintenance debt and increase scenario complexity with no return.

The highest-value enrichment fields for recruiting pipelines fall into four categories:

In Keap, create a custom field for each item in your map before building the scenario. Use a consistent naming prefix—”Enrich_” works well—so fields are easy to identify in the Keap UI and in Make.com field mapping dropdowns.

This upfront mapping step is the same discovery discipline described in the OpsMap checklist for automation planning. Skipping it is the leading cause of scenarios that write data to the wrong fields or in incompatible formats.

Step 2: Create the Trigger in Make.com

The enrichment scenario fires the moment a new candidate contact lands in Keap. Use one of two trigger configurations depending on how candidates enter your pipeline.

Option A — Keap Webhook Trigger (Recommended)

In Keap, create a campaign sequence with a webhook action that fires on new contact creation or tag application. In Make.com, create a new scenario using the Webhooks module as the trigger and paste the generated webhook URL into Keap. This gives you real-time enrichment within seconds of candidate entry.

Webhooks are the correct architecture for any recruiting pipeline where campaigns fire within minutes of contact creation. For the full technical setup, see the step-by-step Make scenario build walkthrough.

Option B — Watch Contacts Trigger (Polling)

Use the Keap “Watch Contacts” trigger module in Make.com set to a 15-minute polling interval. This is simpler to configure but introduces lag between candidate entry and enrichment completion. Acceptable for lower-volume pipelines. Not recommended if your recruiting campaigns fire within minutes of contact creation.

For both options, add a filter immediately after the trigger: check that the Keap contact’s creation date equals today, or that the “Enrich_Status” custom field is empty. This prevents the scenario from reprocessing existing contacts on every run.

Step 3: Add Email Verification as Your First Enrichment Call

Email validity is the highest-priority enrichment step. An invalid email address means every downstream campaign send is wasted. Run verification before any other enrichment call so bad contacts are flagged before consuming operations or campaign sends.

In Make.com, add an HTTP module after your trigger. Configure it to call your email verification API with the candidate’s email address pulled from the Keap trigger data. Most verification APIs return a JSON response with a result field—valid, invalid, catch-all, or disposable—and a confidence score.

After the HTTP module, add a Router module with two branches:

• Valid branch: Continue to remaining enrichment steps. Set a filter condition: result equals “valid” OR result equals “catch-all.”
• Invalid branch: Write “Invalid” to the Keap “Enrich_Email_Status” field, apply a Keap tag “Email: Unverified,” and stop the scenario. This contact does not receive campaign sends until manually reviewed.

Write the verification result and confidence score to dedicated Keap custom fields—not just as a tag. Field-stored data is queryable for reporting and re-enrichment scheduling. Tags alone are not.

For guidance on building the HTTP module itself, see how to feed API docs into Claude to build Make HTTP modules—particularly useful when your verification provider does not have a native Make.com connector.

Step 4: Add Professional Context Enrichment

With email validity confirmed, the next enrichment layer adds professional context: job title, seniority level, and job function. These fields are the primary drivers of campaign branch logic in a recruiting pipeline.

Add a second HTTP module on the valid branch, calling a professional data enrichment API with the candidate’s verified email address as the lookup key. Map the response fields as follows:

• Job title → Keap custom field “Enrich_Job_Title”
• Seniority level (executive / director / manager / individual contributor) → Keap custom field “Enrich_Seniority”
• Job function (engineering / finance / operations / HR / sales) → Keap custom field “Enrich_Job_Function”

Add error handling on this module. Professional enrichment APIs return partial data or no data on a meaningful percentage of lookups—typically 20 to 40 percent depending on your candidate source. Set the module’s error handler to “Resume” and write “Not Found” to the seniority and function fields. Do not let a failed professional lookup kill the entire enrichment chain. The contact still has a valid email and deserves campaign enrollment; it just routes to the generic sequence rather than a personalized branch.

This pattern—enrichment with graceful degradation—is the same architecture described in the guide to routed error handling in Make. Applying it here prevents a single failed API call from breaking your entire recruiting pipeline.

Step 5: Add Company Context Enrichment

Company context enrichment adds employer name, industry vertical, and headcount range to the contact record. These fields serve two purposes: personalization tokens in email copy and company-profile segmentation for campaign targeting.

If your professional enrichment API returns a company domain as part of its response, use that domain as the lookup key for a company data API call. This produces cleaner results than using the email domain directly—particularly for candidates using personal email addresses at large employers.

Map company enrichment fields to Keap custom fields:

• Company name → Keap custom field “Enrich_Company_Name”
• Industry vertical → Keap custom field “Enrich_Industry”
• Employee headcount range (1–50 / 51–200 / 201–1000 / 1000+) → Keap custom field “Enrich_Company_Size”

Use headcount ranges rather than exact figures. Exact headcount data goes stale quickly. Ranges stay accurate long enough to be useful for segmentation across a typical campaign cycle.

Apply the same graceful degradation pattern as Step 4. A missing company lookup is not a scenario failure—it is a data state. Write “Not Found” to each field and continue.

Step 6: Write Pipeline Metadata and Set Enrichment Status

Before the scenario closes, write operational metadata to two Keap custom fields:

• Enrich_Timestamp: Write the current date and time using Make.com’s “now” variable. This records when enrichment ran so you can identify stale records and schedule re-enrichment on a timed interval.
• Enrich_Status: Write “Complete” if all enrichment calls returned data, “Partial” if professional or company lookups returned “Not Found,” or “Invalid” if email verification failed.

The Enrich_Status field becomes your campaign routing key in Keap. A “Complete” status triggers your fully personalized sequence. “Partial” triggers a moderately personalized sequence that uses whatever data is available. “Invalid” suppresses campaign sends and routes to a manual review queue.

This metadata layer is what separates a production enrichment workflow from a fragile prototype. Without enrichment timestamps and status fields, you have no way to audit data quality across your pipeline or identify which contacts need re-enrichment after a period of inactivity.

Step 7: Apply Keap Tags to Drive Campaign Branch Logic

Custom field data drives personalization tokens. Tags drive campaign branch logic in Keap. You need both. After writing all enrichment fields, add a final series of Keap “Apply Tag” actions to translate field values into campaign-routing tags.

Map your tag structure to match the seniority and company size segmentation you defined in Step 1:

• Enrich_Seniority = “Director” or “Executive” → apply tag “Segment: Senior Leader”
• Enrich_Seniority = “Manager” → apply tag “Segment: Manager”
• Enrich_Seniority = “Individual Contributor” → apply tag “Segment: IC”
• Enrich_Seniority = “Not Found” → apply tag “Segment: Unknown”
• Enrich_Company_Size = “201–1000” or “1000+” → apply tag “Company: Mid-Market Plus”
• Enrich_Company_Size = “1–50” or “51–200” → apply tag “Company: SMB”

Use Make.com’s Router module to evaluate field values and apply the correct tag. Each router branch handles one seniority tier or company size bucket. This keeps your conditional logic explicit and auditable—far easier to troubleshoot than nested filter conditions on a single path.

For a practical demonstration of this routing pattern applied to a real workflow, see how Nick eliminated six manual handoffs with a single Make workflow.

How Do You Know the Enrichment Workflow Is Working?

Run the scenario against your test contact and verify each of the following before enabling it for live pipeline traffic:

• Field population: Open the test contact in Keap. Every “Enrich_” field should contain a value—either real data or “Not Found.” Empty fields indicate a mapping error or a silent API failure that your error handler did not catch.
• Enrich_Status accuracy: If your test contact returned full data, Enrich_Status should read “Complete.” Manually test a contact with an invalid email to confirm the “Invalid” branch writes correctly and suppresses campaign enrollment.
• Tag application: Check the test contact’s tag list. The correct seniority and company size tags should be present. If tags are missing, the router branch filter conditions need adjustment.
• Scenario execution log: In Make.com, open the scenario’s execution history. Every module should show a green success state or an expected partial result. Any red error states require investigation before going live.
• Operations count: Note the total operations consumed per contact run. Multiply by your expected monthly contact volume to confirm your Make.com plan supports the load.

Do not move to live pipeline traffic until all five checks pass on at least three test contacts with different data profiles—one valid with full enrichment, one valid with partial enrichment, and one invalid email.

What Are the Most Common Mistakes in Keap Enrichment Scenarios?

Overwriting Manually Entered Data

Write operations that do not check whether a field already contains data overwrite manually entered values. Scope every field write to trigger only when the target field is empty. In Make.com, add a filter before each Keap “Update Contact” module: field value is empty. This is the single most destructive error in enrichment builds and the most preventable.

No Error Handling on External API Calls

External APIs return errors. Rate limits, timeouts, and malformed responses are normal operational events, not edge cases. Every HTTP module in an enrichment scenario needs an error handler configured. Without one, a single API failure stops the scenario and leaves the contact record partially enriched—which is worse than no enrichment because campaign logic reads partial data as complete.

Building Without Field Mapping Defined in Advance

Scenarios built without a pre-defined field map end up with inconsistent field naming, duplicate enrichment fields, and campaign logic that references fields that were renamed mid-build. The 30 minutes spent on Step 1 saves four hours of cleanup.

Using Only Tags Instead of Custom Fields

Tags are binary—present or absent. Custom fields store values that can be updated, compared, and reported on. A recruiting pipeline that stores enrichment data only in tags has no way to refresh stale data, no way to report on enrichment coverage, and no way to personalize email copy with dynamic field tokens. Use both, for the reasons described in Step 6 and Step 7.

Skipping the Re-Enrichment Architecture

A one-time enrichment workflow captures data at candidate entry. Candidates who re-engage after six months carry stale seniority and company data. Build the Enrich_Timestamp field in from day one so you can add a scheduled re-enrichment scenario later without rebuilding the core workflow. For a framework on how automation scales over time, see how to run an OpsMap™ audit before automating.

Frequently Asked Questions

Which email verification API works best with Make.com for recruiting pipelines?

Several email verification services offer REST APIs that work directly with Make.com’s HTTP module. The key requirements for a recruiting pipeline are: a deliverability result field with at minimum four states (valid, invalid, catch-all, disposable), a confidence score, and a response time under two seconds. Evaluate providers on those criteria against your budget and volume. Make.com’s HTTP module connects to any REST API, so provider selection is independent of your automation platform.

How many Make.com operations does a full enrichment scenario consume per contact?

A three-source enrichment scenario—email verification, professional context, company context—consumes four to six operations per contact: one for the trigger, one per external API call, and one for the Keap field write. High-volume pipelines processing hundreds of new contacts daily need to account for this in their Make.com plan selection. Review the Make vs. Zapier operations comparison to understand how operations pricing scales.

Can I use AI to help build the HTTP modules for enrichment APIs without native Make.com connectors?

Yes. Feeding API documentation directly into an AI assistant and requesting a Make.com HTTP module configuration is a reliable build method for enrichment APIs that lack native connectors. The guide on feeding API docs into Claude to build Make HTTP modules covers this approach in detail. It reduces a two-hour manual configuration to under 30 minutes on most enrichment APIs.

What happens if the enrichment API is down when a new candidate enters the pipeline?

With proper error handling in place, a downstream API failure writes “Not Found” to the relevant enrichment fields, sets Enrich_Status to “Partial,” and routes the contact to the appropriate campaign sequence. The candidate is not lost—they enter a less personalized sequence and get flagged for re-enrichment when the API recovers. Without error handling, the scenario fails and the contact record is left in an incomplete state. Configuring error handlers before going live is non-negotiable.

How do I prevent the enrichment scenario from reprocessing existing contacts?

Add a filter immediately after the trigger that checks whether the “Enrich_Status” custom field is empty. If the field already contains a value, the scenario stops without processing. This single filter prevents duplicate enrichment runs on contacts that already have complete data and is especially important if you are using the Watch Contacts polling trigger, which evaluates all recently modified contacts rather than only new ones.

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 Feed API Docs Into Claude to Build Make HTTP Modules Without Native Connectors
• How to Set Up Routed Error Handling in Make With AI Assistance
• 7 Questions to Ask Before You Automate Anything (The OpsMap Checklist)
• How to Run an OpsMap Audit Before Automating Anything
• Make vs Zapier: A Straight Pricing and Feature Breakdown for 2026
• Make.com vs. Zapier in 2026: Which Is Right for Your Operations?
• How Nick Cut 6 Manual Handoffs From Proposal Generation With One Make Workflow
• How David Eliminated 3 Hours of Daily CRM Entry With a Single Make Scenario
• AI-Powered Recruitment: Beyond Basic ATS with Automation
• Automate HR & Recruiting: End the Manual Data Drain, Unlock Growth
• Recruiting Automation: Transforming Hidden Costs into Measurable ROI
• AI-Assisted Make Automation: Frequently Asked Questions
• 10 Automations That Are Finally Easy to Build With Make + AI — No Developer Needed