Build a Make.com scenario that triggers on Keap contact or opportunity events and writes structured candidate data directly into Google Sheets — no copy-paste, no transcription risk, no lag. The full setup takes 45 to 90 minutes and eliminates a recurring manual task that compounds into days of lost recruiter time each year.

Manual data transfer between Keap and Google Sheets is a tax on recruiting speed. Every time a recruiter copies a candidate record by hand, they introduce transcription risk and burn time that should go toward sourcing and closing. This guide builds the automated alternative: a Make.com scenario that captures Keap contact and opportunity events in real time and writes them directly into a structured Google Sheet.

Before building this scenario, it helps to understand what a Make scenario is and how it works. If you are coming from Zapier, the Zapier-to-Make migration guide covers the structural differences that matter for builds like this one. And if you want the full architecture connecting Keap to every tool in your recruiting stack, the HR and recruiting automation overview covers the broader system design.

The productivity math is straightforward. Jeff’s 2007 observation from his Las Vegas mortgage branch still holds: 10 minutes of manual data entry per day equals one full work week lost every year — per person. On a recruiting team of three, that compounds fast. Manual data entry at scale destroys recruiting capacity in ways that never show up cleanly on a budget line.

What You Need Before You Start

Gather these before opening Make.com. Missing any one of them mid-build stalls the entire setup.

• Active accounts: Keap (with admin or automation permissions), Google Workspace or personal Google account with Sheets access, and a Make.com account on any paid plan — free plans have limited webhook support.
• Keap permissions: You need access to Keap’s Campaign Builder or Automation Builder to create an HTTP POST action. Confirm this with your Keap admin before starting.
• Google Sheet prepared: Create the destination spreadsheet and label Row 1 with explicit column headers before building the scenario. Vague headers like “Notes” or “Date” create unmaintainable data. Use specific labels: “Keap Contact ID,” “Candidate First Name,” “Candidate Last Name,” “Email Address,” “Application Date,” “Pipeline Stage,” “Recruiter Owner,” “Last Updated.”
• Time required: 45 to 90 minutes for initial build and test. Add 30 minutes if you plan to configure filters or error-handling routes.
• Risk to note: A poorly mapped field will silently write wrong data — not throw an error. Testing with a live Keap event before activating is mandatory, not optional.

Step 1: Define Your Data Requirements

Before touching Make.com, document every Keap field you need in the log. Recruitment data logging without a defined field list produces a cluttered, unreportable sheet within weeks.

For most recruiting pipelines, the core fields to capture from Keap include:

• Contact ID — Keap’s unique identifier, critical for deduplication and update matching
• First Name, Last Name
• Email Address, Phone Number
• Application Date or Contact Creation Date
• Current Pipeline Stage or Opportunity Stage
• Assigned Recruiter (Owner field)
• Tags applied (comma-separated if multiple)
• Custom fields specific to your firm — resume source, role applied for, salary expectation

Map this list directly to your Google Sheet column headers before proceeding. Every column header you create now corresponds to a Make.com mapping field in Step 4. The more deliberate this structure, the faster Step 4 becomes.

This field-definition discipline is the same principle behind the OpsMap™ audit process — document what data you need and where it lives before you build anything. Skipping this step is the most common reason recruiting data logs become unusable.

Step 2: Create a New Make.com Scenario and Select Your Keap Trigger

Log in to Make.com and click Create a new scenario. The scenario canvas opens with a single empty module circle — this is your trigger.

1. Click the empty module and search for Keap.
2. Select the trigger event that matches the recruiting action you want to capture:
   • Watch New Contacts — fires when a new candidate record is created in Keap.
   • Watch New/Updated Opportunities — fires when a pipeline stage changes, making it the better choice for stage-progression logging.
   • Custom Webhook — the most flexible and fastest option; covered in Step 3.
3. Click Add next to the Keap connection field and authenticate using your Keap API key or OAuth flow as prompted. Make.com stores this connection for all future Keap scenarios.
4. Configure the trigger parameters. For polling triggers, set the interval — every 15 minutes is the default. Reduce this if your plan supports it, or switch to webhook for real-time delivery.

For recruiting workflows where timing matters — offer confirmations, stage advancements, interview completions — use the webhook approach in Step 3 rather than a polling trigger. Understanding how Make scenarios process data helps you choose the right trigger type for your specific use case.

Step 3: Configure the Keap Webhook and Verify the Connection

The webhook trigger is faster and more reliable than polling for recruitment data logging. Here is how to configure it end to end.

In Make.com:

1. Replace the Keap polling trigger module with a Webhooks > Custom Webhook module.
2. Click Add to generate a unique webhook URL. Copy this URL — you will paste it into Keap in the next step.
3. Leave the Make.com scenario on the canvas with the webhook module waiting. It will listen for the first test payload.

In Keap:

