Skip to main content
Glama
Sign In
deenesjakoruzh
agentic-linkedin

agentic-linkedin

by DarkLvrd
OverviewSchemaSourceRelated ServersDiscussionsAdmin
TypeScript
Local

agentic-linkedin

The LinkedIn MCP that never breaks.

An MCP server that gives an AI agent everything a person can do on LinkedIn: you describe what you want, the agent executes it, and you never touch the site.

  • Self-healing — selectors and endpoints live as data; provable fixes auto-apply when LinkedIn changes its DOM

  • Session hygiene — human-like pacing, write budgets, health probes, graceful re-auth; never locks you out

  • Reliable posting — verify-after-post, persisted dedupe keys, never an auto-retry: nothing double-posts

  • Humanized content — per-user voice profiles and an AI-tell audit; everything reads like you wrote it

  • Observable — plan-then-execute with field-level diffs and rendered previews; redacted failure artifacts

Install

npx agentic-linkedin

Requires Node 20+. The package is published to npm; the repository lives at github.com/DarkLvrd/linkedin-mcp.

Related MCP server: LinkedIn MCP Server

For normal people (no code, no terminal)

You don't need to know anything about computers to use this. You need three things: a free chat app, one click to connect, and a one-time LinkedIn sign-in.

Easiest: Cherry Studio (one click)

  1. Download Cherry Studio (free) from cherryai.com/download and install it like any app.

  2. Click this one-click install link:

    Install agentic-linkedin in Cherry Studio

    The app asks you to confirm — accept it. The server is now installed.

  3. Open a chat in Cherry Studio, pick your AI model, and ask it to run the login tool. A browser window opens — sign in to LinkedIn once.

  4. That's it. Talk normally: "post about what I shipped this week" — the AI shows you a preview list first, and nothing posts until you approve.

Also easy: any MCP chat app

