Build AI Agent LinkedNav Claude MCP

Last updated: May 2026

The Model Context Protocol (MCP) is Anthropic's open standard for letting AI models talk to external tools through a stable, structured interface. For LinkedIn outreach, this matters because:

A single SDR's daily LinkedIn workflow involves: pulling signal-driven leads, qualifying them against ICP, drafting personalized openers, approving AI-drafted replies in the Unibox, monitoring campaign performance, adjusting prompts when reply rates drop. MCP lets Claude run the entire orchestration as a coherent conversation rather than the SDR context-switching between dashboards.

The reason variable substitution stopped working in 2026 is that recipients can spot generic templates. The reason AI personalization works is that the AI has access to the prospect's actual recent activity. MCP gives Claude live access to LinkedNav's signal data, conversation history, and prospect attributes — so the drafts are grounded in real context, not made up.

Every AI-drafted message LinkedNav generates is queued as pending until a human approves it. In a Claude MCP conversation, the SDR can review batches of drafts ("show me the 12 pending replies and the prospect context for each") and approve them in bulk — way faster than clicking through a UI. The conversation is the workflow.

The Claude conversation that orchestrates your outreach is itself reusable. Save it as a Skill, deploy it as an agent, share it across the team. The MCP server stays put; the agent layer evolves on top.

LinkedNav's MCP server exposes 80+ tools spanning the full product surface. The major categories:

The full surface is the same product surface as the LinkedNav app, exposed programmatically.

The integration uses API key authentication. Setup is straightforward.

For Claude Desktop on macOS, edit `~/Library/Application Support/Claude/claude_desktop_config.json`:

```json { "mcpServers": { "linkednav": { "command": "npx", "args": ["-y", "@linkednav/mcp-server"], "env": { "LINKEDNAV_API_KEY": "ln_live_xxxxx_your_key_here" } } } } ```

For Claude Desktop on Windows, the config path is `%APPDATA%\Claude\claude_desktop_config.json` with the same structure.

For programmatic Claude API usage (custom agents), use the MCP server URL pattern documented at linkednav.com/claude-mcp-integration with the API key passed as a header.

Quit and re-open Claude Desktop. The MCP server should appear in the conversation tools panel.

In a new Claude conversation, ask:

``` List my LinkedNav campaigns. ```

Claude should call `get_campaigns` and return the list. If you see an authentication error, double-check the API key. If you see "MCP server not found," check the config JSON for syntax issues.

These are the workflows mature LinkedNav users implement on day one. Each is a Claude conversation that runs the full operation end-to-end.

The pattern: every morning, Claude pulls overnight signal-surfaced leads, qualifies them against ICP, and presents a triage queue.

``` You: Show me the new high-intent signals from the last 12 hours. Match them against my ICP and rank by likelihood of fit. For each, summarize why they're high-intent. ```

Claude orchestrates:

The SDR scrolls the list, picks 12 to add to active campaigns. Claude calls `add_leads_bulk_to_campaign` with the selected IDs.

The pattern: review all AI-drafted replies pending approval and approve / regenerate / deny in one pass.

``` You: List all pending replies. For each, show me the prospect's last message and the AI's draft response. Group by sentiment. ```

Claude orchestrates:

The SDR can then say "approve all the positives, regenerate the neutrals with a more direct CTA, deny the negatives." Claude calls the appropriate `approve_pending_reply`, `regenerate_pending_reply`, `deny_pending_reply` for each ID.

The pattern: weekly performance review surfaces underperforming campaigns and suggests adjustments.

``` You: Audit my campaigns from the last 14 days. Identify any with acceptance rate below 25% or reply rate below 10%. For each underperformer, suggest a likely cause and a specific action. ```

Claude orchestrates:

The SDR confirms the actions; Claude executes via `update_campaign`, `update_prompt`, etc.

The pattern: spinning up new campaigns for new offers requires defining ICP from scratch — Claude can do this in one prompt.

``` You: I'm launching outreach for our new product feature targeting engineering leaders at B2B SaaS companies with 50-500 employees. Generate the ICP and seed prompts. ```

Claude orchestrates:

If the SDR approves, Claude calls `create_ai_setup` to save the ICP and `select_ai_setup` to activate it.

The pattern: comment campaigns drift in tone faster than DMs because comments are public-facing. Reviewing batches before posting maintains brand voice.

``` You: List pending comments. Group by post URL. Flag any that feel salesy or off-brand. ```

Claude orchestrates:

