Connect Make.com to ChatGPT via the OpenAI API, pass structured candidate data through a prompt-engineered message, and route the output to a recruiter inbox for review before send. The result: individualized outreach at batch scale without hiring additional recruiters or accepting AI output without oversight.

Why Generic Outreach Fails — and What Actually Fixes It

Top candidates identify a template in two seconds and opt out immediately. The answer is not to hire more recruiters to write individual emails. The answer is a workflow where Make.com™ handles all data movement and trigger logic while ChatGPT writes a genuinely individualized message from the candidate’s actual background.

This is the applied implementation layer of a broader principle: automation-first, AI second. Deterministic logic runs first. AI handles content creation at exactly one step — never the other way around. That sequencing is what separates a reliable production workflow from an unpredictable experiment.

By the end of this guide you will have a live Make.com scenario that reads candidate records, passes structured data to ChatGPT via the OpenAI API, generates a personalized outreach draft, and routes it to your email client or ATS for recruiter review before send. First-time builders should budget two to three hours. Experienced Make.com builders: under ninety minutes.

Before you start, review our guide on AI-powered recruitment workflows and the EEOC AI compliance requirements that apply to any AI-assisted hiring process.

What Do You Need Before You Build?

Complete every prerequisite before opening Make.com. Skipping setup steps is the leading cause of abandoned automation builds.

• Make.com account: Any paid plan works. Free plans have operation limits that throttle batch runs above 20 candidates.
• OpenAI API key: Create one at platform.openai.com. API access is a separate product from a ChatGPT.com subscription — the subscription alone will not work here.
• Candidate data source: This guide uses Google Sheets as the default. If your ATS has a Make.com native module or REST API, use that instead and adapt the trigger step.
• Minimum required data fields per candidate: Full name, current or most recent job title, one specific skill or technology, and the role you are recruiting for. More fields produce better output; fewer fields produce generic output.
• Email client or ATS access: Gmail, Outlook, or your ATS API endpoint for receiving the generated draft.
• Time: Two to three hours for initial build and pilot test. Budget an additional hour for prompt refinement after your first batch.
• Risk awareness: AI-generated content contains factual errors. A human-review gate before send is not optional — it is a structural requirement of this workflow.

Step 1 — Audit and Structure Your Candidate Data Source

The quality of ChatGPT’s output is a direct function of the quality of data you supply. Before building a single module, audit your candidate data.

Open your candidate source — ATS export, Google Sheet, or CRM record — and identify which fields are consistently populated. Create a dedicated sheet or view with only the fields you will use in the prompt. A clean, minimal structure outperforms a bloated export with half-empty columns.

Recommended column structure for your Google Sheet:

• Column A: Candidate full name
• Column B: Current or most recent job title
• Column C: Specific skill, technology, or notable achievement (one sentence maximum)
• Column D: Role you are recruiting for
• Column E: Recruiter highlight (optional — one sentence the recruiter adds manually per candidate; this single field produces the highest-quality personalization output)
• Column F: Status (leave blank; the scenario writes “Sent for Review” here after processing)

Remove any columns containing protected-class information — age, gender, national origin, disability status. These fields must never enter your prompt. Review the California AI procurement compliance requirements and EU AI Act obligations before deploying any AI-assisted outreach at scale.

Once your sheet is clean, add a filter view that shows only rows where Column F is blank. Your scenario processes only unprocessed rows.

Step 2 — Create Your Make.com Scenario and Connect the Data Source

Open Make.com™ and create a new scenario. Name it specifically: “Candidate Outreach — [Role Name] — [Date].” Generic scenario names become unmanageable at scale.

Add the trigger module:

1. Click the first module circle and search for “Google Sheets.”
2. Select Search Rows — not Watch Rows. Watch Rows fires on new additions only; Search Rows lets you process an existing list on demand.
3. Connect your Google account and select your candidate sheet.
4. Set the filter to Column F = empty (unprocessed candidates only).
5. Set Maximum number of returned rows to 10 for your first test run. Increase after validation.

Add an Iterator module immediately after the Google Sheets module. The Iterator breaks the array of rows into individual items so subsequent modules process one candidate at a time. Without it, your OpenAI module receives all rows simultaneously and produces a single blended output. This is a non-negotiable structural requirement.

If you are new to how Make.com scenarios chain modules together, the plain-English guide to Make scenarios covers the fundamentals before you continue.

Step 3 — Add the OpenAI API Module and Write Your Master Prompt

