Skip to main content
Glama

Iridium: LinkedIn MCP Server

Server Details

LinkedIn MCP for Claude, ChatGPT, Grok, Hermes: triage inbox, comment, find people, live profiles

Ownership verified
Status
Healthy
Uptime
100.0% over the last 24 hours
OAuth
Works in Glama
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
–

TDQS

A3.5/5.0

Scored across 64 tools

Disambiguation3/5

The descriptions work extremely hard to separate overlapping tools (find_person vs discover_prospects vs find_prospects vs search_prospects; schedule_manual_dm vs schedule_chat_reply vs schedule_dm_to_person), which is far better than most servers. However, the underlying surface genuinely has four people-search tools and three DM-sending tools with near-identical names, plus a four-way draft matrix (draft/comment_draft/content_draft/reply_draft × list/approve/rewrite/skip) that an agent can easily misselect. The disambiguation burden is pushed entirely onto long prose rather than distinct tool shapes.

Naming Consistency4/5

Nearly everything follows a snake_case verb_noun pattern (list_chats, approve_draft, search_posts_by_topic, withdraw_connection_request), which is highly predictable. Minor deviations exist: schedule_dm_to_person vs schedule_manual_dm vs schedule_chat_reply use inconsistent object naming, get_draft_detail breaks the verb_noun symmetry of the other getters, and connect_linkedin_checkpoint_mcp carries a stray suffix. These are small blemishes on an otherwise consistent scheme.

Tool Count2/5

64 tools is far past the range an agent can hold in view, even for a broad LinkedIn automation domain. Several slots are pure waste: create_sequence and enroll_prospect are explicitly disabled stubs, and the prospect-search family has four tools where two would likely do. The surface is heavy enough that selection errors are likely regardless of description quality.

Completeness4/5

Coverage is genuinely broad: multi-path LinkedIn connection, inbox backfill/search/read/summarize, four draft lifecycles with list/detail/rewrite/approve/skip, scheduling with reschedule/cancel, connection-request receive/respond/withdraw, activity log, settings, and account deletion. Gaps are minor (e.g. no way to un-approve or edit a scheduled send's text, multi-step sequences disabled with only manual scheduling as a workaround). Agents can work around the remaining holes without dead ends.

Available Tools

64 tools
approve_comment_draftAInspect

Approve Comment Draft

Approve one comment draft and schedule it to post. THIS PUBLISHES A PUBLIC COMMENT.

The comment appears on someone else's post under the user's name, so call this only when the user has explicitly approved this specific comment. It counts against their daily comment limit.

Args: handle: cdft_ handle from list_comment_drafts. comment_text: replacement text. Omit to post the drafted text as written. comment_at: "now" to post immediately, or ISO-8601 with an offset. Omit to let Iridium pick a time.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required), comment_at, comment_text.

approve_content_draftAInspect

Approve Content Draft

Publish or schedule one of the user's own LinkedIn posts. THIS POSTS PUBLICLY.

The post appears on the user's profile. Call this only when they have explicitly approved this specific post.

Args: handle: ctnt_ handle from list_content_drafts. post_text: the final text to publish. Required, because the user is expected to edit before publishing. scheduled_at: ISO-8601 with an offset to schedule it. Omit to publish immediately.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required), post_text (required), scheduled_at.

approve_draftAInspect

Approve Draft

Approve one connection-note draft and schedule it. THIS SENDS.

Call it only when the user has explicitly asked for this specific draft to go out. Finding or drafting something is not permission to approve it. The connection request counts against the user's daily limit.

Returns a draft_ handle for the scheduled send, usable with reschedule_send and cancel_scheduled, so there is no need to call list_scheduled afterwards.

Args: handle: draft_ handle from list_drafts, discover_prospects, or run_outreach_pipeline. override_text: replacement note text. Omit to send the drafted text as written, or pass "" to send the connection request with no note at all. send_at: "now" to send immediately, or ISO-8601 with an offset, for example "2026-06-11T09:00:00+00:00". Omit and Iridium picks a sensible time.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required), send_at, override_text.

approve_reply_draftBInspect

Approve Reply Draft

Approve a reply draft and schedule it into the existing thread. THIS SENDS. It adds no new connection and does not count against the daily connection limit, but it is a direct message: it counts toward the cap of 32 DMs a day, and a message can be up to 8,000 characters.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required), send_at, override_text.

backfill_chatsAInspect

Backfill Chats

Pull all existing LinkedIn conversations from Unipile into Iridium — every thread in one pass, not a page at a time. Run this once after connecting LinkedIn to populate your inbox; re-running is safe and repairs older rows in place.

Records each thread's kind (regular DM / inmail / sponsored / linkedin_offer), its subject line where it has one, and a real message preview. Re-run it once after an upgrade to repair rows that predate those fields. Takes 10-30 seconds depending on conversation count.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

cancel_jobAInspect

Cancel Job

Stop a background search that has not finished. What it already found stays readable with get_job. Nothing is sent or changed on LinkedIn; it only stops looking.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: job_id (required).

cancel_scheduledAInspect

Cancel Scheduled

Cancel a connection request (or message) that is SCHEDULED but has NOT been sent yet, so it never reaches LinkedIn. Use when the user says cancel / stop / don't send / take back for something still waiting in the queue (find it with list_scheduled). Synonyms: cancel invite, unschedule, pull back, stop sending, remove from queue. If it has already been sent, this changes nothing and says so: use withdraw_connection_request instead. If it is being sent at this moment it reports that; check list_scheduled shortly.

Args: handle: draft_ handle from list_scheduled or approve_draft.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required).

classify_inboxAInspect

Classify Inbox

Triage the inbox into buckets (default: recruiter_inbound, candidate_reply, cold_outreach_reply, spam) with a confidence per thread. Cache-first; repeat it to finish a large backlog (remaining).

Each thread is judged on its type (regular DM / inmail / sponsored / linkedin_offer), the sender's name and headline, the subject line if it has one, and the latest message. linkedin_offer threads are labelled spam with no model call (auto_labeled).

Args: taxonomy: optional custom list of labels to bucket into limit: max PROVIDER CALLS to spend this call, retries included (default 25). Keep it near 20 — the calls are sequential and a larger batch can outrun the client timeout. failed counts threads the model would not label.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: limit, taxonomy.

connect_linkedin_checkpoint_mcpAInspect