Claude Desktop, Cursor, and other MCP apps can add the server with this block (ask the app's help or paste into its MCP settings):

{
  "mcpServers": {
    "agentic-linkedin": {
      "command": "npx",
      "args": ["-y", "agentic-linkedin"]
    }
  }
}

Both paths need Node.js installed once (download, install, next-next-finish) — it's what runs the server behind the scenes.

Sign in (once)

  1. Start the server with your MCP client (Claude Desktop, Cursor, …).

  2. Call the login tool. A browser window opens — sign in to LinkedIn and let it redirect to your feed.

  3. The session persists to disk (~/.agentic-linkedin/session.json) and restores across restarts.

Identity is never stored in the repo or in failure artifacts. Cookie values are redacted from every log, tool output, and artifact by construction.

The workflow: plan-then-execute

Describe what you want. The agent calls plan with the intended writes and gets back an ordered list with previews:

  • profile changes show field-level old → new diffs

  • posts and messages show rendered feed-style previews with their AI-tell audit

  • a raw toggle always exposes the exact arguments

Nothing executes until you approve the plan. reject cancels it. dry_run previews without storing anything. During execution every write still passes the pacing engine: per-sign-in budgets, the hourly ceiling, randomized human-like delays, and health probes — on a challenge the engine pauses until you re-authenticate.

Tools

  • Session: session_status, login

  • Reads: get_me, get_profile, get_posts, get_conversations, get_conversation_history, get_connections_summary, get_invitations, get_jobs, get_analytics

  • Profile: update_profile, add_skill, remove_skill, reorder_skills, delete_ghost_entry

  • Posts: create_post, edit_post, delete_post, comment, react

  • Messaging: send_message (idempotency-keyed), recall_message, react_to_message

  • Network: connect, respond_invitation, follow, endorse_skill, remove_connection

  • Planning: plan, dry_run, approve, reject

  • Self-healing: show_artifact, update_registry

  • Voice: get_voice_profile, set_voice_profile, bootstrap_voice_profile, audit_draft

Configuration (environment variables)

Variable

Default

Purpose

LINKEDIN_READ_ONLY

0

1/true blocks every write tool outright

AGENTIC_LINKEDIN_SESSION_PATH

~/.agentic-linkedin/session.json

where the session persists

AGENTIC_LINKEDIN_DEDUPE_PATH

~/.agentic-linkedin/posts.json

persisted post-dedupe keys

AGENTIC_LINKEDIN_ARTIFACTS_PATH

~/.agentic-linkedin/artifacts

redacted failure artifacts

AGENTIC_LINKEDIN_OVERLAY_PATH

~/.agentic-linkedin/overlay.json

runtime selector-registry fixes

AGENTIC_LINKEDIN_VOICE_PATH

~/.agentic-linkedin/voice

per-user voice profiles

AGENTIC_LINKEDIN_BUDGET_PER_SIGNIN

3

browser-context writes per sign-in (the authwall threshold)

AGENTIC_LINKEDIN_BUDGET_PER_HOUR

60

total writes per sliding hour

AGENTIC_LINKEDIN_PACING_MIN_MS / MAX_MS

1000 / 5000

randomized delay range before writes

AGENTIC_LINKEDIN_PROBE_INTERVAL_MS

60000

session health-probe interval

Development

npm ci
npm run check   # typecheck + build + full test suite

Tests run fully offline: the transport seam is faked, Voyager/SDUI responses are replayed from recorded fixtures, and the binary is exercised end-to-end over stdio. Live LinkedIn actions are never automated in CI.

License

MIT — see LICENSE.

Available Tools

39 tools
add_skillAdd a skillB

Adds a skill to the profile and returns the verified skills state.

Inputs: name (required).

approveApprove a planA

Executes the actions of a pending plan, in order, through the same gated write path as direct tool calls.

Inputs: planId (required).

audit_draftAudit a draftA

Scans a draft for AI tells (inflated claims, formulaic structure, em-dash overuse, chatbot phrasing, robotic rhythm) and returns suggested fixes — never rewrites.

Inputs: text (required).

bootstrap_voice_profileBootstrap a voice profileA

Derives a starting voice profile from the user's past posts (emoji use and sentence length); tune it afterwards.

Inputs: userId (required), samples (required).

commentComment on a postB

Leaves a text comment on a post.

Inputs: text (required), postId (required).

connectSend a connection requestA

Sends a connection request with a note via the quota-checked endpoint; LinkedIn invite limits surface as clear errors.

Inputs: note (required), profileUrn (required).

create_postCreate a postA

Publishes a text post, verifies it by read-back, and refuses to double-post the same content. Reports verified:false honestly when the read-back cannot confirm.

Inputs: text (required).

delete_ghost_entryDelete a ghost entryC

Removes a profile entry that standard deletes miss, routed through SDUI.

Inputs: urn (required), section (required).

delete_postDelete a postB

Deletes a post through SDUI and verifies it no longer appears in the feed.

Inputs: postId (required).

dry_runDry-run actionsA

Produces the same plan and previews as plan, but nothing is stored and nothing can be approved.

Inputs: actions (required).

edit_postEdit a postA

Replaces a post's text and verifies the edit by read-back.

Inputs: text (required), postId (required).

endorse_skillEndorse a skillC

Endorses a skill on someone's profile.

Inputs: skillId (required), profileUrn (required), vanityName (required).

followFollow or unfollowC

Follows or unfollows a person (SDUI) or a company (Voyager patch).

Inputs: urn (required), kind (required), follow (required).

get_analyticsGet profile analyticsA

Returns profile view counts for the signed-in member.

Inputs: no named parameters.

get_connections_summaryGet connections summaryA

Returns the first-degree connection count.

Inputs: no named parameters.

get_conversation_historyGet conversation historyC

Returns the events of a conversation with id, sender, text, and sent time.

Inputs: conversationUrn (required), limit.

get_conversationsGet conversationsC

Returns recent messaging conversations with participants and last activity.

Inputs: limit.

get_invitationsGet invitationsB

Returns pending connection invitations with id, profile, and sent time.

Inputs: limit.

get_jobsSearch jobsB

Searches jobs by keywords and location id.

Inputs: keywords, locationId.

get_meGet my member infoA

Returns the signed-in member: id, name, headline, vanity name.

Inputs: no named parameters.

get_postsGet feed postsB

Returns recent feed posts with id, author, text, and publish time.

Inputs: limit.

get_profileGet a profileB

Returns a member profile (id, name, headline, location, about) by identifier.

Inputs: identifier (required).

get_voice_profileGet a voice profileA

Returns the voice profile for a user, or an error if none exists yet.

Inputs: userId (required).

loginSign in to LinkedInA

Opens a browser window for a one-time sign-in. Sign in and close the window; the session is then persisted and restored across restarts.

Inputs: no named parameters.

planPlan actionsA

Turns intended writes into an ordered plan with per-action previews (diffs for profile changes, rendered previews for posts/messages, raw args always available). Nothing executes until approve.

Inputs: actions (required).

reactReact to a postA

Leaves a reaction on a post: LIKE, PRAISE, APPRECIATION, EMPATHY, INTEREST, or ENTERTAINMENT.

Inputs: postId (required), reaction (required).

react_to_messageReact to a messageC

Leaves an emoji reaction on a message.

Inputs: emoji (required), messageId (required), conversationUrn (required).

recall_messageRecall a messageB

Recalls (deletes) a message you sent.

Inputs: messageId (required), conversationUrn (required).

rejectReject a planA

Marks a pending plan rejected; nothing executes.

Inputs: planId (required).

remove_connectionRemove a connectionB

Removes a connection by vanity name.

Inputs: vanityName (required).

remove_skillRemove a skillA

Removes a skill by its profile-skill URN and returns the verified skills state.

Inputs: skillUrn (required).

reorder_skillsReorder skillsB

Reorders top skills (newest first) and returns the verified skills state.

Inputs: order (required).

respond_invitationRespond to an invitationB

Accepts, ignores, or withdraws a connection invitation; verified by read-back.

Inputs: action (required), invitationUrn (required).

send_messageSend a messageA

Sends a message in a conversation. Returns the originToken idempotency key — pass it back on a retry so nothing double-sends.

Inputs: text (required), conversationUrn (required), originToken.

session_statusSession statusA

Reports the health of the LinkedIn session (healthy, unhealthy with a reason, or no-session) and whether the server runs read-only.

Inputs: no named parameters.

set_voice_profileSet a voice profileB

Creates or updates the voice profile for a user (tone, vocabulary, emoji, sentence length, stories, notes).

Inputs: userId (required), tone, emoji, notes, +4 more.

show_artifactShow a failure artifactB

Returns a redacted failure artifact (failed request, failed strategies, optional DOM dump).

Inputs: id (required).

update_profileUpdate profileA

Edits headline, about, or top-skills and returns the verified profile (read-back).

Inputs: about, headline, topSkills.

update_registryUpdate the selector registryB

Applies a reviewed selector entry to the runtime overlay — fixes land without a redeploy.

Inputs: selectorId (required), strategies (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Deploy Server
    One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

    TDQS

    B3.2/5.0

    Scored across 39 tools

    Disambiguation5/5

    Each tool targets a distinct resource and action, with clear separation between posts, comments, reactions, messages, connections, profile editing, skills, session management, and voice profile operations. Even similar-sounding tools like react and react_to_message are clearly differentiated by their target.

    Naming Consistency3/5

    The dominant pattern is snake_case verb_noun (create_post, send_message, get_profile), but there are several bare verbs like comment, react, connect, follow, login, plan, approve, and reject, plus non-verb names like session_status and dry_run. The mixed conventions are still readable and not chaotic, but they are inconsistent enough to prevent a higher score.

    Tool Count2/5

    39 tools is well beyond the 25-tool threshold where a tool set starts to feel heavy. While the domain is broad—covering posts, messaging, connections, profile management, voice, and approval workflows—the sheer count makes it difficult for an agent to efficiently select among many highly specialized operations.

    Completeness4/5

    The surface covers core LinkedIn lifecycles well: posts can be created, read, edited, and deleted; messaging has send/recall/history; connections have invite/respond/remove/follow; and profiles support updating, skills management, and endorsements. Minor gaps exist—comments cannot be edited or deleted, reactions cannot be removed, and media/post attachments are unsupported—but these are workable limitations rather than fatal dead ends.

    Maintenance

    ActivityStale
    ResponsivenessNo recent community issues

    Resources

    Related MCP Connectors

    Related MCP Servers

    • linkedin-mcp

      2060-io
      A
      license
      A
      quality
      C
      maintenance
      Enables AI agents to publish posts, images, comments, and reactions to LinkedIn as the authenticated user, with built-in safety features like daily budgets and deduplication.
      9
      27 npm
      1
      Apache 2.0

    • LinkedIn MCP Server

      Sabari2005
      A
      license
      A
      quality
      C
      maintenance
      Lets an AI assistant operate LinkedIn through an authenticated browser session, enabling profile management, posting, networking, messaging, job search, and automated applications.
      100
      39 npm
      1
      MIT

    • linkedin-pilot

      juanpacj-wq
      F
      license
      C
      quality
      C
      maintenance
      Enables an AI agent to drive a real LinkedIn account through a persistent browser session, covering full profile editing, people and content interactions (searching, connecting, messaging, posting, reacting), and job search with step-by-step Easy Apply submissions. It reads data through LinkedIn's internal Voyager API while writing through the actual UI, with a saved answer bank so repeated application questions are resolved automatically.
      39
      2
      -