This is the highest-leverage step. A precisely engineered prompt produces consistent, on-brand outreach. A lazy prompt produces output indistinguishable from a template.

Add the OpenAI module:

1. Click the next module circle and search for “OpenAI.”
2. Select Create a Chat Completion (GPT-4o or GPT-4 Turbo recommended).
3. Connect your OpenAI API key.
4. Set temperature to 0.75 — high enough for natural variation, low enough for consistency.

System prompt — paste and customize the bracketed fields:

You are a senior recruiter at [Company Name]. Your tone is professional, warm, and direct. You write concise outreach emails of 100–130 words. Never use hollow phrases like “I hope this message finds you well,” “I came across your profile,” or “exciting opportunity.” Lead with a specific observation about the candidate. End with one clear, low-friction call to action. Do not use bullet points. Write in plain prose.

User prompt — map Make.com variables into the curly-brace fields:

Write a personalized recruiter outreach email to {{Candidate Name}}, who is currently a {{Current Job Title}}. A notable aspect of their background is: {{Skill or Achievement}}. We are recruiting for a {{Target Role}} position. {{Recruiter Highlight}}. Do not fabricate any additional background details. Use only the information provided.

The final instruction — “Do not fabricate any additional background details” — is the most important line in the prompt. Without it, ChatGPT invents credentials, companies, and accomplishments that do not exist. That fabrication creates legal exposure and destroys candidate trust when discovered.

For a deeper look at where AI-assisted Make builds succeed and where they break down, see 5 automation tasks AI handles well and 5 it still gets wrong.

Step 4 — Add the Human-Review Gate and Route the Output

Never wire AI output directly to a send action. The human-review gate is what separates a responsible workflow from a liability.

Option A — Gmail or Outlook draft:

1. Add a Gmail or Outlook module after the OpenAI module.
2. Select Create a Draft — not Send.
3. Map the OpenAI output to the email body field.
4. Map the candidate name and role to the subject line.
5. The recruiter opens their drafts folder, reviews each message, edits as needed, and sends manually.

Option B — Google Sheet logging with ATS routing:

1. Add a Google Sheets Update a Row module.
2. Write the generated email text to a new column (Column G).
3. Write “Pending Review” to Column F.
4. The recruiter reviews the sheet, pastes approved copy into the ATS, and changes Column F to “Approved” or “Sent.”

Option C — Slack or Teams notification:

1. Add a Slack or Microsoft Teams module.
2. Post the generated draft to a dedicated review channel.
3. Recruiters react with an emoji to approve or flag for edit.
4. A second scenario monitors that channel and routes approved drafts to the email client.

Option A is the fastest path for teams of one to three recruiters. Option B scales better for teams using a shared ATS. Option C works well for distributed teams where approval accountability matters.

Step 5 — Add the Status Update Module

After the routing module, add a final Google Sheets Update a Row module that writes “Sent for Review” to Column F for the processed row. This prevents double-processing on the next scenario run.

Without this step, every run reprocesses every candidate — generating duplicate drafts and wasting API credits. The status column is the idempotency mechanism that makes batch processing safe.

This same pattern — process, output, mark done — applies to every batch automation built in Make.com.

Step 6 — Test With a Single Row Before Running a Batch

Before processing your full candidate list, run the scenario against a single test row containing fabricated data. Use a made-up name, title, and skill so no real candidate data is exposed during debugging.

Test checklist:

• Does the scenario complete without errors?
• Does the email draft contain the candidate name from your test row — not a placeholder?
• Is the email length 100–130 words?
• Does the opening line reference the candidate’s background specifically?
• Is there a single, clear call to action at the end?
• Does Column F update to “Sent for Review” after the run?
• Does a second test run skip the already-processed row?

All seven checks must pass before you run a live batch. Skipping this step and running a batch of 50 candidates with a broken prompt wastes time, API credits, and recruiter attention during review.

How Do You Know the Workflow Is Working?

Measuring workflow performance distinguishes a maintained production system from a one-time build that degrades over time.

Track these four metrics from day one:

1. Recruiter edit rate: What percentage of drafts require substantive edits before approval? Target under 30%. Above 50% signals a prompt or data quality problem.
2. Fabrication rate: How often does a draft contain a detail not present in the source data? Target zero. Any fabrication requires immediate prompt correction.
3. Response rate delta: Compare response rates from AI-assisted drafts against your previous manual outreach baseline. A properly built workflow with good data produces a measurable improvement within 30 days.
4. Processing time per candidate: From trigger to draft-in-inbox. Target under 45 seconds per candidate for standard batches.