Connect Linkedin Checkpoint Mcp

Submit a LinkedIn 2FA verification code to complete the connection. Use this after connect_linkedin_credentials returns checkpoint=True.

Args: account_id: The account_id returned by connect_linkedin_credentials code: The verification code LinkedIn sent to your email or phone

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: code (required), account_id (required).

connect_linkedin_credentialsBInspect

Connect Linkedin Credentials

Connect LinkedIn via username and password. Creates a fresh Unipile-managed session. It does NOT touch your existing browser session, so your LinkedIn tab stays logged in.

If LinkedIn requires 2FA, returns checkpoint=True with an account_id. Follow up with connect_linkedin_checkpoint to complete the flow.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: password (required), username (required), country.

connect_linkedin_li_atBInspect

Connect Linkedin Li At

Connect LinkedIn by pasting your li_at session cookie. Lower friction than OAuth, with no redirect needed.

To get your li_at cookie:

  1. Log in to linkedin.com in Chrome

  2. Open DevTools → Application → Cookies → linkedin.com

  3. Copy the value of the 'li_at' cookie

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: li_at (required), country.

connect_linkedin_urlAInspect

Connect Linkedin Url

Get a Unipile hosted-auth URL to connect LinkedIn. The user opens this URL in their browser to complete the OAuth flow. No password or cookie is needed. Connection is confirmed automatically via webhook once the user completes the flow.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

create_sequenceAInspect

Create Sequence

CURRENTLY DISABLED. This tool returns 501 and creates nothing.

Multi-step sequences are switched off while the per-recipient safety checks are rebuilt. Do not call this. To do multi-step follow-up today, approve one message now and schedule the next with schedule_manual_dm or schedule_chat_reply at a later send_at.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: name (required), steps (required).

delete_accountAInspect

Delete Account

Delete your Iridium account. Deactivates your account immediately, destroys the LinkedIn session at Unipile, and cancels your subscription. All scheduled work stops at once. Your personal data (profiles, drafts, chats, settings) is retained for 30 days and then permanently erased; your action history is retained for audit.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

disconnect_linkedinAInspect

Disconnect Linkedin

Disconnect your LinkedIn account from Iridium. Removes the connection from Unipile and clears it from your profile. Everything that needs LinkedIn stops until it is reconnected.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

discover_prospectsAInspect

Discover Prospects

Search for people, read their profiles, and generate connection note drafts. Up to 3 people come back right here, in about 10 to 40 seconds. More than 3 run in the background: you get a job_id at once, drafts appear in list_drafts and get_job as each is written, and the user is emailed when it finishes or pauses. Returns draft handles ready to approve or skip. Complement to run_outreach_pipeline, which works from the user's saved targets.

CHOOSING BETWEEN discover_prospects AND find_person The deciding question: does the user NAME a specific person, or DESCRIBE a kind of person?

USE find_person when the user names someone (a first and last name), however much else they say about them:

  • "Message Jane Doe, she used to be at Acme."

  • "Is this the John Smith who was at Acme?"

  • "Find Pat Lee at Globex and connect." Returns who they are plus proof (e.g. Acme, 2018-2024). Cost: 1 search plus up to 2 profile reads. Drafts nothing. To write to them afterwards, pass the handle to schedule_dm_to_person.

USE discover_prospects when the user describes a GROUP by role, place or topic and wants connection notes written for whoever is found:

  • "Find 5 ML engineers in San Francisco and draft notes to them."

  • "Reach out to heads of growth in Austin." Searches by query and location, reads each person's profile AND posts, and drafts a note per person. Cost: 1 search plus 2 reads per person (about 11 actions for 5 people). Nothing sends; drafts land in list_drafts. Use it only when the user wants drafts.

NEITHER (use find_prospects or search_prospects) when the user wants a list to browse, or to check a badge such as #hiring, with no notes wanted.

NEVER use discover_prospects to look up a named person: it cannot filter by name or former employer, it returns strangers, and it spends about 11 actions doing so. NEVER use find_person to build a list: it returns at most 2 people.

AMBIGUOUS: "Find me Acme alumni named Jane." This could mean one specific Jane (find_person) or any number of Janes who used to work at Acme, with notes drafted (discover_prospects). A first name only, or a plural, is a group. DO NOT GUESS: the two cost very different amounts and discover_prospects drafts messages. Ask the user one question before calling either, for example: "Do you mean one specific person (give me their full name), or should I find several people matching this and draft notes to them?" Then call exactly one tool.

If the user gave a full name plus any context, choose find_person without asking. Ask only when the request could fit both.

Data accuracy: profile names, companies, and headlines are fetched live from LinkedIn and reflect real, current information. Notes reference actual post content when available; when no posts are found, notes are conservative and based only on verifiable headline/company data.

suggested_send_at is a suggestion only. Nothing sends until approve_draft is explicitly called. Drafts remain in pending_review indefinitely.

Each draft includes a profile field with: about, current_role, past_companies, education, certifications, skills, follower_count, recent_posts. Display this alongside the note so the user understands who was found.

Args: query: Search query e.g. "ML engineer at Series B startup" location: Location filter e.g. "San Francisco Bay Area" limit: Max prospects to process (1-10, default 5) hiring_only: the profile BADGE (is_hiring), not post text. This tool opens every candidate's full profile anyway, so the badge is genuinely CONFIRMED here rather than guessed — the filter is applied after that fetch and costs nothing extra. Use it for "find me hiring managers to connect with". Default false (no filter). For "who POSTED about hiring", use search_posts_by_topic: different question, different people, and free. open_to_work_only: same, for the is_open_to_work BADGE. If both this and hiring_only are true, a candidate matching either badge is kept.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: query (required), location (required), limit, hiring_only, +1 more.

draft_replyAInspect

Draft Reply

Generate a reply to a conversation, using the full thread + your voice, for review. Creates a pending reply draft, one per thread. Approve, rewrite, or skip it next.

Args: chat_handle: chat_ handle from list_chats / search_chats / list_replies intent: optional steer for the reply (a goal or tone)

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: chat_handle (required), intent.

edit_comment_draftBInspect

Edit Comment Draft

Replace a comment draft's text with text the user wrote. Saves only, does not post.

Use this when the user dictates their own wording. Approving is still a separate step.

Args: handle: cdft_ handle from list_comment_drafts. comment_text: the exact text to store on the draft.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required), updated_content.

