How to Scrape LinkedIn and Run Cold Emails in 2026: The Full Signal-Based System

Most cold email is a numbers game played blind: buy a list, blast it, hope. In 2026 that lands you in spam. The teams winning are doing the opposite. They send to fewer people, chosen better, and they let a machine decide who is even worth a message.

The outcome is a system that watches your market, catches the people already showing intent, scores every one of them against who you actually sell to, and only reaches out to the ones worth reaching. It runs evergreen, it fills your pipeline while you sleep, and you own every part of it.

This is not a tool you rent. It is infrastructure you build once. Here is exactly how it works.

Start with people already in motion

Your best leads are not sitting in a database. They are on your feed right now, engaging with the right posts, standing in the right rooms.

So you point the system at motion, not at a static list.

Three sources feed it:

• Around 10 influencers your buyers follow. Scrape everyone who engages with their posts.
• Your profile visitors and your company page visitors.
• Everyone who touches your own content.

Every one of these people is warm by definition. They are active, and they are standing right next to the topic you sell into. That is your raw signal, and it is the whole premise behind signal-based prospecting.

Build the machine, not a workflow

Here is where most setups stop: a Zapier flow that breaks the moment real volume shows up. Ours is infrastructure. A codebase running in the cloud that owns the entire loop end to end: catch the engager, scrape the profile, qualify it, enrich it, sort it into tiers, and hand it to the sender.

Put a light dashboard on top, backed by Supabase, and you see every lead, its tier, and where it sits in the pipeline at a glance.

The scrapers (Apify actors plus a few custom ones) pull the profiles. But the part that makes it yours is not the code, it is the documents that drive it: your ICP and your qualification rules, written in plain markdown. The engine reads them, so you change who you target by editing a doc, and the whole machine adjusts.

We build and run the whole engine in Claude Code, and on the backend you are really just stacking APIs. You connect the Apify API for the scraping (easy enough, and you can swap in other actors or tools whenever you want), then plug in the scoring model, the enrichment providers, and the sender, all into one place.

From there you run the entire pipeline straight from your terminal, or put a simple custom frontend on top. No sprawl across ten tabs and a dozen logins, one workspace that runs the machine.

Qualification is the whole game

This is the difference between a 1 percent reply rate and a real one. Before anyone gets a message, the system grades them in two passes, cheap first.

First, hard rules. Deterministic and free. Wrong country, open-to-work, a recruiter, a competitor, an existing client: they die instantly, no model involved.

# Hard rules. Edit the file, not the code.
geo_whitelist: [United States, Canada, United Kingdom]

title_dq_regex:
  - '(?i)open to (work|opportunities)'
  - '(?i)\b(student|intern|recruiter)\b'

company_blacklist: [competitors, existing_clients]

Then, judgment. For everyone who survives, the model reads your ICP doc and the profile's real signals, the company, the title, the seniority, the recent posts, and returns a score with a reason.

This is where you encode taste, the stuff a rule can never capture. The score becomes a tier, and the tier decides everything downstream:

score 7-10  ->  Tier 1        LinkedIn + email
score 4-6   ->  Tier 2 / 3    email only
score 1-3   ->  Disqualified  leave alone

Enrich, tier, and route

Only now do you spend money. The qualified tiers run through waterfall enrichment: stack a few providers, try them in order, and verify every email before it sends. Then each tier gets the treatment it earned:

• Disqualified: left alone.
• Tier 1: LinkedIn plus email, the full-court press.
• Tier 2 and 3: email only.

Everything lands in your dashboard, so you always know how many leads you caught, how they tiered, and what is in flight. That is real lead qualification, not a spreadsheet you forget to update.

The copy, and running it evergreen

The system hands your writer the context, so the copy can be short and specific: value first, under 80 words, built on the real signal, the post they engaged with, their company, their moment. It reads like a person wrote it, because now it can.

Then you let it run evergreen, and you do not bet on one message. Run two or three offers and angles in parallel, route leads across them, and let the replies tell you which positioning wins. It is the same backbone as the warm outbound playbook and a full signal-based outbound engine.

Tricks from running it live

• Stack a few enrichment providers. No single tool finds every email. Two or three in the waterfall means you actually reach your tier 1 leads instead of losing a third to missing data.
• Watch your scrapers. Apify actors are the fastest start, but uptime moves. Keep a custom scraper or backup source ready so one broken actor never stalls the pipeline.
• Never run just your main offer. Two or three campaigns, different angles, A/B tested. The winner is rarely the one you expected.

You own the engine

Rented tools change their pricing and keep your data. This is the opposite: the scrapers, the ICP and tier documents, the enrichment, the dashboard, and the sequences, all running in your own cloud, all yours.

Signal in, qualified pipeline out, on autopilot. If you want it built for your business, we build it with you and hand you the keys.