SDR approves the clean batch; regenerates flagged ones with revised prompts. Claude calls `approve_pending_comment` / `update_pending_comment` / `retry_pending_comment` per ID.

The pattern: a prospect surfaced via Signal Agent might also be in a Social Listening import. Without de-dup, they get double-touched.

``` You: Find all contacts that appear in more than one active campaign. For each, show me which campaigns and recommend which one to keep them in. ```

Claude orchestrates:

SDR confirms; Claude calls `remove_leads_from_campaign` for the redundant memberships.

You've read this far because manual click-through workflows aren't scaling. LinkedNav's Claude MCP integration lets Claude run your entire LinkedIn outreach orchestration as a conversation.

Start free →    Read MCP integration docs →

Production agents have a few patterns that separate them from naive prompts:

Never let Claude auto-call `approve_pending_reply` or `approve_pending_comment` without explicit human confirmation. The pending-approval queue exists because AI drafts need human gating; bypassing it defeats the safety architecture and risks LinkedIn restriction. The MCP server doesn't enforce this — your agent design must.

`add_leads_bulk_to_campaign` accepts hundreds of leads at a time. If your agent calls it on every signal surfacing without rate-limiting, you'll hit LinkedIn's ~100/week per-account cap fast. Build agent-side limits: e.g., "no more than 100 leads added per campaign per week without explicit override."

`get_campaigns` and `get_dashboard_summary` are heavy operations. If your agent calls them on every conversation turn, you're wasting API budget and user time. Cache for 5-10 minutes within an agent session, refresh on explicit request.

When Claude suggests a campaign action ("update this prompt to fix the low reply rate"), have it surface its confidence. Low-confidence suggestions should default to "draft for review" rather than "execute." Calibrating this prevents runaway agent behavior.

In production agents, log every MCP tool call with timestamp, inputs, outputs, and downstream actions. Required for debugging when an agent does something unexpected, and useful for auditing AI-driven changes to campaigns.

Spin up a 5-prospect test campaign in a sandbox AI Setup before pointing your agent at production campaigns. Catches prompt issues, race conditions, and integration bugs before they affect live outreach.

The auto-withdraw feature pulls back unaccepted invitations after a configured window. Your agent shouldn't fight against it — adding a prospect to a new campaign right after they were auto-withdrawn from a previous one is a detection signal. Check `get_contact(id)` for recent withdrawal history before re-targeting.

LinkedNav exposes its product surface through both MCP and a REST API. Choosing the right interface matters:

Most mature deployments use both. Conversational SDR workflows go through MCP; CRM-triggered automation goes through REST. They share the same underlying API key and quota.

When something doesn't work, check these in order:

The Claude Desktop config has a syntax error or wrong path. Validate the JSON. Confirm `npx` is on PATH (`which npx` should return a path). Restart Claude Desktop.

The API key is wrong, expired, or has been revoked. Generate a fresh key in linkednav.com/app/integrations and update the config.

The API key is for a different LinkedNav workspace than expected (common when teams have multiple workspaces). Check `get_account_status` — confirm workspace ID matches what you intend to operate on.

The agent is calling tools faster than reasonable (typically a runaway loop). Add agent-side rate limiting; check for unintended retries.

The user's natural-language request is ambiguous. Either rephrase more specifically ("Show me campaigns with reply rate below 10%" instead of "Show me campaigns") or update the agent's system prompt to disambiguate common requests.

`get_contacts` on a large workspace can return thousands of records, blowing the conversation context. Use pagination parameters or filters to scope the request: `get_contacts(filter: { campaign_id: 'xyz', limit: 50 })`.

The prompts that production teams actually use day-to-day:

``` Good morning. Run my daily LinkedNav check-in:

Format as a bulleted briefing I can read in 60 seconds. ```

``` Audit my LinkedNav campaigns. For each active campaign:

Skip campaigns with < 50 sends in the period (insufficient data). ```

``` I'm spinning up a new campaign for [offer description]. Help me:

Don't activate anything yet — just propose; I'll approve. ```

``` Summarize my LinkedNav week:

```

These prompts get reused; teams maintain a library of them as Claude artifacts or shared snippets.

Every differentiator is accessible programmatically:

For most teams, the right deployment pattern depends on use case:

Each SDR runs Claude Desktop with the MCP server configured locally. Personal API key. Conversations stay on the SDR's machine. Lowest setup overhead, doesn't scale to team-shared workflows.