enroll_prospectAInspect

Enroll Prospect

CURRENTLY DISABLED. This tool returns 501 and enrolls nobody.

See create_sequence. Schedule follow-ups explicitly instead.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: prospect_handle (required), sequence_handle (required).

find_personAInspect

Find Person

Find ONE specific person by name — optionally pinned by where they used to work — and get a definitive answer in a single call. The user never needs their LinkedIn id or URL.

CHOOSING BETWEEN discover_prospects AND find_person The deciding question: does the user NAME a specific person, or DESCRIBE a kind of person?

USE find_person when the user names someone (a first and last name), however much else they say about them:

  • "Message Jane Doe, she used to be at Acme."

  • "Is this the John Smith who was at Acme?"

  • "Find Pat Lee at Globex and connect." Returns who they are plus proof (e.g. Acme, 2018-2024). Cost: 1 search plus up to 2 profile reads. Drafts nothing. To write to them afterwards, pass the handle to schedule_dm_to_person.

USE discover_prospects when the user describes a GROUP by role, place or topic and wants connection notes written for whoever is found:

  • "Find 5 ML engineers in San Francisco and draft notes to them."

  • "Reach out to heads of growth in Austin." Searches by query and location, reads each person's profile AND posts, and drafts a note per person. Cost: 1 search plus 2 reads per person (about 11 actions for 5 people). Nothing sends; drafts land in list_drafts. Use it only when the user wants drafts.

NEITHER (use find_prospects or search_prospects) when the user wants a list to browse, or to check a badge such as #hiring, with no notes wanted.

NEVER use discover_prospects to look up a named person: it cannot filter by name or former employer, it returns strangers, and it spends about 11 actions doing so. NEVER use find_person to build a list: it returns at most 2 people.

AMBIGUOUS: "Find me Acme alumni named Jane." This could mean one specific Jane (find_person) or any number of Janes who used to work at Acme, with notes drafted (discover_prospects). A first name only, or a plural, is a group. DO NOT GUESS: the two cost very different amounts and discover_prospects drafts messages. Ask the user one question before calling either, for example: "Do you mean one specific person (give me their full name), or should I find several people matching this and draft notes to them?" Then call exactly one tool.

If the user gave a full name plus any context, choose find_person without asking. Ask only when the request could fit both.

LinkedIn applies the name and employer filters itself, so a match already satisfied them. The profile is then read (profile only, no posts; at most 2 matches; cached) to show WHEN: proof lists the matching job, e.g. Acme, Software Engineer, 2018-2024, status "past".

Read verdict: confirmed exactly one person matched every filter you gave. Use its handle. ambiguous two or more did. Compare headline and location, or add a filter (company, location, title) and call again. unverified NOBODY matched your filters; these people share only the name. Do not present them as the person asked for. none nobody by that name.

A match is a person who satisfies the filters, not proof they are the one the user means: check headline and location against what the user said.

Cost: 1 search, plus 1 profile read per match when evidence is on (free if cached). evidence=false skips the profile read: the match is still confirmed, with no dates. If the daily budget is spent the matches still come back, without proof, and budget_exhausted is set.

SEVERAL PEOPLE: send people (a list of the same fields, up to 50) instead of name. Up to 3 are answered right here as {"status": "done", "results": [...]}. More than 3 return a job_id at once, keep working in the background at a pace LinkedIn tolerates, and email the user when they pause or finish. Read them with get_job: results appear as they come in, and each confirmed person carries a handle you can use straight away.

Args: name: full name, e.g. "Jane Doe". The last word is the surname. (Or send people.) past_company: a company they USED to work at, e.g. "Acme". company: a company they work at NOW. location: where they are now, e.g. "San Francisco". title: words from their current title, e.g. "Chief Scientist". keywords: a soft hint (e.g. a former city). Narrows the search; proves nothing. evidence: read the profile to show dates (default true). include_history: also return their whole work history (default false).

Returns {"verdict", "matches", "more", "searches", "profiles_opened", "budget_exhausted", "note"}. Each match: handle, name, headline, location, distance, profile_url, and (when read) proof [{company, role, from, to, status}]. Pass handle straight to schedule_dm_to_person, get_linkedin_profile (for posts) or enroll_prospect.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: name, title, people, company, +5 more.

find_prospectsAInspect

Find Prospects

Find people on LinkedIn and, optionally, verify and write to a few of them — one tool that spends only what the filters you asked for actually cost.

USE THIS as the default for any "find me people who..." request. It searches once, narrows for free on the fields the search already returned, and opens full profiles only for the number you allow, best candidates first.

This is the tool that answers "who actually HAS the #hiring badge / the #opentowork badge". Set hiring or open_to_work and give it max_touches: it orders the bucket by the free signals most likely to carry the badge, opens that many profiles — the only place the badge exists — and tells you which candidates it CONFIRMED. Cost is 1 profile touch per candidate confirmed, except that a full Recruiter seat confirms "open to work" for free at search time. Read confirmed and each candidate's confirmed / badges to see who is verified; the rest of the bucket is unverified and the response says so.

Four phases, and you control where it stops: max_touches=0 (default) search + free narrowing only. No profile is opened, nothing is charged against the daily profile budget. This is a browse. max_touches=N additionally opens up to N full profiles (profile AND posts together, in one pass), best-first, to CONFIRM the badge filters. Already-known people are served from cache for free and never counted against N. want_notes=true additionally drafts a connection note for the confirmed candidates, reusing profiles already read — no extra LinkedIn reads, ever. Nothing sends; drafts land in list_drafts.

"#hiring" and "#opentowork" mean TWO DIFFERENT THINGS on LinkedIn, and which one the user means decides what the search costs:

BADGE the frame on someone's PROFILE (is_hiring / is_open_to_work). It is NOT in any people-search result and NOT in their posts. Seeing it means opening that person's profile — one profile touch each — with a single exception: a full Recruiter seat can filter "open to work" at search time for free. This tool's hiring and open_to_work flags mean the BADGE. POST TEXT the hashtag someone typed into a POST. Free to search, opens nobody's profile, and says nothing about their badge. That is search_posts_by_topic, not this tool — "who POSTED about hiring" is a different question from "who HAS the hiring badge", and they return different people.

