Building an ai-powered lead enrichment pipeline that actually works

Most founders waste hours manually copying data from LinkedIn into spreadsheets before they can send a cold email. After reading this you’ll be able to assemble a repeatable, ai-powered enrichment flow that pulls fresh data, writes personalized lines, and pushes the result to your outreach tool—all without writing a line of code.

We’ll walk through each piece, show real prompts, note where things break, and give a honest price take. If you’d rather skip the build and deploy a working version in an afternoon, we’ve packaged this workflow as a blueprint at deepusecase.com/vault.

Why manual lead enrichment kills your outreach

Manual work is slow and error‑prone. You open a profile, copy the job title, paste it into a sheet, then repeat for the next fifty leads. By the time you finish, the data is already stale.

That lag means your ice‑breaker feels generic, and reply rates drop. The fix isn’t more hustle; it’s a repeatable system that runs while you sleep.

One‑sentence truth: if you’re still doing this by hand, you’re leaving money on the table.

The core pieces of an ai-powered enrichment flow

At a high level you need three blocks: a scraper, an AI enricher, and a delivery mechanism. The scraper pulls raw LinkedIn data; the AI enricher turns that raw blob into a usable first line; the delivery block pushes the enriched record to your CRM or email sequencer.

1. Scrape LinkedIn profiles with a tool like PhantomBuster or Apify and export to a webhook.
2. Catch the webhook in Make (formerly Integromat) and send the raw JSON to an OpenAI GPT‑4 call.
3. Use a prompt that asks the model to output a short, personalized ice‑breaker based on the job title, recent post, and company news.
4. Take the model’s reply, map it to fields in Airtable or Google Sheets, then trigger your outreach sequencer via another webhook.

That’s the whole loop. Each step can be toggled on or off without touching code.

How do you handle rate limits when scraping LinkedIn?

Rate limits are the silent killer of any scraping job. PhantomBuster, for example, caps you at 80 requests per hour on the free tier. If you blast past that you get a temporary block and your whole pipeline stalls.

What I do is split the work into batches and add a delay node in Make. After each batch of 20 profiles I insert a 15‑minute pause. That keeps us under the limit and lets the IP cool down.

Here’s the exact Make scenario outline:

1. Webhook trigger from PhantomBuster (receives array of profile URLs).
2. Array aggregator set to collect 20 items.
3. HTTP request to OpenAI with the enriched prompt (see next section).
4. Update Airtable record with the AI output.
5. Delay module set to 900 seconds (15 min).
6. Loop back to step 2 until the input array is empty.

If you’re using Apify instead, the same pattern works; just swap the webhook source.

— and good luck finding docs for this — the delay module is buried under “Tools > Sleep”, which took me twenty minutes to locate the first time.

What most guides get wrong about AI prompts for enrichment

Many tutorials tell you to ask the model for “a personalized cold email line”. That’s too vague and leads to fluff like “I hope you’re doing well”. The model needs concrete constraints.

Here’s the prompt I use, tested on GPT‑4‑turbo:


You are a sales copywriter. Given the following LinkedIn profile data:
- Name: {{name}}
- Job Title: {{title}}
- Company: {{company}}
- Recent Post: {{recent_post}}
- Company News: {{company_news}}

Output only the sentence, no extra text.


The key is the word count limit and the demand for a question. Without those you get generic filler.

I also found that feeding the model the raw HTML snippet from PhantomBuster causes token waste. I strip it down to plain text in a Make text parser step before the OpenAI call.

How to debug when this breaks

When the pipeline stops, the first place to look is the webhook logs in Make. If you see a 429 from PhantomBuster, you’ve hit the rate limit—add more delay or upgrade the plan.

If the OpenAI call returns an error, check the prompt length. GPT‑4‑turbo has a 8k token ceiling; a bloated JSON payload can push you over. I keep the input under 1500 characters by trimming irrelevant fields.

Sometimes the AI returns a sentence longer than 20 words or missing the question. I added a filter step in Make that checks the output length and regex for a question mark; if it fails, the scenario routes to a manual review queue in Airtable.

My concrete gripe: the error messages from PhantomBuster’s webhook are cryptic—just “Failed” with no payload—making you guess whether it’s a timeout or auth issue. That’s annoying, but once you know to check the PhantomBuster dashboard logs it’s manageable.

My concrete love: watching the Make scenario view update in real time as each profile moves through the steps. It turns an abstract workflow into something you can see, which cut my debugging time from hours to minutes.

Cost breakdown and my honest take

Here’s what I spend each month to run this at about 500 enriched leads:

• PhantomBuster Scraper‑Lite: $29/mo (allows 10 k requests/mo).
• Make Core plan: $9/mo (enough for the scenario runs and webhook).
• Airtable Plus: $20/mo (gives 5 k records and automation runs).
• OpenAI API (GPT‑4‑turbo, ~0.03 $/1k tokens): roughly $12/mo for 500 leads.
• Total: ~$70/mo.

$29/mo for PhantomBuster is fair for the request volume you get; the free tier is useless for any real volume.

I think the Make Core plan is a steal—$9/mo gives you more than enough runs for a solo operator.

The free tier of Airtable is a joke if you need more than 1 200 records; the Plus plan is the minimum viable option.

We cover this in more depth elsewhere — AI meeting tools coverage.

If you’d rather skip the build and deploy a working version in an afternoon, we’ve packaged this workflow as a blueprint at deepusecase.com/vault.