How to Enrich Keap Candidate Data with Make.com™: A Step-by-Step Guide for Recruiters

Keap stores what candidates tell you. The application form, the resume upload, the opt-in field — that’s the extent of a default Keap contact record. It’s a static snapshot, and static snapshots power generic campaigns. If you’re operating a recruiting pipeline where your 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 satellite drills into one specific capability within the broader complete guide to recruiting automation with Make.com™ and Keap. If you haven’t read that guide, start there for the full pipeline architecture. Come back here when you’re ready to build the enrichment layer.

Before You Start

Data enrichment scenarios connect Keap to external data services through Make.com™. Before you build, confirm the following prerequisites are in place.

• 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 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, etc.).
• External data service credentials — at minimum an email verification API key. Additional enrichment sources (company data, professional profile lookups) require separate API accounts.
• A test contact in Keap with a known email address so you can validate field writes without affecting live pipeline records.
• Time allocation: Plan 2–4 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 can overwrite existing manually entered data if not scoped correctly. Always scope writes to empty fields first during testing.

Step 1 — Map the Enrichment Fields You Actually Need

Define your target fields before you open Make.com™. Every field you enrich should connect directly to a campaign decision — if it doesn’t drive segmentation or personalization, cut it.

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

• Contact validity: Email deliverability status, phone number format validity. These fields determine whether outreach fires at all — invalid contacts get tagged and routed to a re-engagement or manual review branch rather than consuming campaign sends.
• Professional context: Current job title, seniority level, job function. These fields drive campaign branch logic — a director-level candidate receives a different email sequence than an individual contributor for the same role family.
• Company context: Employer name, industry vertical, company headcount range. These fields power personalization tokens in email copy (“We work with companies like [Company Name]…”) and segment candidates by employer profile.
• Pipeline metadata: Enrichment timestamp, enrichment status (found / not found / partial). These operational fields let you audit data freshness and trigger re-enrichment on a schedule.

In Keap, create a custom field for each item in your map before building the scenario. Name fields consistently — use a prefix like “Enrich_” so they’re easy to identify in the Keap UI and in Make.com™ field mapping dropdowns.

Gartner research consistently identifies poor data quality as a primary driver of failed automation initiatives. Defining fields before building prevents the most common failure mode: 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. For the full technical setup of this approach, see the guide on webhook triggers for real-time Keap automation.

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 a lag between candidate entry and enrichment completion. Acceptable for lower-volume pipelines; not recommended if your recruiting campaigns fire within minutes of contact creation.

Scope both trigger options to new contacts only by adding 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 re-processing 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 immediately.

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 / 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 will not receive campaign sends until manually reviewed.

According to Parseur’s Manual Data Entry Report, organizations spend an average of $28,500 per employee per year on manual data handling. Catching invalid contact data at the point of entry — before a recruiter spends time crafting outreach — directly attacks that cost.

Step 4 — Build the Company Data Enrichment Call

With a verified email address, you now have enough signal to query company-level data. Many enrichment APIs accept an email domain and return the associated company name, headcount range, industry, and location.

Add a second HTTP module in the valid branch from Step 3. Pass the email domain (extracted from the candidate’s email address using Make.com™’s split(email, "@")[1] formula) to your company data API. Map the returned fields as follows:

• Company name → Keap standard Company field (if empty) or “Enrich_Company_Name” custom field
• Headcount range → “Enrich_Company_Size” custom field
• Industry → “Enrich_Industry” custom field

Add error handling to this module using Make.com™’s “Ignore” error handler with a resume route. If the company data API returns no result (unknown domain, personal email address), the scenario continues without writing to those fields rather than stopping entirely.

McKinsey Global Institute research identifies data enrichment and intelligent automation as key enablers of productivity gains in knowledge-intensive workflows — and recruiting is precisely that category of work.

Step 5 — Add Seniority and Job Function Enrichment