Honesty contract, worth relaying to the user: checked is how many profiles this call actually opened, cached how many were reused free, confirmed how many really carry the badge, and count - checked - cached are candidates NOBODY has verified. When the daily budget is spent, the candidate list still comes back with budget_exhausted set — the tool never returns an empty list to mean "out of budget", and never silently stops early.

Args: query: what to search for, e.g. "ML engineer" or "Head of Growth". location: plain-text location, e.g. "San Francisco" or "United States". limit: bucket size to search for (1-100; classic LinkedIn plans return at most 10). company / headline_keywords / exclude_headline_keywords / network_distance: free filters applied to the search results themselves — they cost nothing, so use them freely to cut the list before spending touches. Any-of within a filter, all-of across filters. network_distance: DISTANCE_1 (direct connections), DISTANCE_2, DISTANCE_3. hiring: set this to find people who really have the #hiring profile BADGE (not post text). It is the only way to get that answer: no LinkedIn plan can filter on the badge at search time, so candidates are ORDERED by the free signals that correlate with it and then CONFIRMED by opening profiles — 1 touch per candidate confirmed, on every tier, capped by max_touches. The response marks each confirmed candidate and counts them in confirmed. With max_touches=0 nothing is confirmed and this flag only changes the order. For "who POSTED about hiring" use search_posts_by_topic instead: free, and a different question with different people. open_to_work: set this to find people who really have the #opentowork profile BADGE (not post text). On a full Recruiter seat LinkedIn confirms it at search time for free (its own spotlight, 0 touches, results arrive pre-filtered); on every other plan — Recruiter Lite included — it falls back to order-then-confirm at 1 touch per candidate confirmed, capped by max_touches. The tool picks whichever route this account can actually use, and the response says which candidates are confirmed either way. posted_recently: neither badge nor post text — an ACTIVITY filter ("posted at all in the past 30 days", regardless of what about). Free at search time, Sales Navigator seats only; on other plans the search runs without it and tier_note says so. max_touches: how many profiles this call may open BEFORE answering (0-10, default 0). You wait for these, up to 3. More than 3 runs in the background instead: you get a job_id at once, read the bucket and the confirmations as they arrive with get_job, and the user is emailed when it finishes. background_touches: how many of the best remaining candidates to confirm AFTER the answer is sent (0-10, default 0). You do NOT wait for these and they are NOT confirmed in this response — background.queued says how many are running. Ask again in a moment and they come back already confirmed, at no extra cost, because they land in the same cache. Use this to keep a long list moving without making the user wait: "here are 25 people, the best 8 are being confirmed now". want_notes: draft a connection note per confirmed candidate. Default false.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: query (required), location (required), limit, hiring, +9 more.

find_stale_threadsAInspect

Find Stale Threads

Surface dropped balls, meaning threads with no activity in days: ghosted → you sent the last message and got no reply owed_reply → they replied and you haven't responded Threads with a pending scheduled reply are excluded. Oldest first, except threads whose contact shows a cached #hiring or #OpenToWork profile BADGE sort ahead of ones that don't.

hiring_signal: true when this contact's cached LinkedIn profile shows the #hiring or #OpenToWork profile BADGE (not post text) — best-effort, from a prior profile fetch, never a new one. False means either confirmed absent or never checked; treat it as "nothing to report," not a confirmed negative.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: days, limit.

get_activity_logAInspect

Get Activity Log

Read the user's activity log. Every action Iridium has taken, newest first.

Iridium records every attempted action in an append-only ledger: what ran, when, whether it succeeded, and the text that was actually sent. This tool reads it. Nothing is sent or changed by calling it.

USE THIS when the user asks what happened, in any form: "what did you do today?" "did that comment actually post?" "show me everything from yesterday" "what failed?"

Answer from this log rather than from memory of earlier turns in the conversation. The log is the record; the conversation is not.

Each entry has: at, action (readable label), surface, status, target (who or what it touched), summary (one sentence), detail (the text that was sent), and error when it failed. Entries older than the user's data-retention window may have no target name, because the profile behind it has been erased. That is expected and is not a failure.

Args: limit: Entries per page, 1-100 (default 20). cursor: next_cursor from a previous call, to fetch the following page. surface: "linkedin" for actions taken on LinkedIn, "iridium" for actions inside Iridium such as sign-ins and draft decisions. Omit for both. status: "success", "failed", or "skipped". Omit for all. action_type: exact slug filter, e.g. "comment_send". Omit for all.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: limit, cursor, status, surface, +1 more.

get_draft_detailAInspect

Get Draft Detail

Everything Iridium knows about one connection-note draft: the full note text, the angle it was written from, and the profile it is addressed to. Read-only.

Use this when the user asks why a draft says what it says, or wants the full text that list_drafts only previews.

Args: handle: draft_ handle from list_drafts.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required).

get_jobAInspect

Get Job

Check on a search that is running in the background, and read what it has found so far.

Large searches (more than 3 people to look up, or a list to read and draft notes for) do not make you wait. They return a job_id straight away, keep working, and email the user when they pause or finish. Results appear here as they come in, so you can already message people, read their profiles or draft notes while the rest is still going.

Call with a job_id to get its status, how many are done, and every result so far (people carry a handle you can pass to the other tools). Call with no job_id to list the latest jobs.