1. Navigate to Campaign Builder (or Automation Builder, depending on your Keap tier).
2. Create or open the automation that fires on your chosen recruitment trigger event — for example, “Contact Tag Applied: Application Received” or “Opportunity Stage Changed.”
3. Add an HTTP Post action step to the automation sequence.
4. Paste the Make.com webhook URL into the HTTP Post URL field.
5. In the Post Body, add the Keap merge fields for every data point you listed in Step 1. Format them as key-value pairs. Example: contact_id=~Contact.Id~&first_name=~Contact.FirstName~&email=~Contact.Email~&stage=~Opportunity.Stage~
6. Save and publish the Keap automation.

Verify the connection:

1. Trigger the Keap automation manually by applying the tag or advancing a test contact through the pipeline stage.
2. Return to Make.com. The webhook module displays a green checkmark and shows the incoming data structure.
3. Click the webhook module to inspect the payload. Confirm every field you listed in Step 1 appears in the data bundle. If a field is missing, return to the Keap HTTP Post body and add the missing merge field.

If you need deeper error-handling logic for this scenario, the guide on setting up routed error handling in Make covers the architecture for routing failed executions without losing data.

Step 4: Map Keap Fields to Your Google Sheet Columns

With the webhook delivering data to Make.com, add the Google Sheets module that writes each record as a new row.

1. Click the + icon to the right of the webhook module to add a new module.
2. Search for Google Sheets and select Add a Row.
3. Authenticate your Google account if you have not already done so.
4. In the Spreadsheet ID field, select the Google Sheet you prepared in the prerequisites. Make.com lists all Sheets your connected account can access.
5. Select the correct Sheet Name (tab) within the spreadsheet.
6. Make.com now displays a field for each column header in Row 1 of your Sheet. Map each field:
   • Keap Contact ID → Column A (Keap Contact ID)
   • First Name → Column B (Candidate First Name)
   • Last Name → Column C (Candidate Last Name)
   • Email → Column D (Email Address)
   • Application Date → Column E (Application Date)
   • Pipeline Stage → Column F (Pipeline Stage)
   • Owner/Recruiter → Column G (Recruiter Owner)
   • Last Updated → Column H — use Make.com’s {{now}} timestamp function here
7. For any field that may arrive empty from Keap, use Make.com’s ifempty function to insert a default value rather than leaving a blank cell. Example: {{ifempty(1.stage; "Unassigned")}}

Mapping accuracy here directly determines reporting reliability downstream. Take the time to verify each mapping against a real Keap payload before moving to Step 5.

Step 5: Add Filters to Prevent Unwanted Rows

Not every Keap event should create a new row in your recruitment log. Without filters, your Sheet fills with noise: internal contacts, test records, duplicate stage events.

To add a filter between the webhook module and the Google Sheets module:

1. Right-click the arrow connecting the two modules and select Set up a filter.
2. Define the conditions that must be true for a row to be written. Common recruitment filters:
   • Tag name contains “Applicant” or “Candidate”
   • Opportunity Stage does not equal “Test” or “Internal”
   • Email address is not empty
   • Contact ID is not on an exclusion list
3. Test the filter by triggering a Keap event that should be blocked. Confirm the scenario runs but the Google Sheets module is skipped.
4. Test again with an event that should pass. Confirm the row is written correctly.

Filters are lightweight and do not count against your Make.com operation limits when the scenario stops before the downstream module executes. Use them aggressively — it is easier to loosen a filter later than to clean up thousands of junk rows.

Step 6: Activate the Scenario and Set the Schedule

Before activating, run a final end-to-end test:

1. Trigger a live Keap event — apply the tag or advance a real test contact to the target pipeline stage.
2. Watch the Make.com scenario execute in real time. Each module should show a green success indicator.
3. Open your Google Sheet and confirm the new row appears with every field populated correctly.
4. Check the timestamp in the Last Updated column. Confirm the format matches your reporting expectations.

Once the test passes:

1. Click the Scheduling toggle in the lower-left corner of the Make.com canvas to turn the scenario on.
2. For webhook-based scenarios, the scenario activates immediately and runs on demand whenever Keap sends a payload. There is no polling interval to set.
3. For polling-based scenarios, set the run interval. Every 15 minutes is the standard starting point.
4. Enable Incomplete Executions in the scenario settings so that any failed run is saved for review rather than silently dropped.

If you want to build more Make automations beyond this specific scenario, building Make automations in plain English using the MCP server dramatically accelerates build time — especially for scenarios involving API modules or complex routing logic. For AI-assisted builds specifically, review how to evaluate an AI-built Make scenario before it goes to production.

How to Know It Worked

The scenario is functioning correctly when all of the following are true:

• Every Keap recruitment event that matches your filter writes a new row to the Google Sheet within the expected timeframe — immediately for webhooks, within the polling interval for scheduled triggers.
• All mapped fields populate with accurate data. No fields are blank that should have values. No fields contain IDs where labels are expected.
• The Last Updated timestamp is current and correctly formatted.
• Filtered events — test contacts, internal records — do not appear in the Sheet.
• The Make.com execution history shows 100% success rate over 48 hours of live operation with no incomplete executions.
• A recruiter on your team can open the Sheet and immediately understand every column without asking for explanation.

