Firmbase
    ← All resources

    How I Automated My LinkedIn Outreach With Claude — A Founder's Playbook

    Dave Curran·11 min read
    How I Automated My LinkedIn Outreach With Claude — A Founder's Playbook

    TL;DR — I built a Claude-powered agent that runs my LinkedIn outreach for me. It reads my contacts from a CRM, visits each profile in Chrome, sends a connection request (with or without a personalised note), captures enrichment context, respects LinkedIn's rate limits, and writes the outcome back to the CRM. No Zapier. No Expandi. No dodgy scraping tool. Just Claude, a browser, and one plain-English instruction file. Here's exactly how it works.

    Why I was drowning in LinkedIn outreach

    Like most UK B2B founders, I live and die by LinkedIn. At Firmbase we sell into UK sales teams, so LinkedIn is where my ICP lives. The flow has always been the same: identify the right companies, find the right people, connect, have a conversation, book a call.

    The identification bit we've nailed — that's literally what Firmbase does. Describe your ICP in plain English, get a ranked list of matching UK companies and contacts, in seconds. The bottleneck moved to the next step: actually reaching out.

    Doing it by hand was grim. Opening 20 profiles, deciding whether each person was already connected, already pending, email-gated, or unreachable, clicking through LinkedIn's endless modal variants, then remembering to log what happened in the CRM. Forty minutes a day of low-value clicking that I kept putting off — which meant pipeline kept stalling.

    I could have bought a LinkedIn automation tool. I didn't want to, for three reasons:

    1. Account risk. Tools like Expandi, Dux-Soup, and Meet Alfred automate with browser extensions or proxies that LinkedIn's detection has gotten very good at spotting. A flagged account is a catastrophe.
    2. They're dumb. They send the same templated note to everyone, ignore the 20% of profiles that need special handling, and produce nothing useful for the next touch.
    3. It's 2026. I have Claude. Why would I rent a pixel-clicker when I can give an actual reasoning model a playbook?

    So I built my own. The rest of this post is the build.

    What Claude actually does (the 2-minute primer)

    If you're a product person rather than an engineer, here's the mental model you need.

    Claude is a large language model — same family as ChatGPT, but with a few things that matter here. One of them is Claude in Chrome: a browser extension that lets Claude see and control a Chrome window. It can navigate, click, read what's on screen, and fill in forms. It's not a script replaying recorded actions. It's Claude reasoning about each page as it sees it, the same way you would.

    That distinction is the whole game. Traditional automation tools break the moment LinkedIn changes a button label or introduces a new dialog variant. Claude doesn't care. If the page looks weird, it reads the page and figures out what to do.

    The second thing is Skills. A skill is a markdown file — plain English — that tells Claude how to do a specific job. You don't write code. You write instructions, like you'd brief a smart junior hire. Claude reads the skill when it's triggered, then executes.

    So the build wasn't "write a LinkedIn bot". It was: write a really clear brief for a colleague who happens to be an AI with browser arms.

    The architecture

    Three pieces, all talking to each other:

    1. The CRM (source of truth). Every contact I want to reach out to lives in a simple CRM with an API. Each contact has a status (to_contact, connection_sent, connected, email_sequence, replied, not_relevant) and a few fields — LinkedIn URL, company, optional pre-written connection note, and an enrichment_context field that gets filled in as we learn more.

    2. The Claude skill. A single markdown file that describes the entire workflow. It tells Claude: fetch the to_contact list from the API, visit each LinkedIn URL in Chrome, decide what to do based on what's on the page, then write the outcome back to the CRM. It's about 400 lines of prose and decision trees — no code.

    3. Claude, with the Chrome MCP tool enabled. I type "run my LinkedIn outreach" in Claude. It loads the skill, starts working through my list, and reports back when it's done.

    The beauty of this shape: the CRM is the source of truth, the skill is the playbook, and Claude is the worker. I can swap any of the three without rewriting the others. If I want to add email outreach tomorrow, I write a new skill. If I want to change my CRM, I point the skill at a different API.

    The decision tree that makes it reliable

    This is where most "LinkedIn bots" fall over, and where the judgment of a reasoning model actually earns its keep.

    When you land on a LinkedIn profile, the page can be in any one of at least seven states, and the correct action is different for each:

    1. The page didn't load — invalid URL, profile deleted. Mark not_relevant, move on.
    2. It's a company page, not a person. Same — skip.
    3. Already connected (1st-degree). Update status to connected, don't click anything.
    4. Connection request already pending. Mark connection_sent, move on.
    5. Follow-only profile. No Connect button, even in the ... dropdown. Leave them in the pipeline for email outreach.
    6. Connect button present. Click it, then another dialog opens — which could be a standard "add a note" dialog, a "how do you know this person" prompt, or an email gate. Each needs different handling.
    7. Something unexpected. Non-English profile, unusual interstitial, CAPTCHA. Log and skip.

    A rules-based script can kind of handle cases 1–4 if LinkedIn never changes. Case 6 breaks them within weeks. Case 7 breaks them forever.

    Claude handles all of it because it's reading the page and reasoning. The skill just tells it: here's what each state looks like, here's what to do in each case, here's the signal to check first. For example, the reliable way to know someone is already connected isn't the "Message" button (that's also there for LinkedIn Premium users reaching 2nd- and 3rd-degree connections) — it's the 1st degree indicator next to their name. The skill calls that out explicitly. Claude checks for it before touching anything.

    The other thing: when the connection dialog asks "How do you know [name]?", the skill tells Claude to always pick "Other" and proceed. These are the judgment calls that turn a toy into a tool.

    The rules that keep my account safe

    The single biggest risk of any LinkedIn automation is getting your account restricted. LinkedIn monitors connection request velocity very closely. Cross a threshold and you get a warning. Ignore the warning and you get a temporary ban. Do it again and the ban gets permanent.

    The skill enforces hard rules:

    • Maximum 20 connection requests per day, across all sessions. Claude checks today's outreach log before starting each run and only processes what's left of the quota.
    • 20–30 second pause between requests, randomised. No two runs have the same cadence.
    • 2–3 minute pause every five requests. Mimics the natural rhythm of a human switching contexts.
    • Stop immediately on any warning. If LinkedIn shows "you may be sending too many requests", or asks for identity verification, or hits us with a CAPTCHA, Claude stops the session, reports what happened, and leaves the remaining contacts in the pipeline untouched.

    This last rule is where the agent shape genuinely beats a dumb script. A script keeps going until it crashes. Claude reads the warning and pulls the handbrake.

    After a month of running daily, zero account warnings. No restrictions. Same volume I'd be doing manually, just without the 40 minutes of clicking.

    Enrichment is the real win

    Here's the bit I didn't plan for but now wouldn't live without.

    Every time Claude visits a profile, it captures enrichment context from the page: current title, company, location, mutual connections, recent posts if anything jumps out. That goes back into the CRM against the contact.

    Example enrichment line saved against a contact:

    "SVP Sales at Druva (data protection SaaS), based in London. 500+ connections, recently shared a Gartner Magic Quadrant post. 3 mutual connections."

    The next time I (or Claude) reaches out to that person — via email, a follow-up message, a meeting request — that context is right there. I don't have to re-visit their profile. I don't have to remember who they are. The personalisation work that usually happens just-in-time before a touch has already happened, in the background, for every contact in the pipeline.

    This is the compound effect. Every outreach run improves the quality of every future touch.

    What a daily run actually looks like

    In the morning, I type four words into Claude:

    run my LinkedIn outreach

    Claude loads the skill, checks the CRM, tells me where the quota stands ("12 connection requests already sent today — quota remaining: 8"), and starts working. I can keep working on something else while it runs. About 30–40 minutes later, I get a summary:

    • 8 requests sent this session. Six sent with a personalised note, two without.
    • 3 skipped — one follow-only, one email-gated, one company page.
    • 2 newly accepted — people who had pending requests and confirmed on the connections page.
    • Pipeline health: to_contact 12, connection_sent 34, connected 22, email_sequence 8, replied 4, not_relevant 11.

    That last line is the one I didn't expect to care about. Every run ends with a pipeline snapshot. If to_contact is getting thin, I know to run Firmbase and top up my list. The outreach agent and the ICP engine feed each other.

    What this isn't

    This is not a mass-spam tool. It's not "send 500 connection requests to everyone with 'VP Sales' in their title". The list comes from deliberate ICP work in Firmbase. Every contact is someone I actually want to speak to.

    What I've automated is the drudgery around that outreach — the clicking, the state detection, the logging, the pipeline hygiene. The strategy is still mine. The CRM, the ICP, the pre-written notes, the decision to stop on any warning: all mine.

    That distinction matters. It's the difference between scaling myself and pretending to be ten of me. The first compounds. The second gets you banned.

    Should you copy this?

    If you're a UK B2B founder or a small sales team running outbound on LinkedIn, and you can describe your process in clear English, the answer is yes. You need three things:

    1. A CRM with an API you can read and write against. (Airtable, Notion, a Supabase table, or your own.)
    2. A Claude subscription with the Chrome extension installed.
    3. A skill file — the plain-English playbook Claude runs against. You can start from the structure in this post and adapt.

    If you're not technical, the skill file is the new leverage point. It's markdown. Write clearly, be specific about edge cases, and Claude will handle the rest.

    FAQ

    Can Claude automate LinkedIn outreach?

    Yes. Using the Claude in Chrome extension, Claude can navigate LinkedIn, send connection requests, handle every dialog variant (standard, "how do you know", email-gated), and log the outcome to any CRM with an API. The key difference from traditional LinkedIn automation tools is that Claude reads each page and reasons about it rather than replaying a script, which makes it resilient to LinkedIn UI changes.

    Is Claude-based LinkedIn automation safe?

    It's as safe as your rules. In my setup, hard limits of 20 requests per day, 20–30 second gaps between requests, and an automatic stop on any LinkedIn warning mean the outreach stays well within human-speed behaviour. After a month of daily runs, zero account warnings. If you push the volume, LinkedIn will notice — same as with any automation tool.

    Do I need to be a developer to build this?

    You need to be comfortable with APIs and markdown, not with production code. The entire "automation" is a plain-English instruction file Claude follows. The only engineering work is making sure your CRM has endpoints Claude can call. For many founders, that's a one-evening job with a no-code backend.

    How is this different from tools like Expandi, Dux-Soup, or Meet Alfred?

    Three big differences. One: existing LinkedIn automation tools replay scripted flows — they break when LinkedIn changes a button. Claude reads the page each time and adapts. Two: they send the same templated note to everyone. Claude uses per-contact notes from your CRM, falls back to blank requests when no note is set, and captures enrichment context on the way out. Three: they charge monthly for a pixel-clicker. Claude is a general-purpose reasoning model you're likely paying for anyway.

    What else can I automate with this shape?

    Anything that's "visit a website, make a judgment, write the result somewhere, repeat". Email triage, inbound-lead enrichment, competitor monitoring, weekly metrics pulls, content moderation. The CRM-as-source-of-truth + skill-as-playbook + Claude-as-worker pattern generalises a long way.

    Where this goes next

    The LinkedIn agent is one piece of a bigger outbound loop I'm building on top of Firmbase: ICP definition, contact discovery, LinkedIn outreach, email sequences, follow-up, meeting booking. Each step is its own skill. Each skill writes to the same CRM. I run them from a single Claude session.

    If you're a UK sales team sick of manual outbound and curious about what this stack looks like in practice, come and say hi at firmbase.co. Describe your ICP in plain English, get a ranked list of matching UK companies and contacts instantly — and if you want, we'll show you the LinkedIn agent too.

    Cheers,

    Dave