status: queued (starting), running, waiting (paused to stay within LinkedIn's limits; it resumes by itself at resume_at and the user is emailed), done, stopped (LinkedIn kept slowing the account down; wait a day), cancelled, failed. Read message: it says it in plain words and is safe to relay to the user as written.

Args: job_id: the job to read. Omit to list the latest 10. limit: most results to return (1-200, default 50).

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: limit, job_id.

get_last_actionAInspect

Get Last Action

Read back the single most recent action Iridium took, with its full text.

Use this to confirm something just happened, after approving or scheduling anything, or when the user asks "did that work?". Cheaper than get_activity_log when only the last action matters. Nothing is sent or changed by calling it.

Returns {"item": null} if the account has no recorded actions yet.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

get_linkedin_profileAInspect

Get Linkedin Profile

Read the full LinkedIn profile(s) of people you already know, or several at once.

ONE PERSON, THREE TOOLS - use them in this order:

  1. find_person WHO is this? A name (plus where they worked) returns a confirmed handle and proof. 1 search plus up to 2 profile reads.

  2. get_linkedin_profile TELL ME MORE. A handle returns the full profile and posts. Call it only when find_person's headline and proof are not enough.

  3. schedule_dm_to_person MESSAGE THEM. Pass the profile_handle from step 1. Never message from a name alone: sending by name guesses between people who share it. If find_person's verdict is not confirmed, ask the user which person they mean before sending. Already in a conversation with them (see search_chats)? Use the chat_ handle with schedule_manual_dm instead; no lookup is needed.

At least one of name, linkedin_id, iridium_handle, linkedin_ids, or iridium_handles must be provided. Prefer iridium_handle(s). name (with the optional hints company, education, location, headline_keywords) is a keyword search that opens up to 5 full profiles: to find ONE named person use find_person instead.

Costs one profile touch per person against the daily budget — this is the expensive way to look someone up, and the right one when you already hold a handle and want depth. To resolve a name, use find_person. To find people you cannot yet name, use find_prospects.

More than 3 handles run in the background (up to 50): you get a job_id at once, read the profiles as they arrive with get_job, and the user is emailed when it finishes.

Returns {"results": [...], "total": N, "query_used": str | None}. Results are fully read: about, current_role, past_companies, education, certifications, skills, recent_posts, prof_handle, and the two profile BADGES as is_hiring / is_open_to_work. Opening the profile is the only thing that reveals those badges, and this call already opened it, so they cost nothing extra here — this is the cheapest confirmation available for a person you can already name. (find_prospects with max_touches does the same for people you cannot yet name, one touch each.)

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: name, company, location, education, +5 more.

get_threadAInspect

Get Thread

Read a full LinkedIn conversation with one person, local-first, using no Unipile quota once synced. Returns the most recent messages oldest-first; pass before (the returned next_cursor) to scroll up into older history.

Args: chat_handle: chat_ handle from list_chats / search_chats before: next_cursor from a prior call, to load older messages limit: messages per page (default 10, max 50)

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: chat_handle (required), limit, before.

get_user_profileAInspect

Get User Profile

The user's Iridium account state: their saved targeting and voice settings, daily limits and how much of each is used today, counts of pending drafts and queued sends, unread replies, and whether LinkedIn is connected. Read-only.

Check this before any bulk action to see what capacity is left, and before asking the user to supply a setting — it may already be set. The setting fields are named exactly as update_settings takes them, so anything read here can be written straight back.

daily_dm_cap and dms_sent_today count every direct message today, new chats and replies into existing ones alike. Past the cap a new send is refused (429) and a queued one waits until the next day.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

list_chatsAInspect

List Chats

The user's LinkedIn conversations, most recent first. Reads from Iridium's synced copy, so it uses no LinkedIn quota.

Returns chat_ handles for get_thread, summarize_thread, draft_reply, and schedule_manual_dm. If the inbox looks empty on a new account, run backfill_chats once.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

list_comment_draftsAInspect

List Comment Drafts

List pending comment drafts awaiting review.

ALWAYS display every draft to the user in full:

Post by [author_name]: [post_text, the complete text, never truncated]

Drafted comment: [comment_text, displayed in full]

Do NOT call approve_comment_draft or schedule anything unless the user explicitly asks.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

list_connection_requestsAInspect

List Connection Requests

List the connection requests the user has RECEIVED and not yet answered: the people who want to connect with them. Use when the user wants to see, count, review or triage who is waiting to connect, e.g. "how many connection requests do I have", "who wants to connect with me", "check my invites", "go through my pending invitations", including a big backlog like 99+.

Synonyms the user may use: connection requests, connect requests, invitations, invites, LinkedIn invites, pending requests, pending invitations, inbound requests, incoming connections, network invitations, My Network invites, people who want to connect, requests to connect.

If the user mentions connection requests but it's unclear they want to work through them now, ask first: "Do you want to work with your connection requests right now?" Calling this can start a background review and an email, so don't call it speculatively.

Each request has the person's name and headline, the note they attached (often empty), any message they have already sent in the inbox (message, e.g. a recruiter's InMail), and an accept / maybe / decline suggestion with a confidence. Read-only: it makes no LinkedIn call and answers nothing. If the list is stale or not yet labelled (reviewing true) it starts a background review, and the user gets an email when it finishes, so tell them that and don't wait.

Do NOT use to send connection requests (outreach tools), to read or send messages (list_chats / get_thread), or when the user hasn't asked about received connection requests.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

list_content_draftsAInspect

List Content Drafts

The user's own LinkedIn post drafts, waiting for review. Nothing here has been published.