If your recruiter edit rate exceeds 50%, revisit Step 3. The problem is almost always in the system prompt — either the tone instruction is too vague, the word-count constraint is missing, or the banned phrases list needs expansion.

What Are the Most Common Mistakes?

1. Skipping the Iterator module. Every builder who skips the Iterator discovers the problem the same way: the OpenAI module returns one blended email that addresses no candidate specifically. Add the Iterator immediately after the data source module.

2. Connecting the OpenAI module to a Send action instead of a Draft or logging action. One bad batch sending 200 unreviewed AI emails to candidates is a reputation event, not a process error. The human-review gate is non-negotiable.

3. Including protected-class data in the prompt. Any field containing age, gender, national origin, or disability status must be stripped before data enters the OpenAI module. This is a legal requirement, not a preference.

4. Using temperature above 0.9. High temperature produces creative output. It also produces invented credentials, hallucinated employers, and off-brand tone. Stay at or below 0.75 for outreach content.

5. Building without a status column. Without an idempotency mechanism, every scenario run reprocesses every candidate. The status column is the fix. Build it in Step 1, not as an afterthought.

6. Treating the first prompt as the final prompt. Prompt engineering is iterative. The system prompt you write today will need revision after your first live batch. Budget time for that refinement session.

If you want a structured framework for evaluating any Make.com build before it goes to production, see how to evaluate an AI-built Make scenario before it goes live.

Frequently Asked Questions

Can this workflow send emails automatically without recruiter review?

It can be wired that way, but it should not be. AI-generated content contains errors. An unreviewd send action will eventually produce an email with fabricated credentials or off-brand tone that reaches a candidate. The reputational cost of that error exceeds any time savings from removing the review step. Keep the human gate.

Does this work with ATS systems other than Google Sheets?

Any ATS with a Make.com native module or a REST API works as the data source. Replace the Google Sheets trigger with your ATS module and map the equivalent fields. The OpenAI and routing steps remain identical.

What happens when ChatGPT returns an error or empty output?

Add an error handler to the OpenAI module. Route error bundles to a separate Slack notification or Google Sheet log so recruiters know which candidates were skipped. A workflow with no error handling fails silently. For a step-by-step approach, see how to set up routed error handling in Make.

How do I prevent the same candidate from being processed twice?

The status column in Step 5 is the answer. The trigger module filters for Column F = blank. Once the scenario writes “Sent for Review” to Column F, that row is excluded from every future run.

Is this approach compliant with EEOC guidelines?

The workflow itself does not make hiring decisions — it drafts outreach copy. AI writing assistance at the outreach stage carries lower compliance risk than AI screening or scoring tools. The key requirements are: no protected-class data in the prompt, human review before send, and documented oversight. Review the full EEOC AI compliance guidance for your specific deployment context.

What is the difference between GPT-4o and GPT-4 Turbo for this use case?

GPT-4o is faster and less expensive per token. GPT-4 Turbo produces marginally more consistent tone adherence on complex system prompts. For standard 100–130 word outreach emails, GPT-4o is the right default. Switch to GPT-4 Turbo if tone consistency becomes a recurring issue after prompt refinement.

Additional Reading

• What Is Automation-First? Why You Should Automate Before You Add AI
• 10 Automations That Are Finally Easy to Build With Make + AI — No Developer Needed
• How to Evaluate a Make Scenario Built by AI Before It Goes to Production
• How to Set Up Routed Error Handling in Make With AI Assistance
• 5 Automation Tasks AI Handles Well — and 5 It Still Gets Wrong
• What Is a Make Scenario? The Plain-English Guide for Zapier Users
• 9 EEOC AI Compliance Requirements HR Teams Must Meet in 2026
• California AI Procurement Compliance: Action Steps for HR and Recruiting
• 11 EU AI Act Requirements Every HR Leader Must Know in 2026
• AI-Powered Recruitment: Transforming HR Workflows
• Make.com FAQ: Everything Zapier Users Ask Before Switching
• 7 Questions to Ask Before You Automate Anything (The OpsMap Checklist)
• AI-Assisted Make Automation: Frequently Asked Questions
• The AI Automation Advantage in Candidate Sourcing
• Accelerate Hiring: A Step-by-Step Guide to AI Candidate Screening