Job title parsing is the step that drives the most campaign personalization value. A raw job title field (“Senior Product Manager,” “VP of Engineering,” “Associate Recruiter”) contains two distinct signals: seniority level and job function. Most enrichment APIs parse these into separate structured fields.

Add a third HTTP module to call a professional data enrichment API with the candidate’s email or full name plus company. Map the returned seniority level (individual contributor / manager / director / VP / C-suite) to an “Enrich_Seniority” custom field and job function (Engineering / HR / Finance / Sales / Operations) to an “Enrich_Function” custom field.

These two fields do the heavy lifting for campaign branching. In Keap, you can now build campaign sequences where:

• Director+ seniority → receives executive-tone outreach with minimal frequency
• Individual contributor → receives higher-frequency outreach with role-specific details
• HR function candidates → receive messaging that references their recruiting context

For the Keap-side implementation of these campaign branches, see the guide on conditional logic in Make.com™ for Keap campaigns.

Step 6 — Write All Enriched Data to Keap in a Single Update

Batch your Keap field writes into a single Update Contact module at the end of the enrichment chain rather than writing after each API call. This reduces API calls to Keap, lowers your operations count, and prevents race conditions where a partially written record triggers a Keap campaign before all enrichment data is present.

In Make.com™, use the “Set Variable” module after each enrichment step to store returned values in scenario variables. Then add a single Keap “Update a Contact” module at the end of the scenario that writes all variables to their mapped custom fields simultaneously.

Field mapping checklist for the final Update Contact module:

• Enrich_Email_Status ← email verification result
• Enrich_Company_Name ← company name from domain lookup
• Enrich_Company_Size ← headcount range
• Enrich_Industry ← industry vertical
• Enrich_Seniority ← parsed seniority level
• Enrich_Function ← parsed job function
• Enrich_Status ← “Complete” (written on every successful run)
• Enrich_Timestamp ← current date/time (use Make.com™’s now formula)

For a complete walkthrough of the mechanics of writing and managing Keap tags and custom fields at scale, see the guide on automating Keap tags and custom fields with Make.com™.

Step 7 — Apply Keap Tags to Fire Campaign Sequences

Tags are Keap’s campaign trigger mechanism. After writing enrichment data to custom fields, add a final Keap “Apply Tag” module in your Make.com™ scenario to signal that enrichment is complete and the contact is ready for campaign sequencing.

Use a tag structure like:

• Enrich: Complete — applied to all successfully enriched contacts; triggers your standard campaign entry sequence
• Enrich: Email Invalid — applied to contacts that failed email verification; triggers a manual review notification to the recruiting team
• Enrich: Partial — applied when some but not all enrichment calls returned data; allows campaign to proceed with available data while flagging for manual review
• Seniority: [Level] — applied based on enriched seniority field value; drives campaign branch entry in Keap

In Keap’s campaign builder, set your campaign start trigger to “Tag Applied: Enrich: Complete” rather than contact creation. This guarantees the campaign sequence never fires before enrichment writes are complete — eliminating personalization token failures where tokens render blank because the custom field hadn’t been populated yet.

Add a 90-second delay module in Make.com™ between the Update Contact step and the Apply Tag step. This buffer accounts for Keap’s API propagation time and ensures custom field values are committed before the tag fires the campaign.

Step 8 — Build the Null-Result Handler

Every enrichment scenario needs an explicit path for contacts where external APIs return no data. Without it, those contacts stall silently in your pipeline — tagged as neither enriched nor failed.

At the Router module you created in Step 3, add a third branch with a filter condition: “Enrich_Status” does not equal “Complete” AND the scenario has reached the end of the enrichment chain. In this branch:

• Write “Not Found” to the Enrich_Status field
• Apply the “Enrich: Partial” tag in Keap
• Send a Slack or email notification to the recruiting team with the candidate’s name and Keap contact ID for manual follow-up

This branch ensures zero contacts fall through the pipeline without a status. The recruiting team receives actionable notifications for the small percentage of contacts where enrichment fails, rather than discovering gaps during campaign reporting.