These are posts the user would publish under their own name, distinct from comment drafts (which go on other people's posts) and outreach drafts (which are connection notes). Show each draft in full and let the user decide. Publishing is a separate step.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

list_draftsAInspect

List Drafts

Connection-note drafts waiting for review. Nothing here has been sent.

Each entry has a draft_ handle, who it is addressed to, a preview of the note, and the time Iridium suggests sending it. Show the notes to the user and let them decide. Approving is a separate step: call approve_draft only when the user explicitly asks.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

list_repliesAInspect

List Replies

Inbound threads awaiting a reply (they messaged last, not yet actioned). Returns chat handles ready for draft_reply / get_thread / schedule_chat_reply.

hiring_signal: true when this sender's cached LinkedIn profile shows the #hiring or #OpenToWork profile BADGE (not post text) — best-effort, from a prior profile fetch, never a new one. False means either confirmed absent or never checked; treat it as "nothing to report," not a confirmed negative.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

list_reply_draftsBInspect

List Reply Drafts

Pending inbound-reply drafts awaiting your review.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

list_scheduledAInspect

List Scheduled

Everything approved and queued to send, with the time each one goes out.

These have been approved and WILL send unless cancelled. Use reschedule_send to move one and cancel_scheduled to stop it.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

list_sent_connection_requestsAInspect

List Sent Connection Requests

List the user's SENT connection requests that are still pending, meaning awaiting acceptance, whatever their age and whether or not Iridium sent them. LinkedIn only keeps pending requests: accepted ones become connections, and declined, expired or withdrawn ones are gone. Use for "show/list my sent requests", "who hasn't accepted", "how many pending", "oldest pending", "clean up old invites". If the user asks for ALL requests Iridium sent, including accepted and failed ones, also read get_activity_log and say that acceptance isn't recorded there.

Synonyms the user may use: sent connection requests, sent invitations, pending invitations I sent, outgoing requests, invites awaiting acceptance, unanswered requests, requests nobody accepted, my outbound invites.

Read live from LinkedIn (a few times a day at most; it is budgeted). Each item has name, headline, sent_at, days_waiting, the note sent, and a handle when Iridium sent it: only those can be withdrawn with withdraw_connection_request. Requests sent by hand on LinkedIn are listed without a handle. total is how many were read; complete: false means there are more than 500 pending, so the oldest may be missing. Use order=oldest to find the stalest.

Do NOT use for requests the user RECEIVED (list_connection_requests) or ones still queued to send (list_scheduled).

Args: limit: how many to return (default 100) order: newest or oldest first

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: limit, order.

list_solved_issuesAInspect

List Solved Issues

Known problems the Iridium team has already fixed, newest first.

Returns a list of {title, resolution, solved_at}. Read-only — nothing is sent or changed.

USE THIS before report_issue, to check whether the thing you just hit is already solved, and when a user asks whether a problem they remember has been fixed.

DO NOT USE as general help or documentation: this is only the list of past breakages, not a description of what Iridium can do. Call list_tools for that.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

list_toolsAInspect

List Tools

The Iridium tools available to this account, filtered by what the user has enabled.

Useful for answering "what can you do?" without guessing. A tool absent from this list is switched off for this account, so do not offer it.

Returns capabilities, the handful of jobs Iridium does, and tools, the flat list behind them. Lead with the capabilities when answering the user. Read tools when picking the call.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

report_issueAInspect

Report Issue

Send the Iridium team an anonymous note about something that broke while you were working.

Returns {"received": true}. Nothing is sent to LinkedIn and nothing about the account is changed. This is NOT a support ticket: the report carries nothing that identifies the user, nobody will reply, and there is no way to follow it up. It exists so the team can see which workflows break most and which ones users cannot work without.

USE THIS when an Iridium tool failed, returned something wrong, or made a workflow the user cares about impossible to finish — especially if you have hit it more than once.

DO NOT USE when the user just needs to be told something (a cap was reached, LinkedIn is disconnected, a draft was skipped) — tell them, that is not a break. Do not use it to ask a question, request a feature, or chase a previous report. Call list_solved_issues first; if the problem is already fixed there, tell the user instead of reporting it again.

Args: what_broke: One line on what failed. Max 200 characters. how_it_happened: One line on the steps that led to it. Max 200 characters. frequency: One of first_time, sometimes, every_time. importance: One of nice_to_have, important, blocking — how much the user needs this workflow to work.

NEVER include personal or identifying information in either text field: no names, company names, job titles, message or post text, email addresses, phone numbers, URLs, @handles, or Iridium handles (draft_, chat_, prof_). Describe the shape of the failure, not the data it happened to. "Approving a connection note fails when the note ends in a question mark" is a report; anything naming a person is not. Text containing an identifier is rejected with 422 — restate it without one rather than working around the check.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: frequency (required), importance (required), what_broke (required), how_it_happened (required).

reschedule_sendAInspect

Reschedule Send

Move a pending send to a different time. It has already been approved, so it will send.

Args: handle: draft_ handle from list_scheduled or approve_draft send_at: "now" to send immediately, else ISO-8601 e.g. "2026-06-11T09:00:00+00:00"

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required), send_at (required).

respond_connection_requestAInspect

Respond Connection Request

Respond to ONE received connection request: accept it or decline it. Do not run this without first listing the connection requests to the user (list_connection_requests). Use only after the user has decided specifically what to do, and has named who clearly: a person ("accept Brenda") or a clearly defined group ("decline all the recruiters", "accept everyone from Gitforce"). Never respond on your own initiative, and never just because a request is labelled accept or decline.

For a group, work it out yourself from the list (name, headline, note, message), then call this once per person, one at a time, until you have covered them all. If any request doesn't clearly fit what the user described, skip that one, finish the rest, then ask the user about the skipped ones. If the user asks about something specific, call list_connection_requests once first, then confirm with them which people and which action, so both you and the user know the right operation was requested.

Takes one handle (from list_connection_requests) and action: accept or decline. Synonyms the user may use: accept / approve / add / connect with; decline / reject / ignore / dismiss / turn down; applied to connection requests, invites or invitations. "Ignore" means decline (there is no separate ignore action).

Not instant: each request is queued and answered in the background, spaced out and under a daily limit, to protect the LinkedIn account. After the last one, tell the user once that they'll get an email when it's done. It cannot be undone.

Do NOT use to send or withdraw your own connection requests, or to reply to messages.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

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

rewrite_comment_draftAInspect

Rewrite Comment Draft

Rewrite a comment draft with an instruction. Does not post.

The rewrite runs in the background, so call list_comment_drafts afterwards to read the new text.

Args: handle: cdft_ handle from list_comment_drafts. instruction: what to change, for example "shorter", "ask a question at the end", "drop the praise". Omit for a general retry.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required), instruction.

rewrite_content_draftAInspect

Rewrite Content Draft

Rewrite a post draft with an instruction. Does not publish.

The rewrite runs in the background, so call list_content_drafts afterwards to read the new text.

Args: handle: ctnt_ handle from list_content_drafts. instruction: what to change, for example "punchier hook", "cut it in half", "end on a question".

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required), instruction.

rewrite_draftAInspect

Rewrite Draft

Rewrite a connection-note draft with an instruction. Does not send.

The rewrite runs in the background, so the new text is not in the response. Call get_draft_detail or list_drafts afterwards to read the result.

Args: handle: draft_ handle from list_drafts. instruction: what to change, for example "shorter", "lead with the mutual connection", "drop the compliment".

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required), instruction (required).

rewrite_reply_draftBInspect

Rewrite Reply Draft

Rewrite a reply draft with an instruction, for example 'shorter' or 'propose Tuesday'. Does not send.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required), instruction (required).

run_commenting_pipelineAInspect

Run Commenting Pipeline

Generate up to 3 LinkedIn comment drafts on relevant posts, found by searching all of LinkedIn for the user's saved comment_topics.

USE THIS when the user wants to comment by TOPIC, or names no target in particular: "find me some posts to comment on" "comment on posts about RAG" "who's worth engaging with this week?"

DO NOT USE when the user names specific companies ("comment on posts from people at Stripe"). Use run_company_commenting_pipeline instead.

After calling this tool, ALWAYS display every draft to the user in full:

Post by [author_name]: [post_text, the complete text, never truncated]

Drafted comment: [comment_text, displayed in full]

