How to Set Up LinkedIn AI Outreach at Scale — Scrape Profile → Hyper-Personalized Message in n8n
Cold LinkedIn outreach fails for one reason: it's obviously templated. "Hi {{first_name}}, I'd love to connect and explore synergies" gets ignored because the recipient knows a bot sent it to 500 othe
Cold LinkedIn outreach fails for one reason: it's obviously templated. "Hi {{first_name}}, I'd love to connect and explore synergies" gets ignored because the recipient knows a bot sent it to 500 other people. The fix isn't sending less — it's making every message read like you spent ten minutes on their profile. This workflow does exactly that: feed it a list of LinkedIn URLs, and it scrapes each profile, reads their recent posts and role, and generates a hyper-personalized connection request plus a follow-up — all written to a Google Sheet ready for you to review and send.
The problem: personalization doesn't scale by hand
Every ops lead and founder knows personalized outreach converts 3–5x better than spray-and-pray. The catch is time. Doing it right means opening each profile, reading their headline, scanning their last few posts, noting their company's stage, and then writing something specific. That's 8–12 minutes per prospect. For a list of 200 people, that's an entire work week of copy-paste tab-switching before you've sent a single message.
So most teams cave and use a generic template with a merge tag. Reply rates crater to 1–2%, the domain reputation of the sending account degrades, and LinkedIn's spam filters start throttling the account. The bottleneck was never the sending — it's the research and writing step in the middle. That's the part a workflow can own.
The solution: a research-and-write pipeline in n8n
The pattern is a linear enrichment pipeline. You supply the raw material (profile URLs), and n8n handles the three expensive steps: scrape the public profile data, reason over it with an LLM to find a genuine hook, and write two messages in your voice. The output lands in Google Sheets — deliberately, not auto-sent — so a human stays in the loop for the final approve-and-send. That single design choice keeps you inside LinkedIn's tolerance and lets you catch the occasional weird AI output before it goes out.
Each row you get back contains: the prospect's name, headline, current company, the specific post or detail the message references, a connection-request note under LinkedIn's 300-character limit, and a longer follow-up for after they accept. You read down the column, tweak anything off, and send. Ten minutes of review replaces a week of research.
Step-by-step: building the workflow
Here's the node-by-node structure. The template ships with all of this pre-wired, but understanding it lets you tune the prompt and swap the scraper for whatever provider you already pay for.
1. Trigger + input source. Start with a Google Sheets Trigger node (or a manual Schedule Trigger for batch runs) pointed at a sheet with one column: profile_url. Read the rows with a Google Sheets node set to Get Rows. This gives you a clean array of prospects to iterate over.
2. Loop and rate-limit. Wire a Loop Over Items (Split in Batches) node with a batch size of 1, and drop a Wait node inside the loop set to 20–40 seconds. LinkedIn and scraping providers both throttle aggressive request patterns — pacing the loop keeps you under the radar and avoids burning API credits on rate-limit errors.
3. Scrape the profile. Use an HTTP Request node against a compliant profile-data provider (services like a proxycurl-style enrichment API, or Apify's LinkedIn actor). Send the profile_url as a query parameter and your API key in an HTTP Header Auth credential — never hardcode the key in the URL. The response returns structured JSON: headline, current position, company, about section, and recent activity. Add an If node right after to skip rows where the scrape failed or returned an empty profile, so bad data doesn't reach the LLM.
4. Shape the data. A Set (Edit Fields) node pulls just the fields you need into clean variables: {{$json.full_name}}, {{$json.headline}}, {{$json.company}}, and {{$json.recent_posts}}. Trimming the payload here keeps your LLM prompt tight and your token cost down.
5. Generate the messages. This is the core. Use the AI Agent node (or a basic Message a Model node) with an Anthropic Claude or OpenAI credential. The recommended model is a current Claude model — claude-sonnet-5 hits the sweet spot of quality and cost for this kind of short-form writing at volume. Your system prompt does the heavy lifting:
"You write LinkedIn outreach for a technical founder. Given a prospect's headline, company, and recent posts, write (1) a connection request under 280 characters that references one specific, genuine detail — never generic flattery — and (2) a 3-sentence follow-up for after they accept. Sound like a peer, not a salesperson. No 'I came across your profile.' No emojis. Return JSON with keys connection_note and followup."
Pass the scraped fields into the user message. Set the node to return JSON so you can map the two outputs to separate columns. Turning on structured output (or adding a Structured Output Parser) guarantees clean, parseable results instead of prose you have to regex apart.
6. Write back to Google Sheets. A final Google Sheets node set to Append or Update (matching on profile_url) writes the name, hook, connection note, and follow-up into your review sheet. Loop closes, next prospect starts.
Benefits: what this actually buys you
Speed. 200 researched, personalized messages generated overnight instead of over a week. You wake up to a full sheet.
Reply rates that hold. Because every message references a real post or role, prospects respond as if you wrote it by hand — because functionally, you did the research part at machine speed and kept the human judgment where it matters.
Account safety. Nothing auto-sends to LinkedIn. The workflow stops at the sheet, so you never trip automation detection, and you keep full control over volume and timing on the actual send.
Reusability. Swap the system prompt and you've got outreach for a different campaign, persona, or product in minutes. The pipeline doesn't care what you're selling.
Common pitfalls to avoid
Auto-sending from the workflow. Tempting, but connecting n8n directly to a LinkedIn-automation send step is how accounts get restricted. Keep the human approve-and-send. The Google Sheet handoff is a feature, not a limitation.
Skipping the empty-profile check. Scrapers fail silently — private profiles, deleted accounts, rate limits. Without the If node filtering empty responses, your LLM will hallucinate a "personalized" message from nothing, and that's worse than no message. Always gate on a valid scrape.
Prompts that produce generic output. "Write a personalized message" gives you personalized-sounding sludge. Force specificity: instruct the model to quote or reference one concrete detail, and explicitly ban the tells ("I came across," "synergies," "I'd love to pick your brain"). Test the prompt on 10 rows and read every output before you run 200.
Ignoring the character limit. LinkedIn connection notes cap at 300 characters. If your model overshoots, the note gets truncated mid-sentence. Set the target to 280 in the prompt and add a Code node to hard-truncate as a safety net.
Running the loop too fast. No Wait node means you hammer the scraping API and hit rate limits within a dozen rows. Pace it. A batch of 200 that finishes overnight is fine; a batch of 200 that fails at row 15 is not.
Get these six nodes wired correctly and you've replaced the single most time-expensive part of outbound — the research — while keeping the judgment and the send under your control. Start with a list of 20 warm prospects, tune the prompt until every output would pass as hand-written, then scale the input list.
Ja construimos isso pra voce
Nao comece do zero. O LinkedIn AI Outreach at Scale — Scrape Profile → Hyper-Personalized Message e um workflow n8n pronto para instalar — conecta suas ferramentas em minutos, sem codigo.
Instalar por $79.0 →