For troubleshooting Make.com™ scenarios that aren’t writing to Keap as expected, see the guide on common Make.com™ Keap integration errors and how to fix them.

How to Know It Worked

Run your test contact through the scenario and verify these outcomes before activating the scenario for live pipeline traffic:

• Custom fields populated: Open the test contact in Keap. Every “Enrich_” field you mapped should contain a value or “Not Found” — never blank.
• Tag applied: The appropriate enrichment status tag (“Enrich: Complete,” “Enrich: Partial,” or “Enrich: Email Invalid”) appears in the contact’s tag list.
• Campaign entry triggered: If the test contact received “Enrich: Complete,” confirm in Keap’s campaign dashboard that the contact entered the correct campaign sequence.
• Timestamp written: The Enrich_Timestamp field shows the current date/time, confirming the final Update Contact module executed successfully.
• Operations count within budget: In Make.com™’s scenario history, confirm the operations consumed per run are within your plan’s daily budget at your expected pipeline volume.
• Error log clean: Make.com™’s scenario history shows no incomplete executions. Any errors during testing should be resolved before activating for live contacts.

Common Mistakes and How to Avoid Them

Overwriting manually entered data

If a recruiter manually corrected a candidate’s company name in Keap, your enrichment scenario will overwrite it on the next run. Prevent this by adding a filter to each field write: only update if the target field is currently empty. In Make.com™, add a condition before each Set Variable step that checks whether the Keap field already contains a value.

Firing campaigns before enrichment completes

The most common failure mode: the Keap campaign trigger fires on contact creation, and the first campaign email sends before enrichment tags are written. Solution: change your campaign entry trigger from contact creation to “Enrich: Complete” tag application, as described in Step 7.

No error handling on external API calls

External APIs fail. Rate limits get hit. Without error handlers on each HTTP module, a single API timeout stops the entire scenario and leaves the contact in an undefined state. Add Make.com™’s “Ignore” error handler to every external API call, with a resume route that continues the scenario and writes a failure flag to the relevant Keap field.

Enriching irrelevant data points

Every enrichment field adds API calls, operations cost, and scenario complexity. If a data point doesn’t connect to a campaign decision — a segmentation branch, a personalization token, or a routing tag — remove it. The MarTech 1-10-100 rule (Labovitz and Chang) establishes that preventing bad data costs a fraction of what it costs to fix or work around it later; the same logic applies to unnecessary data that clutters your Keap records and complicates your campaign logic.

Skipping re-enrichment scheduling

A contact enriched today may hold a different role in six months. Build a separate Make.com™ scenario on a 90-day schedule that queries Keap for contacts tagged “Enrich: Complete” with an Enrich_Timestamp older than 90 days, clears the enrichment status tag, and runs them through the enrichment scenario again. This keeps your pipeline data current without any manual intervention. The guide on eliminating manual data entry by syncing Keap contacts with Make.com™ covers the broader contact sync architecture this re-enrichment schedule sits within.

What Comes Next

A functioning enrichment workflow is the foundation — not the finish line. Once Keap contact records contain verified, structured data, your campaign builder can do work that generic automation platforms can’t: branch by seniority, personalize by company profile, route by job function, and time outreach based on pipeline stage signal rather than arbitrary follow-up intervals.

To measure whether the enrichment investment is producing the recruiting outcomes it should — reply rate lift, time-to-hire reduction, unsubscribe rate decline — see the guide on measuring Keap and Make.com™ metrics to prove automation ROI. For the specific Make.com™ modules that power the broader pipeline this enrichment workflow feeds into, see the list of essential Make.com™ modules for Keap recruitment automation.

The SHRM research on recruiting efficiency is consistent: the organizations that close candidates fastest are not the ones with the largest recruiting teams — they’re the ones whose systems know the most about each candidate at the earliest possible moment. This enrichment workflow is how you build that institutional knowledge at scale, automatically, before a single recruiter sends a single email.