Do NOT call approve_comment_draft or schedule anything unless the user explicitly asks.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

run_company_commenting_pipelineAInspect

Run Company Commenting Pipeline

Generate LinkedIn comment drafts on recent posts by people who work at specific companies.

USE THIS when the user names one or more companies: "comment on posts from people at Stripe" "I want to be visible to Anthropic and OpenAI engineers" "engage with anything Ramp employees posted this week"

DO NOT USE for topic- or keyword-based commenting ("find me AI posts to comment on", "comment on posts about RAG"). Use run_commenting_pipeline instead, which searches the whole of LinkedIn by the user's saved comment_topics.

How it differs: this tool searches by AUTHOR COMPANY and recency only, with no keyword filter, because ANDing a keyword against a single employer usually returns nothing. Topical relevance is then judged by the model over whatever those employees actually posted. As a result it may legitimately return zero drafts if nobody at those companies posted anything worth engaging with; that is a valid outcome, not an error, and you should say so plainly rather than retrying.

Takes up to 5 companies per call. Companies with no matching LinkedIn page come back in unresolved_companies, so tell the user which ones failed.

After calling this tool, ALWAYS display every draft to the user in full:

Post by [author_name] ([company]): [post_text, the complete text, never truncated]

Drafted comment: [comment_text, displayed in full]

Do NOT call approve_comment_draft or schedule anything unless the user explicitly asks.

Args: companies: Company names, e.g. ["Stripe", "Ramp"]. Max 5. n: How many drafts to generate (default 3, capped by the user's remaining daily cap). date_posted: "past_24h" | "past_week" | "past_month". Default "past_week".

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: companies (required), n, date_posted.

run_content_pipelineAInspect

Run Content Pipeline

Draft LinkedIn posts for the user to publish, from their saved content topics and voice. Produces drafts only and publishes nothing.

Runs in the background and returns immediately. Call list_content_drafts to read the results. Requires content topics to be set, otherwise it returns an error saying so. Runs at most once a day, and returns status "skipped" with reason "already ran today" on a second call.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

run_outreach_pipelineAInspect

Run Outreach Pipeline

Draft 3 connection notes against the user's saved targets and return them inline in about 5 seconds. Produces drafts only and sends nothing.

After calling this tool, ALWAYS display every draft to the user in full:

[Name], [Headline] at [Company] [note_text, displayed in full] Suggested send: [suggested_send_at]

Do NOT call approve_draft or schedule anything unless the user explicitly asks.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: no named parameters.

schedule_chat_replyAInspect

Schedule Chat Reply

Send or schedule a message into an existing conversation. THIS SENDS.

It goes into a thread that already exists, so it creates no new connection and does not count against the daily connection limit, but it is a direct message and counts toward the daily DM cap. A message can be up to 8,000 characters. DMs are capped at 32 a day, new chats and replies together; past that, scheduling is refused (429) or a queued send waits until the next day. Call it only when the user has approved this specific message.

Args: chat_handle: chat_ handle from list_chats or search_chats. text: the exact message to send. send_at: "now" to send immediately, or ISO-8601 with an offset. Omit for immediate.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: text (required), chat_handle (required), send_at.

schedule_dm_to_personAInspect

Schedule Dm To Person

Send or schedule a direct message to a person you have already found. THIS SENDS.

ONE PERSON, THREE TOOLS - use them in this order:

  1. find_person WHO is this? A name (plus where they worked) returns a confirmed handle and proof. 1 search plus up to 2 profile reads.

  2. get_linkedin_profile TELL ME MORE. A handle returns the full profile and posts. Call it only when find_person's headline and proof are not enough.

  3. schedule_dm_to_person MESSAGE THEM. Pass the profile_handle from step 1. This tool takes a profile_handle, never a name: a name guesses between people who share it. If find_person's verdict is not confirmed, ask the user which person they mean first. Already in a conversation with them (see search_chats)? Use the chat_ handle with schedule_manual_dm instead; no lookup is needed.

If you already have a thread with this person the message goes into it. Otherwise it is a direct message to a connection, or a connection request with the text as its note. Several messages scheduled at once are spaced out so LinkedIn never sees a burst; the reply says so when a message is moved. A message can be up to 8,000 characters. DMs are capped at 32 a day, new chats and replies together; past that, scheduling is refused (429) or a queued send waits until the next day. A connection-request note is limited to 300 characters and an InMail to 1,900.

Args: profile_handle: prof_ handle from find_person or get_linkedin_profile (required). text: the exact message to send. send_at: "now" to send immediately, or ISO-8601 with an offset. name: optional; shown in the queue. Read from the profile when omitted. message_type: optional override: connection_request, direct_message or inmail.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: text (required), name, send_at, message_type, +1 more.

schedule_manual_dmAInspect

Schedule Manual Dm

Schedule a direct message to someone you're already connected with. Use list_chats to find the chat_handle for a conversation. A message can be up to 8,000 characters. DMs are capped at 32 a day, new chats and replies together; past that, scheduling is refused (429) or a queued send waits until the next day.

Args: chat_handle: chat_ handle from list_chats or list_replies text: Message text to send send_at: "now" to send immediately, else ISO-8601 e.g. "2026-06-11T09:00:00+00:00" message_type: "direct_message" (default) or "inmail"

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: text (required), chat_handle (required), send_at, message_type.

search_chatsAInspect

Search Chats

Search your LinkedIn inbox by message content and by structured filters, all local (no LinkedIn quota). Free text matches participant names and message bodies (e.g. "who mentioned CMU"). Operators can be passed in q or as discrete args: is:unread/read · from: · company: · after:/before: · newer:d · older:d Returns chat handles ready for get_thread / schedule_chat_reply.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: q, name, after, limit, +6 more.

search_posts_by_topicAInspect

Search Posts By Topic

Search LinkedIn posts by topic and return each post with its author as a candidate. Reads only, drafts nothing, and opens no profiles: the post itself is the evidence and the author comes back inline, so the cost is the same whether it returns 1 post or 50.

USE THIS when the person is defined by what they posted: "who is posting about X", "engineering managers at Nvidia who posted about hiring this month", "people in my network talking about Y". One call answers the whole question — do not search people and then read each one's posts.

DO NOT USE for a people search with no topic (search_prospects / find_prospects), or when the user wants messages written (discover_prospects). In particular, this tool answers "who POSTED about hiring" — NOT "who HAS the #hiring badge on their profile", which is find_prospects' hiring flag and costs a profile touch per person confirmed. The two return different people.

Args: keywords: POST TEXT — words the post body must contain, e.g. "hiring", "open roles", "RAG evals". "#hiring" here matches the hashtag someone TYPED IN A POST; it is not the profile badge and implies nothing about it. Free: one post search, no profile opened. (The badge is find_prospects' hiring, and costs a touch per person.) author_company: Company the author currently works at, by name, e.g. "Nvidia". author_keywords: Text in the author's headline or title, e.g. "engineering manager". date_posted: past_day | past_week | past_month (default past_month). Newest first. posted_by: first_connections or people_you_follow to stay inside the user's network. limit: Max posts to return (1-50, default 10). Reposts are dropped.

Returns {"posts": [...], "count": N, "has_more": bool}. Each post: text, date, post_url, reaction_count, comment_count, and author {name, headline, is_company, handle}. The handle is a prof_ handle (null for company pages) — pass it to get_linkedin_profile for the full profile, or straight to schedule_dm_to_person / enroll_prospect.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: keywords (required), limit, posted_by, date_posted, +2 more.

search_prospectsAInspect

Search Prospects

The cheapest people search there is: ONE LinkedIn action, no profile opened, no badge checked. Reads only, drafts nothing.

It is not specific to any signal. It returns whoever matches the query and location — that is all it knows. hiring_only / open_to_work_only do NOT filter and do NOT confirm anything: they only REORDER the same results using hints in the headline and title text, which is a guess, not the badge. Someone with the real #hiring badge and a plain headline sorts last; someone who typed "hiring" in their headline and has no badge sorts first.

USE THIS to browse cheaply, or to get a long list to narrow by hand.

DO NOT USE when the answer has to be TRUE about a badge — "people who are actually hiring", "who is really open to work". This tool cannot know: the badge lives only on the full profile. Use find_prospects, which opens profiles and tells you which candidates it confirmed.

DO NOT USE when the user wants messages written. discover_prospects searches and drafts a connection note for each person in one call.

Results are read live from LinkedIn at the time of the call.

Args: hiring_only / open_to_work_only: the profile BADGE (is_hiring / is_open_to_work), not post text. The badge is never in a people-search result — it lives only on the full profile (SEARCH.md §7.1/§7.4) — so these do NOT filter; an earlier version faked the filter out of headline text and returned a near-empty list for almost every real query. Instead they SORT by how likely each result is to carry the badge, from free signals already in the search result (headline phrasing, an empty current work history). Nothing is ever dropped — see note in the response. This tool opens no profiles, so it never confirms a badge: cost 0 touches, certainty 0. To confirm, use find_prospects with max_touches (1 touch each). posted_recently: neither badge nor post text — an ACTIVITY filter ("posted at all in the past 30 days", regardless of what about). Free at search time, needs a Sales Navigator seat; on any other plan the search runs without it and tier_note says so. Default false. open_to_work: the profile BADGE, confirmed for free at search time by LinkedIn's own "Open to work" spotlight — applied before results come back, so 0 profile reads. Needs a full Recruiter seat (Recruiter Lite has no such spotlight); on any other plan the search runs without it and tier_note says so. Default false. Note this is the same badge as open_to_work_only above; the difference is that this one is CONFIRMED by LinkedIn and free, while that one is only a guess at the ordering.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: query (required), location (required), limit, hiring_only, +3 more.

skip_comment_draftBInspect

Skip Comment Draft

Discard a comment draft without posting it. Nothing reaches LinkedIn.

Args: handle: cdft_ handle from list_comment_drafts.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required).

skip_content_draftAInspect

Skip Content Draft

Discard a post draft without publishing it. Nothing reaches LinkedIn.

Args: handle: ctnt_ handle from list_content_drafts.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required).