If any of these conditions fail, return to the step where the failure originates. Most issues trace back to Step 1 (incomplete field list), Step 3 (missing Keap merge fields), or Step 4 (incorrect data type mapping).

Common Mistakes That Break This Build

Vague Google Sheet headers. Column headers like “Status” and “Date” produce a Sheet that no one can report from six months later. Use explicit labels from the start.

Testing with synthetic payloads instead of real Keap events. Make.com’s built-in test data does not replicate the edge cases that real Keap records produce — empty fields, unexpected formatting, long tag strings. Always test with live events.

Skipping the filter step. Without filters, every Keap contact event — including internal records, test contacts, and duplicates — writes to the Sheet. Clean data architecture requires deliberate exclusion rules from the start.

Ignoring incomplete executions. If Make.com’s Incomplete Executions setting is off, failed runs disappear silently. A candidate record that triggers a Keap event but fails in Make.com never appears in the Sheet — and no one knows it is missing.

Not using the Contact ID as the anchor field. Without Keap’s Contact ID in the Sheet, deduplication and future update-matching become impossible. Always include it, even if no current report uses it.

Mapping dates as plain text. Make.com delivers dates in ISO 8601 format by default. If your Google Sheet column is formatted as plain text, dates sort and filter incorrectly. Format the column as Date in Google Sheets and use Make.com’s formatDate function to match.

What to Build Next

This scenario handles new record creation and stage events. Once it runs cleanly for one week, three natural extensions add significant value:

• Update existing rows instead of adding new ones. Add a Google Sheets Search Rows module before the Add a Row module. If the Contact ID already exists, route to an Update a Row module instead. This prevents duplicate rows when the same candidate advances through multiple stages.
• Conditional routing by stage. Add a Router module after the webhook. Route different pipeline stages to different Sheets or different notification channels — for example, candidates who reach “Offer Extended” trigger a Slack notification to the hiring manager.
• Error alerting. Add an error handler route that sends a Slack or email notification when an execution fails, including the candidate’s name and the error message. The AI-built error handler case study shows how this reduces diagnostic time from 20 minutes to a glance.

For recruiting teams evaluating whether to build additional automation in-house or with a partner, the DIY vs. Make partner decision guide covers when each approach makes sense in 2026.

Frequently Asked Questions

Does this scenario work with Keap’s legacy (Classic) version or only the current version?

The webhook approach in this guide works with both Keap versions. Keap Classic uses Campaign Builder for HTTP Post actions; the current version uses Automation Builder. The Make.com webhook URL configuration is identical regardless of which Keap tier you use.

What happens if Make.com goes down while a Keap event fires?

Keap’s HTTP Post action will receive a failed response. Depending on your Keap automation settings, it will either retry the POST or mark the execution as failed without retry. To prevent data loss, enable Incomplete Executions in Make.com so any payload that arrives during a partial outage is queued for processing when the scenario resumes.

Can this scenario update an existing row instead of always adding a new one?

Yes. Add a Google Sheets Search Rows module before the Add a Row module. Search for the Keap Contact ID in column A. If a match exists, route to an Update a Row module using the matched row number. If no match exists, route to the Add a Row module. This pattern requires a Router module and adds approximately 20 minutes to the build.

How many Make.com operations does this scenario consume per execution?

A basic webhook-trigger-to-Google-Sheets build consumes two operations per execution — one for the webhook module and one for the Google Sheets Add a Row module. If you add a filter that blocks the execution before the Sheets module runs, only one operation is consumed. Adding a Search Rows module adds one more operation per execution.

Is this the right approach for a recruiting firm logging hundreds of candidates daily?

Yes, with one addition: implement the update-vs-add routing described in the “What to Build Next” section. At high volume, duplicate rows from the same candidate advancing through multiple stages become a data quality problem quickly. The Contact ID anchor field and conditional routing are essential at scale.

Additional Reading

• What Is a Make Scenario? The Plain-English Guide for Zapier Users
• How to Switch From Zapier to Make Without Breaking Your Existing Workflows
• How to Run an OpsMap Audit Before Automating Anything
• 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 Build a Make Automation in Plain English Using the MCP Server
• DIY Automation vs. Hiring a Make Partner in 2026: When to Do Each
• How an AI-Built Error Handler Reduced Technician Research Time From 20 Minutes to a Glance
• Make.com FAQ: Everything Zapier Users Ask Before Switching
• Manual Data Entry: The Silent Killer of Business Productivity and Profit
• Automate HR and Recruiting: End the Manual Data Drain, Unlock Growth
• 7 Questions to Ask Before You Automate Anything (The OpsMap Checklist)
• 8 Make.com Scenarios That Are Now Faster to Build With AI
• How to Build a Make Scenario With Claude: A Step-by-Step Walkthrough
• Recruiting Automation: Transforming Hidden Costs into Measurable ROI