Iridium: LinkedIn MCP Server
Server Details
LinkedIn MCP for Claude, ChatGPT, Grok, Hermes: triage inbox, comment, find people, live profiles
- 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
Scored across 64 tools
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.
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.
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.
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 toolsapprove_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:
Log in to linkedin.com in Chrome
Open DevTools → Application → Cookies → linkedin.com
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:
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.
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.
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:
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.
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.
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
LinkedIn outreach from Claude: invites under safe caps, follow-ups, replies and inbox triage.
LinkedIn actions for AI agents: search, messaging, posts and invites, as hosted MCP tools.
LinkedIn outreach in Claude or ChatGPT: campaign stats, replies, leads, drafts. Never sends.
The safest LinkedIn MCP: your Agents read DMs, search your network and draft messages you send.
Related MCP Servers
- AlicenseBqualityBmaintenanceConnects 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.47Apache 2.0
- AlicenseNot gradedqualityDmaintenanceEnables Claude AI to interact with LinkedIn through browser automation, including profile reading, people and job search, company research, post publishing, and profile editing.MIT
- AlicenseAqualityBmaintenanceAI 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.2213MIT
- AlicenseAqualityDmaintenanceAn 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.17Apache 2.0
Glama MCP Gateway
Add one secure layer between your agents and this server.