skip_draftAInspect

Skip Draft

Discard a connection-note draft without sending it. Nothing goes to LinkedIn.

Args: handle: draft_ handle from list_drafts.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required).

skip_reply_draftCInspect

Skip Reply Draft

Discard a reply draft without sending.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required).

summarize_threadAInspect

Summarize Thread

Structured summary of one conversation so you don't re-read it: participants, company, the core ask, current state, and the suggested next step. Cached until a new message arrives (pass force=true to recompute).

Args: chat_handle: chat_ handle from list_chats / search_chats force: recompute even if a fresh cached summary exists

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: chat_handle (required), force.

update_settingsAInspect

Update Settings

Change the user's profile, targeting and limits. Persists immediately, sends nothing.

Every field is optional and only the ones passed are changed; each field's own description says what it does. Pipelines read these settings, so this is how "only comment on AI posts" or "cap me at 5 a day" gets applied.

This is also how you clear a blocked pipeline. When a run fails for a missing setting, the error names the field: ask the user for it in plain language, send it here, then retry the run. Never invent a value the user did not give you.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: voice_dna, current_role, target_cities, comment_topics, +19 more.

withdraw_connection_requestAInspect

Withdraw Connection Request

Withdraw a connection request that HAS ALREADY BEEN SENT and is still pending, because the person hasn't accepted. Use only when the user explicitly asks to withdraw / retract / take back / unsend an invite that went out. For requests still waiting in the queue use cancel_scheduled. Find the request with list_sent_connection_requests first, and confirm the person with the user. Tell them: LinkedIn blocks re-inviting the same person for up to three weeks after a withdrawal. One person at a time. Limited per day. It cannot be undone.

Args: handle: draft_ handle from list_sent_connection_requests.

Responses:

200: Successful Response (Success Response) Content-Type: application/json

Inputs: handle (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      B
      maintenance
      Connects AI assistants like Claude to LinkedIn through your own logged-in browser session, enabling profile and company lookups, messaging, inbox management, job searches, and related actions. All browser interactions run locally on your machine.
      47
      Apache 2.0
    • A
      license
      A
      quality
      B
      maintenance
      AI agent for LinkedIn outreach: finds the right people, writes in your voice, follows up, replies. Six campaign goals: sell a product or service, find a job, hire people, find partners or investors, find a vendor, research interviews. Campaigns stay drafts until you launch them.
      22
      13
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      An MCP server that lets AI assistants like Claude read LinkedIn data through your own logged-in browser session. Access profiles and companies, search for jobs, or get job details.
      17
      Apache 2.0
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources