AI Agents
LinkedIn MCP Server: How to Give Claude and Cursor LinkedIn Actions (2026)
A LinkedIn MCP server lets an AI agent look up profiles, send invitations and read replies. Here's how the options differ, how to connect one, and what has to be enforced outside the agent.
Adam A. · · 6 min read
A LinkedIn MCP server is a Model Context Protocol server that gives an AI agent such as Claude, Cursor or ChatGPT tools for LinkedIn: looking up profiles, sending connection requests and messages, and reading the inbox. You add it to your agent like any MCP server. The important difference between options is where the safety limits live.
Key takeaways
- MCP is an open standard for connecting AI apps to tools. A LinkedIn MCP server exposes LinkedIn actions as tools the model can call.
- There are three kinds in 2026: open-source servers you run yourself on your own session, hosted APIs with an MCP endpoint, and campaign tools that added MCP on top of their campaign objects.
- An agent will happily call
send_connection300 times in a loop. Caps, warmup and pacing need to be enforced by the server, not requested in the prompt. - Look for queued writes, a dry-run mode, never-contact-twice dedupe across accounts, and a circuit breaker that stops on a LinkedIn checkpoint.
- Any LinkedIn automation carries account risk. LinkedIn's User Agreement prohibits automated access, and no server removes that risk.
What is a LinkedIn MCP server?
It's a server that speaks the Model Context Protocol and exposes LinkedIn actions as tools. Your agent sees a list of tools with descriptions and input schemas, decides when to call them, and gets structured results back.
Without one, an agent that wants to "invite these 20 people with a short note" has nothing to call. With one, the model can call a send_connection tool with a profile URL and a note, then check the result, then move on, all inside the same conversation or agent loop.
LinkedIn doesn't offer an official MCP server for outreach. Its official APIs focus on things like sign-in, posting, ads and approved partner programs, not on sending invitations or direct messages from member accounts. Every LinkedIn MCP server that can send invites or DMs works through a logged-in member session in some way.
What kinds of LinkedIn MCP servers exist?
There are three broad kinds, and they make different trade-offs on setup, safety and cost.
| Kind | How it works | Good for | Watch out for |
|---|---|---|---|
| Open-source, self-run | You run it locally with your own LinkedIn session (cookie or browser automation). Several exist on GitHub. | One person experimenting with one account | You maintain it when LinkedIn changes; limits are whatever you build; session on your machine and IP |
| Hosted API with MCP | A service holds the session (usually with a dedicated proxy per account) and exposes MCP plus REST | Agents that need several accounts, uptime and webhooks | Pricing model (per account vs per action), what's enforced server-side, data retention |
| Campaign tool + MCP | An existing outreach platform lets the agent manage campaigns, lead lists and stats via MCP | Teams already running sequences in that tool | The agent works with campaigns rather than single actions, so it can't simply "message this person now" |
Before you pick, read the project's README or docs for three things: what tools it exposes, how it stores the LinkedIn session, and what stops an agent from sending too much.
Which tools should a LinkedIn MCP server expose?
At minimum: profile lookup, connection requests, messages, and an inbox read. For agents that run whole conversations, you also want status checks, cancellation and account health.
Here's the tool list SendCrew's MCP server exposes, as an example of a full set (as of November 2026):
| Group | Tools |
|---|---|
| Read | get_profile, check_inbox, get_thread, list_senders, get_sender_health, get_action_status, list_actions, get_stats |
| Write | send_connection, send_message, send_inmail, send_voice_note, view_profile, react_to_post, comment_on_post, withdraw_invite, reply_to_thread, tag_thread, schedule_action, cancel_action |
| Data | find_email (pay-per-use lookup) |
The tools are deliberately small. There's no "campaign" object the agent has to create first: send_message with a profile URL sends that message, and the agent decides what happens next. Every write takes optional sender_id, dry_run, idempotency_key and campaign (a free-text label for grouping stats). The full schemas are in the tools reference.
How do you connect a LinkedIn MCP server to Claude Code or Cursor?
You add the server's URL (for a remote server) or its launch command (for a local one) to your client's MCP config, along with an API key if it needs one. Then the tools show up in the agent.
For a remote server over Streamable HTTP, Claude Code takes one command:
claude mcp add --transport http --scope user sendcrew https://sendcrew.io/api/mcp \
--header "Authorization: Bearer YOUR_API_KEY"
In Cursor, add it to ~/.cursor/mcp.json (or the project's .cursor/mcp.json):
{
"mcpServers": {
"sendcrew": {
"url": "https://sendcrew.io/api/mcp",
"headers": { "Authorization": "Bearer YOUR_API_KEY" }
}
}
}
Local open-source servers usually use a command and args entry instead of a url, and read your LinkedIn session from an environment variable. Follow that project's README.
Once it's connected, ask the agent to list its tools before anything else. It's a quick way to check the server loaded and to see exactly what the model can do.
What should happen when the agent calls a write tool?
The write should be queued and checked, and the call should return right away. It shouldn't open a browser and click through LinkedIn while the agent waits. Pacing is the reason: a human-looking pace means minutes between actions, and an agent can't sit inside a tool call that long.
In SendCrew a write returns immediately with an action id:
{
"action_id": "…",
"status": "queued",
"dry_run": false,
"sender_id": "…",
"run_after": "2026-12-01T09:14:00Z",
"deferred_reason": null
}
The agent can poll get_action_status, or you can subscribe to signed webhooks for accepts, replies and account health. If the account has used today's quota, the write isn't refused. It's queued for the next window with a deferred_reason, so the agent doesn't retry in a loop.
Add "dry_run": true to any write and the server runs every check and says which account would send it and when, without queueing anything. It's the first thing to use when you're testing a new agent prompt.
What safety checks should a LinkedIn MCP server enforce?
The checks that matter are the ones the model can't talk its way around. Ask "can the agent change this with a parameter?" If the answer is yes, it's not a safety check.
A checklist to run against any option:
- Daily and weekly caps per account, enforced by the server. Our defaults for a warmed account are 25 invitations and 50 messages a day, with a ceiling of 100 invitations a week. (Background on these numbers: LinkedIn connection limits in 2026.)
- Warmup for new accounts: lower caps that ramp up over 2–3 weeks.
- Working hours in the account's own time zone, plus random pauses between actions.
- One action at a time per account, in a queue, never parallel bursts.
- Never-contact-twice dedupe across all your accounts, so two senders don't hit the same person.
- A circuit breaker: a checkpoint, captcha or restriction pauses the account and alerts a human. Nothing retries through it.
- One consistent IP and device fingerprint per account, not a shared pool that changes every request.
- Idempotency keys, so an agent that retries after a timeout doesn't send the same message twice.
SendCrew does all eight server-side; the safety rules page lists the current numbers. Whichever server you use, check these against its docs, not its landing page.
How much does a LinkedIn MCP server cost?
Open-source servers are free to run, but you pay in maintenance time and in risk to your own account. Hosted options usually charge per connected LinkedIn account per month, per action, or as part of a wider platform plan.
For reference, SendCrew is priced per connected account, as of November 2026: $79 per account per month for 1–9 accounts ($59 each from 10), $999 a month for 25 accounts, and $2,999 a month for up to 300. Every plan includes a dedicated residential IP per account. Compare on the full cost at your account count, including proxies and any per-action fees.
FAQ
Is there an official LinkedIn MCP server?
No. As of November 2026 LinkedIn doesn't provide an MCP server for sending invitations or messages, and its official APIs don't cover member-to-member outreach. LinkedIn MCP servers that send invites or messages are third-party and work through a member's logged-in session.
Can Claude send LinkedIn messages?
Yes, once you connect a LinkedIn MCP server that has a messaging tool. Claude then calls the tool with the profile URL or thread and the text. Claude itself has no built-in LinkedIn access.
Will using a LinkedIn MCP server get my account banned?
It can. LinkedIn prohibits automated access in its User Agreement, so any automation carries some risk. Volume, pacing, warmup, a consistent IP and stopping at the first checkpoint make a large difference. Pick a server that enforces those for you.
What's the difference between a LinkedIn MCP server and the LinkedIn API?
The official LinkedIn API is LinkedIn's own developer platform, with approved use cases such as sign-in, posting and ads. A LinkedIn MCP server is a tool interface for AI agents. Servers that do outreach use a member session rather than the official API.
Do I need a separate LinkedIn account for each client?
Yes. Each sender is one real person's LinkedIn account. Agencies connect each client's own accounts, ideally in separate client workspaces so contacts and inboxes stay apart.
To try it with your own agent, the SendCrew quickstart walks through connecting an account and making a first dry-run call.