Build a custom agent using the Claude API, with the MCP server configured at the API level. Deploy as a Slack bot, internal web app, or automation cron. Team members invoke shared agent workflows ("approve all positive replies", "audit campaigns") from a single interface.

Package the agent workflows as a Claude Skill or Connector that non-technical SDRs can use without writing prompts each time. The Claude LinkedIn Automation page has examples of this pattern. Users get one-click access to common workflows; the prompts are pre-engineered.

Scheduled Claude API calls running off-hours: nightly campaign audits, daily Signal Agent triage summaries posted to Slack, weekly performance reports. Pattern uses the MCP server but doesn't require human conversation — the agent's outputs feed downstream workflows.

Most mature deployments use combinations: Pattern A for individual SDR work, Pattern B for shared team workflows, Pattern D for monitoring. Pattern C lowers the barrier for non-technical team members.

No, for basic Claude Desktop usage — anyone who can edit a JSON config file can connect Claude to LinkedNav and start running natural-language workflows. For custom agents (Pattern B-D above), some developer skills help but aren't required if you're using the Claude LinkedIn Automation Skills which package common workflows.

The MCP server is the underlying tool surface — it exposes 80+ tools that any MCP-compatible client (Claude Desktop, custom agents, Skills) can call. Claude Skills are pre-packaged agent workflows built on top of the MCP server, designed for one-click use without writing prompts. Most users start with Skills, then graduate to custom MCP-backed agents as their needs become specific.

The MCP server itself is generous on rate limits — designed for interactive conversational use plus reasonable automation. The downstream LinkedIn outreach is rate-limited by LinkedIn's enforcement (~100 invites/week per account), which the agent should respect via tool-design (not by ignoring the underlying constraints).

The MCP server runs as a hosted service from LinkedNav; the npm package wrapper is open for inspection. If you find a bug or want a new tool exposed, contact LinkedNav support.

No. All LinkedNav tiers (Free, Standard $49, Pro $99) include MCP access at no additional charge. Tool-call volume is unlimited within the underlying campaign / outreach quotas.

Yes — MCP is an open standard. Any MCP-compatible client can use the LinkedNav MCP server. Claude is the most-tested client today; OpenAI Agents SDK, Cline, and other MCP clients should also work.

The API key is sensitive — treat it like a password. Don't commit to git, don't share publicly, rotate if exposed. The Claude Desktop config stores it in plain text on your local machine — same security model as SSH keys. For team deployments (Pattern B), use environment variables and secret managers.

It exposes the same data the LinkedNav app exposes to you — your campaigns, your contacts, your signals, your replies. Claude has access to this through the MCP server; treat your conversations accordingly. For especially sensitive workflows (e.g., enterprise deals with NDAs), use ephemeral conversations and don't save them.

Technically yes (Pattern D background automation), but you should never let an agent auto-approve outbound messages or comments. The pending-approval queue is the safety architecture; bypassing it forfeits the human oversight that prevents AI-drafted outbound from going off-brand or off-spec. Agents can auto-execute read operations and suggestion operations; send operations should always have human gating.

``` Show me my campaign performance for the last 7 days. Identify the top 3 by reply rate and the bottom 3 by acceptance rate. For each underperformer, suggest one specific change. ```

This uses `get_performance_analytics`, `get_campaigns`, and Claude's reasoning together — a good test that the integration is working end-to-end.

Yes. Most production teams keep prompts in a git repo, alongside any custom integration code. Prompts are essentially configuration — they evolve as your offer evolves and your understanding of the ICP sharpens. Treating them as code means review processes, change history, and the ability to roll back when a prompt update tanks reply rates. Pair this with the LinkedNav prompt management surface (`get_prompts`, `update_prompt`) so the canonical prompts live in LinkedNav and the version history lives in git.

LinkedIn doesn't expose an outreach API for third parties — automation tools like LinkedNav implement the LinkedIn-side execution via server-side headless browsers, then expose their own API on top. Building from scratch means rebuilding the headless-browser layer, the rate-limiting / safety logic, the multi-account session management, the auto-withdraw logic — typically 6-12 engineer-months of work before you can send a single message safely. Using LinkedNav + Claude MCP collapses that to 10 minutes of config because the safety architecture and orchestration layer already exist and you're just wiring in the AI control plane on top. The build-versus-buy math is settled for almost every team in 2026 — buy the platform that handles LinkedIn execution safely, customize the agent layer on top to fit your sales motion.

Sales Navigator Automation · Social Listening · Multiple Senders · Unified Inbox · Buying Signals