gtm-api: LinkedIn MCP Server

Probe one contact's current connection degree (1st / 2nd / 3rd / 4_plus) from a managed account, and actualize a stale stored row: a live connection whose degree is no longer 1st is soft-deleted (removal_kind=removed) in the same call. Reuses the get-lite-profile getter (owner-only: it runs on the account you name). Supply exactly one target identifier.

Ask what a LinkedIn connection request came to, without sending: by the client_reference it went out under (optionally for one person: profile_id or ln_member_id), or by the activity_log_sid a 409 named. result.outcome: sent (item is the request, or null with reason request_row_pending or caller_confirmed), in_flight, unknown (the answer was lost and the sent invitations have not shown it yet; retry_after, send_decisive_at), or not_sent (no_send_under_key, refused, not_in_invitations, caller_confirmed). Send the same request again only on not_sent, under the same key. result.activity_log_sid i…

Ask what a LinkedIn message send came to, without sending: by the client_reference it went out under (optionally at one place: linkedin_conversation_sid, ln_member_id or profile_urn), or by the activity_log_sid a 409 named. result.outcome: sent (item is the message, or null with reason message_row_pending or caller_confirmed), in_flight, unknown (the thread has not shown it yet; retry_after, send_decisive_at), or not_sent (no_send_under_key, refused, not_in_thread, caller_confirmed). Send the same request again only on not_sent, under the same key. result.activity_log_sid is the attempt a pers…

Ask what a LinkedIn comment, post or repost came to, without sending: by the client_reference it went out under and its verb (comment, create-post, repost), optionally at one place (entity_urn: the post a comment or a repost went to, in any of its forms, or the comment a reply answers; parent_comment_urn for a reply; post_place for a post), or by the activity_log_sid a 409 named. result.outcome: sent (item is what it made, or null with reason result_pending or caller_confirmed), in_flight, unknown (LinkedIn has not shown it yet; retry_after, send_decisive_at), or not_sent (no_send_under_key, r…

Lend ONE of your connected accounts to another workspace, temporarily and revocably. This is a loan, not a handover: permanent ownership transfer has no MCP tool at all. Target exactly one of to_email (resolved to that user's working team) or to_team_sid; neither, both, a bad email or a self-target is 422. account_sid is prefix agnostic (ln_ac_, em_ac_); `channel` says which service owns it. ALWAYS ASYNC: returns 201 with status pending, and the loan has NOT started. Poll search_account_shares with filter { sid: { eq } } until status is active (the holder can work) or failed (read failure_reas…

Provision ONE antidetect browser for the team. The main flow mints a fresh vendor (GoLogin) profile and pushes the resolved proxy into it, so supply exactly one proxy source: proxy_country_code is the default, custom_proxy_config routes that minted profile through a proxy the caller supplies (probed first, 422 custom_proxy_unreachable_* when dead, never with proxy_5g). Pick the branch yourself, never ask an end user for a sid. Bind an existing vendor_profile_id for the BYO-PROFILE path instead, with no proxy source: that profile carries its own. If no LinkedIn account signs in on it for 30 day…

Issue a new API key and return the full secret in the create envelope's plaintext_token EXACTLY ONCE. It is unrecoverable, so hand it to the user immediately and never log or echo it; if lost, rotate. BOTH grant axes are clamped to the ISSUER's own current authority (403, reason grant_exceeds_ceiling): permissions must sit inside the caller's token set ('*' only for an unrestricted issuer; on delegation, inside the parent key's set), and account_sids inside the caller's account slice - a sliced caller cannot pass null ("all accounts") and must send an explicit list within their slice. Verify r…

Start a self-serve purchase of a subscription. DANGEROUS (charges money): it pre-creates a billed Paddle transaction and returns a hosted checkout_url the buyer pays in the Paddle overlay (server-side preview→commit gate applies). Resolves the bracket price for the requested slot count, optionally applies to team_sid on activation (omit to buy floating), and can bundle add-ons in the same checkout. The real subscription row is born on the billing-subscriptions.activated webhook; poll get/search afterwards. Requires billing.manage.

Save a scraping source as a collector and start it. Give the source EXACTLY one way: a bare url (people and company searches only) or the pair source_method plus source_input. Anything else is 422. Use for the standing ask, "keep pulling everyone behind this link". To wire outreach, author the plan FIRST on the mass-actions mount (preview_mass_action, then create_mass_action with scope kind none) and pass its ma_ac_ sid here: every new lead is appended to that run as one item. Omit mass_action_sid to collect only, omit replay_frequency for a one-shot. Run 1 dispatches AT ONCE: real LinkedIn …

Description is built at runtime.

Description is built at runtime.

Commit a previewed plan into a running bulk dispatch. Requires the commit_token from preview_mass_action over EXACTLY these inputs: the server re-derives the HMAC, so an edited plan, a changed scope or a different caller is 422 invalid_commit_token, and a token older than 15 minutes is 422 commit_token_expired. Re-preview in either case. Re-runs the preview validation, inserts the run and its items and starts dispatching. Always asynchronous: the returned sid is the monitoring handle (get_mass_action with include=metrics, get_mass_actions_metrics, or the mass-actions.settled / .paused webhook…

Register a new OAuth application; the server generates client_id. v1 clients are public/PKCE (no secret). A confidential client (fast-follow) returns client_secret in the create envelope ONCE. Tell the user to store it; it is unrecoverable and must never be logged. permissions is the ceiling the client may request; redirect_uris is an exact-match https allow-list (closes open-redirect). Dedup (team_sid, name) → already_exists. Set platform:true (admin only) to register a platform client with no owning team.

Register a custom domain as a certificate row in status='pending'. Does NOT start ACME; call issue_ssl_certificate next to begin the HTTP-01 flow. Idempotent on the domain natural key, and already_exists says whether the row was left as found. true: the team's row is returned as it stands (pending, active, or an attempt in flight whatever the status), nothing was written. false: a new row, or a failed/expired row with nothing in flight or a soft-deleted row recreated in place (same sid, reset to pending, challenge and last_error cleared; read last_error with get_ssl_certificate first if the re…

Create a new workspace. The caller becomes the owner AND the first member; the free "Sandbox" plan (forever free, 1 account slot, no card) is applied automatically where the owner does not already run a free workspace. Names are not unique: every call creates a new team (no dedup).

Invite a person by email. Born status=invited, user_sid=null, with a one-time code (+7d expiry); dispatches the invite email. permissions is the explicit token list validated against the catalog (403 grant_exceeds_ceiling when it exceeds the CALLER's own grant; '*' is grantable only by the owner or a wildcard holder; can_view_teams is always added - the membership floor). account_sids is the optional profile slice (null/omitted = all team profiles; an explicit empty list is refused, and a sliced caller cannot grant beyond their own slice). Natural key (team, email) over live rows; re-inviting …

Create a webhook subscription endpoint. The server generates a 32-char hex secret and returns it ONCE in this response (masked on every subsequent read). Store it client-side for HMAC verification. target_url must be https:// and public (non-RFC1918); each events[] value is validated against WebhookEventTypeEnum; the same target_url cannot be registered twice per team. State-changing.

Decommission (soft-delete) a single antidetect browser by sid: outward, destructive, one-way through MCP. A browser in an active-run status is stopped FIRST and the node must confirm: the call can take up to ~20s waiting for that confirm, and if it does not arrive the delete is refused with 409 conflict (context.reason=browser_stop_unconfirmed) and NOTHING is deleted - retry in a minute rather than assuming success. Variant B cascade: the bound linkedin-account is soft-deleted and pending plugin tasks transition to failed; the cascade block reports the counts. A platform-minted GoLogin profile…

Revoke a key (simple soft-delete): status=revoked, deleted_at set. The key stops verifying at once: id tells every channel service to forget its cached verdict (a peer the fan-out cannot reach falls back to its 5-minute cache). Irreversible: a revoked key never re-activates; issue a fresh one. Idempotent: re-deleting → already_deleted.

Remove a saved payment method: this only takes it off the paying user's saved list in Paddle. A method a live subscription uses is refused (409 conflict, payment_method_in_use) until that subscription is moved to another card via get_billing_payment_method_add_link: always the case for is_default:true while the plan bills it. A non-default card can be refused too, when it pays another subscription of the same payer (another workspace or a floating one). Idempotent. Requires billing.manage.

Retire a collector for good: soft-delete, so no further run is ever minted and a run in flight abandons at its next page boundary. Runs and collected leads are retained for audit and stay readable by sid. The linked mass-action is INDEPENDENT and keeps draining the leads already enrolled in it: stop that separately with delete_mass_action. To stop collecting for a while without losing the job, use pause_linkedin_auto_scrape instead. No undo through MCP.

Delete one of OUR OWN LinkedIn comments, addressed by comment_urn (wire delete-comment). The counterpart of create_linkedin_comment. You already hold the handle: create_linkedin_comment returns comment_urn, and the linkedin-scraping get-post-comments rows carry the same compound urn, so a comment can be removed without any extra read. LinkedIn only deletes the account's own comments and we do not pre-validate that. Identity-bound: linkedin_account_sid REQUIRED, spends the SAME comment_posts bucket as commenting (30/day), but an undo is paced 2 s, not the bucket delay, so a comment and its dele…

Delete one thread from this account's OWN LinkedIn mailbox (wire delete-conversation, matrix row 110). Counterpart mailboxes keep their full copies and no message is recalled: the opposite blast radius of delete_linkedin_message_on_linkedin, which recalls ONE message for everyone. Irreversible on the wire (LinkedIn resurrects the thread only when a counterpart writes again), so not a mass action. Pass the conversation sid; the LinkedIn-side delete runs first and the stored row is soft-deleted only on a confirmed success (the next sync converges to the same state). Voyager basic messenger only:…

Recall one of OUR OWN sent messages: it disappears for EVERY participant, not just for us. Addressed by the message sid, like react_linkedin_message. Irreversible - a wrong sid destroys a real conversation, so confirm the message first. LinkedIn allows a recall only WITHIN AN HOUR of sending; past that it refuses, so an older message comes back as 409 message_too_old_to_recall with nothing dispatched and no limit spent. The stored row is NOT removed: it stays in the thread marked is_deleted with an emptied body, which is what LinkedIn serves afterwards, so the operator still sees that somethin…

Delete one of OUR OWN LinkedIn posts, addressed by activity_urn (wire delete-post). The counterpart of create_linkedin_post and the way to retract a post an agent published: pass the activity_urn that create_linkedin_post returned, or the post URL. LinkedIn only deletes the account's own posts and we do not pre-validate that. Identity-bound: linkedin_account_sid REQUIRED, spends the SAME posting bucket as publishing (20/day in series of 3 at a 1200 s pause; free plan 4 - the series is what lets a publish and its delete fit back-to-back), saturation returns 429. Backend urns (urn:li:share:, urn…

Delete one SCHEDULED (never published) post from the account's queue, addressed by the BACKEND urn get_linkedin_scheduled_posts returns as rows[].post_urn (wire delete-scheduled-post). NOT a variant of delete_linkedin_post: an unpublished share has no activity urn, and this verb runs a graphql mutation against the queue while delete-post drives an SDUI action on a live feed post - the two handles are not interchangeable. Spends the one Content bucket, posting (20/day in series of 3 with a 1200 s pause; free plan 4/day) - the same bucket publishing spends, sized so queue cleanup and publishing …

STOP a bulk run. This is the cancel path and it works at any status: pending and queued items are swept to cancelled, running items finish their current step and stop at the boundary, an auto-scrape feeding a standing run stops being able to append, and the run is soft-deleted. The cascade block reports how many were cancelled and how many were still in flight. Items stay queryable; there is no undo through MCP, and a plan cannot be edited, so restarting means a fresh preview and create.

Dismiss a notification from the inbox: a soft-delete that sets deleted_at. DESTRUCTIVE (removes the row from inbox lists). It does NOT cancel in-flight delivery: if the delivery worker already picked the row up, the email still goes out. The audit row is retained (recoverable via deleted_at filters).

Destructive. Soft-delete the client (sets deleted_at) and cascade-revoke every issued oauth session and grant, disconnecting all agents connected through this app immediately. The public OAuth flow rejects a soft-deleted client. Idempotent: re-deleting → already_deleted. The client's sessions survive as revoked-not-deleted (retained).

Remove a custom domain's certificate. DESTRUCTIVE. Revokes the certificate at the CA (best-effort), removes the on-disk serving files, and soft-deletes the row. The CA-revoke and file-removal are external side effects, not a DB cascade, so this is a simple delete. No recovery: re-create + re-issue to restore.

Cascade soft-delete a workspace and its owned rows (members, keys, sessions, oauth clients, certs). Owner-only. DESTRUCTIVE. Blocked (409 delete_blocked) while a paid applied subscription is live. Unapply/cancel it first; clear soft blockers (active keys / members) with acknowledge[]. Deleting the owner's LAST workspace is allowed and leaves their ACCOUNT untouched: they are left with no workspace until their next sign-in provisions a replacement. Erasing an account is a separate deliberate act, never a side effect of this tool. There is no restore: the deleted workspace cannot be brought back…

Remove a pending invite OR kick an active member: one tool, soft-delete. DESTRUCTIVE. The structural owner is protected (409 conflict, owner_cannot_be_removed); move ownership via transfer_team_ownership first. Kicking a member revokes their sessions in this team only.

Soft-delete a webhook (deleted_at set; webhook stops matching new events). Existing webhook_logs remain queryable but un-retryable; pending / retrying deliveries are cancelled. Destructive and one-way (no API undo).

Download one inbound attachment of a basic-messenger message, returned inline as a base64 data_url (nothing is persisted, no row changes). This verb is addressed by RAW LinkedIn ids, not by our message sid, so assemble it from a message row you already hold (search_linkedin_messages): linkedin_account_sid = that row's linkedin_account_sid; message_id = that row's message_hash (must be the 2-… form); attachment_urn = attachments[i].urn on the same row. profile_id is the ACTING account's own LinkedIn URN: read ln_id off that linkedin_account_sid via search_linkedin_accounts, NOT the other party'…

Sales Navigator variant of download_linkedin_message_attachment: one inbound attachment of an SN message, inline as a base64 data_url. Same raw-id addressing, one field fewer (the SN wire verb takes no profile_id): linkedin_account_sid must be an account with Sales Navigator, message_id is the message row's message_hash, attachment_urn is attachments[i].urn on that row. The row must be messenger_type='sales_navigator' (an account without SN is refused before dispatch). Same 120 s budget and messaging_general bucket.

Edit the connected account's OWN LinkedIn profile in one call: the intro card (name, headline, additional name, industry, location, the current position/education pins and their visibility, website, pronouns), the About section (`about`, `top_skills`), the profile photo (`photo`) and the background image (`background`). Send only what changes: the intro card is read first and submitted whole (the LinkedIn wire replaces it), the About save is partial (an omitted field keeps its value, about: '' clears the text, top_skills: [] removes them all), each image replaces one picture. Every section is …

Endorse a target person's skills from this account (warm-up / engagement action). Outward action on LinkedIn.

Endorse ONE explicit skill on a 1st-degree connection as this account (wire endorse-skill, ?action=endorse). Unlike endorse_linkedin_account_skill there is no discovery read and no auto-pick: you supply skill_id, exactly one dispatch. Skill ids exist only on skills that already carry at least one endorsement (a zero-endorsement skill is not addressable), so take them from the enrichment person-skills read. Requires a 1st-degree connection (409 not_connected). Spends the endorse_skills bucket (30/day, paced; the undo waits only 2 s, so an endorse and its undo fit back to back). Returns the echo…

The cheap company read: id, vanity, name and logo, nothing else. Deliberately sparse, the company twin of the lite person profile. Use it to confirm a company exists and to pin its identifiers before joining data; use enrich_linkedin_company_profile when you actually need industry, size, HQ or the about text. cached 7d. COST NOTE: a /company/<slug>/ URL is ONE small request on LinkedIn's side, while a Sales Navigator /sales/company/<id> URL costs TWO, because the vanity has to be resolved first (measured: 433 ms vs 2479 ms). Prefer the vanity URL, or resolve the id once with enrich_linkedin_co…

The company page's own feed, newest-first: the company-side twin of person-posts (author = the company page). Addressed by NUMERIC company id, nested: {company:{company_ln_id}}. If all you have is a company URL or slug, call enrich_linkedin_company_profile first and take company_id off its result; passing {company:{company_url}} here validates and is then refused not_dispatchable, having still opened a ledger row. cached 7d, paginated.

One company page's own data: name, industry, size, HQ, about, website, followers. URL-addressed (ledgered input_kind='url'). cached 7d. To LIST a company's people use scraping (company-employees / company-decision-makers).

Resolve a numeric LinkedIn company id to its vanity slug. Its own method because this resolution is the single most expensive company request LinkedIn serves: a ~164KB organizational-page download, the only id-native request that reveals the vanity. Cached 30d, since the mapping does not change. The pattern that keeps company work cheap: resolve the id ONCE here, then call every other company read by vanity.

Resolve any linkedin.com post URL (feed permalink, /posts/ slug) or lnkd.in shortlink to its stable activity URN (urn:li:activity:…). A shortlink is expanded server-side before the page is opened. The URN never changes, so this is a cacheable enrichment lookup at cached 7d. It is the resolver the get-post-* / tracked-post flows build on. Returns activity_urn (null if the URL could not be resolved - notably a shortlink of a ugcPost-threaded post, whose page exposes no activity urn at all; address such posts by post_urn via enrich_linkedin_post_details instead, which takes the shortlink directly…

The middle person read, between the lite identity stub and the full dossier: name PARTS (first / last, which no other read splits out), headline, country and display location, profile and background imagery, and the premium / influencer / creator / verified flags. One request, cached 24h. Reach for this when you want to know WHO someone is without pulling the experience and education cards you will not read. Addressed by public_identifier ONLY: the underlying query keys on the vanity slug, so a urn-only call is refused before any browser work (resolve the slug with enrich_linkedin_person_lite_…

Licenses and certifications from the target profile: issuing authority, license number, validity window. A qualification and compliance signal for recruiting and technical ICP fit. cached 7d. Most profiles have NONE, so an empty list is a real answer about the person rather than a failed read. license_number and url are frequently null even on real entries (LinkedIn own certifications carry neither). Address by profile_id XOR public_identifier, the same exactly-one-of rule as every other person read: passing both is a 422, they prohibit each other. The screen behind this one is the exception t…

The target's recent comments across OTHER people's posts (activity feed, Comments tab): where the target spends attention, and warm entry points for an opener. Each item carries the PARENT POST too, so you can read what they were reacting to without a second call. cached 7d, paginated. Addressed by profile_id alone. PAGING: the end of the feed is a MISSING paging.next_page_cursor, never an empty page, because member filtering can empty a page mid-feed; there is no total, LinkedIn reports 0 for this feed whatever is in it. The target's OWN posts are person-posts; the commenters OF a post are sc…

Contact details for ONE person: email, phones (typed, so HOME/WORK is kept, unlike the lossy flat `phone` on person-full-profile), websites and twitter handles. Cached 24h. IMPORTANT: LinkedIn reveals contacts to 1st-degree connections ONLY, so this runs from whichever of YOUR accounts is connected to the target (picked automatically, respecting limits; linkedin_account_sid is only a preference). If none of your accounts is connected it refuses 422 no_connected_account, so connect first (linkedin_connection_requests send), then retry after the invite is accepted. An empty block means the conne…

Education history only, a subset projection of the full-profile wire call (NOT a stub: shares get-full-profile, no dedicated verb). cached 7d under its own method key (a cached full profile does NOT satisfy it). Not paginated. public_identifier passes straight through (native slug support).

Complete, paginated work history ("Show all experiences"), unlike the truncated head on full-profile. One call = one page; loop cursor until paging.next_page_cursor is absent. cached 7d. A public_identifier-only call needs a stored URN (run person-lite-profile first) or is refused not_dispatchable. On the connected account's OWN profile each entry also carries position_id, the key of the position editing verbs.

The Featured section: what the target chose to pin (posts, links, media). Small, cheap, high-signal for personalization: pinned content is what the person WANTS noticed. cached 7d. Not paginated. A public_identifier-only call needs a stored URN.

The complete person dossier: identity, headline/position/company, location, about, follower/connection counts, premium/verification flags, plus truncated heads of experience/education/skills/recent posts. cached 24h. One full profile beats separate subset calls when you need profile + 2 or more sections. Full sub-record lists still need the dedicated paginated methods. picture_url is normalized to avatar_url.

ONE tab of the Interests section per call: top_voices (the default), companies, groups, newsletters or schools. Cheap ICP-fit and conversation-hook signal. cached 7d, paginated. The wire pages a single tab, so reading all five spends the method five times; the requested tab is echoed at result.tab so a caller looping the vocabulary can tell the responses apart. Addressed by public_identifier ONLY: a urn-only call is ledgered and then refused not_dispatchable, so run person-lite-profile first if all you have is the urn.

The Languages section: spoken languages with self-declared proficiency. Cheap localization signal: write the opener in the prospect's native language. cached 7d. Most profiles declare NONE, so an empty list is a real answer about the person rather than a failed read. proficiency is the RAW string LinkedIn renders, suffix included ("Native or bilingual proficiency", "Full professional proficiency", ...), localized on non-English sessions and null when the member declared the language without a level. Address by profile_id XOR public_identifier; like certifications, the screen behind this one ne…

Cheapest person read: existence check + full identifier resolution. THE tool for turning a vanity slug (/in/…) or a bare URN into the canonical identifier quad (ln_member_id + both URNs + nickname) that every deeper enrich and stored-domain join keys on. cached 24h. Pin linkedin_account_sid and the relationship degree comes back with it in network_distance, which saves the second dispatch to linkedin-connections.check-degree; without a pinned account that field is null, because a degree relative to an account you did not name is not an answer. Address by profile_id XOR public_identifier.

Posts authored or reshared by the target, newest-first: the personalization goldmine before outreach. Reshares carry the original in reshared_post; created_at is ISO 8601. cached 7d. This is the target's OWN feed; to harvest who ENGAGED with a post use the scraping surface. A public_identifier-only call needs a stored URN.

The target's recent reactions on OTHER people's posts (activity feed, Reactions tab): topical interest signal, cheaper to act on than comments. Each item carries the reaction type, when they reacted, and the PARENT POST whole. cached 7d, paginated. Addressed by profile_id alone. PAGING: the end of the feed is a MISSING paging.next_page_cursor, never an empty page; there is no total, LinkedIn reports 0 for this feed whatever is in it. reaction_type is null when the header phrase did not map, which is normal. The reactors OF a post are scraping (get-post-reactors).

Recommendations on the target profile: who vouches for them and in what words. `direction` picks received (the default, what LinkedIn opens on) or given; these are two SEPARATE reads of the same screen, so asking for both runs the method twice. cached 7d. The counterpart carries a nickname, name, headline and network distance but NO ln_id: LinkedIn does not put the member urn in this payload, so enrich the nickname separately if you need the urn. created_at is parsed out of the free-text context line and is null when that line has no date. Address by profile_id XOR public_identifier, the same …

The "Providing services" marketplace page of one service-provider profile: business name, pricing line, page URL and the standardized services they list. Complements scraping-side search-service-providers (that discovers providers, this reads one provider's own page). cached 7d, no pagination. result.services is NULL when the member sells no services at all, which is a different fact from a page whose services_provided is empty, and both are a normal completed read. A page its owner has UNPUBLISHED reads as null too (LinkedIn drops the link the read follows), which looks the same as never havi…

Complete, paginated skills list ("Show all skills") with endorsement counts (skill_id is the endorse handle). cached 7d. Use to see/reason over skills; to simply ENDORSE, use linkedin-accounts.endorse-skill (auto-discovers skills, no enrich call needed). A public_identifier-only call needs a stored URN.

One post's own data by its urn: full text, author, media, engagement counters, per-reaction breakdown, is_reshare with the original post embedded. LIVE since 2026-08-14 (node get-post). Accepts post_urn XOR url. result.post is null when the post is deleted or unavailable - a delivered answer, not an error, so do not retry it. Cached 7d. WHO engaged is scraping (get-post-comments / get-post-reactors / get-post-resharers); impressions exist only on the executor's own posts.

Hand the current issue to the human support team. Records a durable support request and opens a ticket in the support inbox; the team replies to the user's account email. Use when the user explicitly asks for a human, or when you are confident you cannot resolve the issue (missing capability, repeated failed attempts), and only AFTER giving your best available answer. The response item's status says what happened: handed_off (in the support inbox), received (recorded; delivery pending configuration), handoff_failed (recorded; delivery will be re-driven by ops; do not tell the user it failed, t…

ESCAPE HATCH: issue one arbitrary LinkedIn HTTP call (url + GET/POST + headers/body) under a chosen OWN account, for endpoints the typed methods do not cover. May be a read or an action (apply to a job, attend an event), so you own the semantics. High-risk: admin-gated + feature-flagged; the url must match the server host allowlist (else 403 forbidden_endpoint). OWN-ACCOUNT ONLY: linkedin_account_sid is REQUIRED. It spends the account's custom_request bucket, which returns 429 when saturated. A non-2xx response is still a successful dispatch (ok=false, status_code carries it; never throws). Th…

Follow a LinkedIn member as this account, so their posts reach its feed. One-way and needs no relationship: you can follow anyone whose profile allows it, connected or not, which makes it a common warmup step before a connection request. IDEMPOTENT: following someone this account already follows returns 200 with the same terminal state, so a repeat is a success, not an error. The wire cannot tell a fresh follow from a repeat, so read get_linkedin_account_my_following first if you need that answer; either way the call spends one networking_general unit (40 a day, 180 s apart). Pass target.nickn…

Mint a cloud-browser access key (smart-link) on a browser. Returns the whole minted entry in result.access_key, whose `key` field is the raw cb_ak_ token (shown once), AND result.public_connect_url, the ready-to-share link to hand to whoever opens it (no platform account needed on their side). Pass result.access_key.key, never result.access_key, to revoke_cloud_browser_access_key. `purpose` decides what the page behind the link does: `relogin` walks them through signing the LinkedIn session back in and re-binds the browser once they confirm, `share` just hands them the browser to drive. Option…

Fetch a single antidetect browser by sid, with optional eager-loaded relations.

Seats and 5G proxy slots the workspace occupies: every live browser row, whatever its status and whether a LinkedIn account is bound. Team-wide; compare against limits.accounts and limits.proxy_5g.

Fetch a single API key by sid, with optional metrics include. Returns token_prefix + token_last4 for display; the secret is unrecoverable (use rotate_api_key to mint a new one).

Period-bound counts of the team's keys by status, plus issuance / expiry tallies inside the window (created_in_period, expired_in_period). Requires period {from, to}. Optional filter. Counts key rows, not key traffic.

Period-bound totals of the team's external API requests, merged across the answering services: total_count, error_count and the 2xx/3xx/4xx/5xx split in aggregated.counts; error_rate, avg_duration_ms, first/last_occurred_at in aggregated.metrics. Requires period {from, to} (ISO 8601 UTC, half-open, at most 92 days). Optional group_by splits the same numbers per key: client_sid ("how much does each agent call", groups carry the client name), route or entity ("which tools"), status_family, service, surface (occurred_hour / occurred_day exist too but bucket is the better time axis). Optional buck…

Return a temporary Paddle Customer Portal deep link to add or replace a card for the workspace's applied subscription. This is the ONLY way to add a card: Paddle has no add-card API; the user enters card details on Paddle's hosted page. Never cached. Returns no_billing_account if the workspace has no applied subscription. Requires billing.manage.

Fetch a single billing subscription by sid, with optional includes (price, product, team, latest_transactions).

Return a short-lived Paddle portal deep link to update the card for this subscription (the typical past_due recovery path). No charge, mutates nothing on our side. Requires billing.manage.

Fetch a single billing transaction by sid, with optional subscription / owner / team includes. Returns the frozen items[] charge snapshot inline.

Fetch a temporary, time-limited URL for this transaction's invoice PDF from Paddle (never stored here; expires ~1h, opens inline). Works for self-serve card charges and sales-issued manual invoices. Returns invoice_not_ready before the transaction is billed, and invoice_not_available when Paddle issued no invoice for it (a $0 payment-method-change charge, a canceled checkout): the rows with a PDF are the ones carrying invoice_number. Read-only, mutates nothing. Requires billing.view.

Period-bound money sums over the caller's transactions. Requires period {from,to}. Money never crosses currencies; every sum lives inside a per-currency by_currency entry keyed by ISO 4217. Answers 'how much did I pay / tax this quarter'. Sums are GROSS (refunds not modeled in v1). Filter is the same object as search and every axis is applied; billed_at / created_at operators are dropped from the period-bound sums (period is the one window there) but they DO scope the counts block, which carries no period of its own. Requires billing.view.

Period-bound aggregates over a filtered cloud-browser-session set. Requires period {from,to}. Returns total_count, active_count, avg_session_duration_seconds, login_success_rate, unique_devices_count and unique_ips_count. Optional filter and a single group_by axis (access_type / login_result / ip_country / antidetect_browser_sid / …).

Return the authenticated user's own profile: the JWT subject, self only (no {sid} form). include[]=default_team hydrates the working team; include[]=accessible_teams returns the owner + active-membership union (workspace switcher / OAuth consent multiselect). Reads email, name, timezone, default_team_sid. Needs a credential with a person behind it (an app session or an OAuth connector). An API key authenticates as itself, not as a user, so on a key this answers 403 with context.reason=not_a_user_actor and no permission changes that.

Fetch a single ledger row by sid to inspect one request referenced from a data-requests.* webhook or another row's cached_from_sid pointer.

Fetch one knowledge-base article in full by its id (as returned by search_knowledge in article_id). Use when the retrieved chunks reference steps or context you need whole.

Return the most recent platform benchmark row (largest period_start < today). Platform-GLOBAL: every team reads the same weekly row. No parameters. Use to compare an account or fleet against the market (acceptance rate, reply rates) and to calibrate safe daily ceilings by cohort. Pair it with linkedin-account-snapshots / linkedin-accounts / *.metrics for the per-account numbers to compare against. Every metric lives in the group_1 / group_2 / group_3 JSON blobs; dereference the specific path per MARKET_BENCHMARKS.md. NOT for a single account's current numbers (linkedin-accounts / -snapshots), …

Fetch a single LinkedIn account by sid, with optional eager-loaded relations. For login or health state add include antidetect_browser: browser status login_issue means the sender is signed out of LinkedIn, while the item status field is platform lifecycle, not login state.

Period-bound aggregates over a filtered activity-log set (avg plugin duration, avg pending age) plus the counts block and an optional group_by axis (action_type | status | linkedin_account_sid). Use for: "what was done today/this week grouped by action_type", at-a-glance fail rate (group_by status). Guardrail (high-write table): period {from,to} is REQUIRED and filter must include linkedin_account_sid.eq/.in. Unbounded scans are rejected; window may not exceed 90 days. The filter here is NARROWER than search: linkedin_account_sid and status are the only axes the aggregation applies. Slice any …

Read the connected account's creator content analytics over a date window: per metric (impressions, engagements) the daily series, the period total, and the percentage change against the prior period. Omit both dates to get the trailing 28 days, which is what the LinkedIn dashboard itself opens on. Supplying one date without the other is refused rather than half-defaulted, and a window running into the future is refused too (LinkedIn has no data there and would answer with zeroes that read like a collapse in reach). Identity-bound: this is the account's own dashboard, not a competitor read. Th…

The nurture cards on this account's My Network catch-up tab (linkedin.com/mynetwork/catch-up/all): birthdays, job changes and work anniversaries among its connections, each with the one-click message LinkedIn printed on the card's button. The "who is worth congratulating today" feed. READ ONLY: it lists prompts and sends nothing. message_sent means this account already answered that card, and null means LinkedIn said nothing, not no. NO page_size, deliberately: LinkedIn's own request carries no count knob, so the page is server-fixed at 10. Page with `cursor` instead, passing paging.next_page_…

Return the Sales Navigator InMail credit balance (the LSS_INMAIL grant) for the connected account. Requires a Sales Navigator seat: the balance is read from the Sales Navigator credits API, so an account without a seat is refused with 422 `sales_nav_required` instead of being dispatched into a guaranteed LinkedIn 403.

List who the connected account follows, newest-first: the follow-edge twin of get-my-followers (§5.8 latest-*). A null cursor refreshes then returns the head page; a non-null cursor is a read-only continuation over the already-refreshed head (no limit spend). Cursor-paginated.

Fetch the full self-profile of the connected LinkedIn account.

One page of this account's own LinkedIn Recruiter hiring projects, most recently accessed first, optionally filtered by a name keyword. NEEDS A RECRUITER SEAT (422 recruiter_required otherwise). The one recruiter list with an exact paging.total. Omit page_size to get the wire default of 10; pass paging.next_page_cursor back as `cursor` for the next page. Read-only, persists nothing, one self_account_sync unit.

Fetch the lite self-profile (name, headline, avatar) of the connected account.

Who viewed this account's profile over the LAST 90 DAYS, newest first: the list behind linkedin.com/me/profile-views. Window and sort are fixed by LinkedIn and there is no filter, so "who viewed me today" means reading the top of the feed. Rows carry rendered text only ("Viewed 1w ago"), never a parseable date. An ANONYMIZED viewer arrives with is_anonymous true, a descriptor where the name goes, a people-search url instead of a profile, and no member ids, so branch on that flag before opening or keying a row. Served by the Premium viewer screen, so what a non-premium account gets back is unve…

The Recruiter contracts this account's member can act under (LinkedIn's contract chooser, wire get-recruiter-contract-options), with current_contract_id = the contract the account's seat is stamped under. NEEDS A RECRUITER SEAT on the account (422 recruiter_required otherwise). Read it when recruiter_status is set but recruiter_seat_id is null: a member on several contracts holds no seat until the browser is bound to one. The premium check does not bind one by itself: from the platform's browser this list answers LinkedIn 401 on every account so far, a live session included, and the refusal co…

This account's own LinkedIn Recruiter seat, contract, profile and entitlements (the talentMe read). NEEDS A RECRUITER SEAT on the account (422 recruiter_required otherwise). Every field can be null: the wire may omit any of them. owner_seat_id is the seat number the recruiter sync and thread tools dispatch with; the premium check stamps it onto the account itself (recruiter_seat_id), this read persists nothing. Call it to check can_send_paid_inmail and credits before send_linkedin_recruiter_message, or to see using_multiple_contracts. Spends one self_account_sync unit.

This account's Sales Navigator alert feed, the bell on linkedin.com/sales/home: saved leads and accounts posting, changing job, accepting an invitation, or turning up in a profile-view signal. NEEDS A SALES NAVIGATOR SEAT on the account; without one we refuse up front rather than spend a run on a likely refusal. Ordered by LinkedIn's own RELEVANCE score, NOT reverse-chronological, so sort by published_at yourself before calling anything new. That field is epoch milliseconds and is the only machine-readable timestamp across the three self feeds. metadata.num_unseen counts unseen alerts feed-wid…

Read the connected account's OWN LinkedIn services page ("Providing services") as its edit form: status (ACTIVE or UNPUBLISHED), description, the offered services with their standardized-skill ids, the location and messaging flags, review visibility, pricing, the currencies LinkedIn offers and the 16 top-level service categories (valid service ids, though sub-skills exist too: lookup_linkedin_param_id with type service_category finds them by name). result.page is null when the account has no page. The public page of any member is enrich_linkedin_person_services; this is the owner's view, read …

List the active LinkedIn sessions for the connected account.

Read the connected account's Social Selling Index: the overall score, the four pillars it is the sum of (professional brand, finding the right people, engaging with insights, building relationships), and where the account stands inside its industry and its own network. Answers WITHOUT a Sales Navigator seat, reporting that as active_seat: false with the scores still filled in, so it is a health signal for any account rather than a premium-only read. Identity-bound: the sid names the account whose own dashboard is read; there is no way to read someone else's SSI. Every score is FRACTIONAL (a re…

Fetch one sync run by sid, with includes (linkedin_account; activity_log_pages for the per-page fetch log; limit for the gating smart-limit bucket, always resolved). Use to drill into a single run's progress, resume-cursor state, and per-page audit.

Aggregate sync-run counters for dashboards: a counts block (total + per-status: pending, in_progress, completed, cancelled) plus avg_completed_duration_seconds, with an optional group_by axis (status | sync_type | triggered_by) that repeats the same block per group. Required period {from,to} bounds the window.

Fetch one collector by sid: status and paused_reason, next_run_at and last_run_at, runs_count and total_new_results, and mass_action_sid (null = collect-only). include: linkedin_account (the executor row), last_run (the newest run, null when the job has never run). Executions and leads are separate reads: search_linkedin_auto_scrape_runs and search_linkedin_auto_scrape_results.

Fetch one run by sid: the poll handle after run_linkedin_auto_scrape_now. Read status, page_cursor and pages_applied for progress, new_count against enrolled_count for how much of the delta reached the linked mass-action, and error_message for why a failed run failed. The leads it discovered come from search_linkedin_auto_scrape_results filtered on first_seen_run_sid, which is the authoritative delta (new_count is a best-effort rollup under crash retry).

Period-bound aggregates over one account's invitations. Requires period {from,to} and filter.linkedin_account_sid (.eq or .in) - that is the ONLY filter axis the aggregation applies, unlike search. Returns avg_time_to_triage_seconds; acceptance / ignore rates are derived client-side from the counts block.

Period-bound aggregates over one account's sent requests. Requires period {from,to} and filter.linkedin_account_sid (.eq or .in) - that is the ONLY filter axis the aggregation applies, unlike search. Returns avg_note_length_of_accepted and avg_time_to_accept_seconds; acceptance / withdraw / expiry rates are derived client-side from the counts block.

Period-bound aggregates over a filtered connection set. Requires period {from,to} (≤ 90 days). Returns connections_growth, connections_removed, net_growth, reply_rate_within_connections, dormant_connections and avg_time_to_first_message. Optional filter and a single group_by axis.

Fetch one conversation by sid: the stored row including the denormalized participants list. Stored-DB read: no plugin call, no limit spend.

Period-bound conversation aggregates for one account (new_conversations_count, active_count) with an optional group_by axis. Requires period {from,to} (≤ 90 days) and filter.linkedin_account_sid - that is the ONLY filter axis the aggregation applies, unlike search. Returns the counts block alongside.

Period-bound audience aggregates over a filtered follower set. Requires period {from,to}. Returns followers_growth, follower_to_connection_conversions and connected_follower_share. Optional filter and a single group_by axis (linkedin_account_sid).

Period-bound message aggregates for one account (reply_rate_pct, avg_time_to_reply_seconds, avg_thread_depth) with an optional group_by axis. Requires period {from,to} (≤ 90 days) and filter.linkedin_account_sid - that is the ONLY filter axis the aggregation applies, unlike search. Returns the counts block alongside.

One page of the account's SCHEDULED-posts queue: drafts waiting for their publication time, each with post_urn, scheduled_at, text and LinkedIn's own error_message (wire get-scheduled-posts). A PRIVATE read - nobody on LinkedIn sees it - but it spends the one Content bucket, posting (20/day in series of 3 with a 1200 s pause; free plan 4/day), shared with publishing. Pass author_organization_id (the bare numeric company id) to read a COMPANY PAGE's queue the account administers instead of the member's own. Offset-paged: page_size 1-100 (default 20), pass paging.next_cursor back as cursor. rows…

Fetch one bulk run by sid: the plan that runs, status / paused_reason / hold_till, the canary gate and settled_at. include=metrics adds the item breakdown, which is where outcome lives.

Where a run is right now, in one round-trip, without paging items. Typical call: filter {sid:{eq}}. Returns items_by_status (the outcome split), items_by_current_step, items_by_wait_reason, in_flight (0 means the run is caught up), the next / last scheduled item, created_objects and the top error prefixes. No group_by: the shape is fixed. Use this instead of listing a run's items to answer 'how is it going'.

Always-fresh head read of pending inbound invitations: refresh the newest from LinkedIn in-request (§5.8), then return the last N (received_at DESC). The first page (cursor null) triggers the refresh; continuation pages read the already-refreshed DB. Account-scoped. Runs through the account's browser: a stopped or idle one is cold-started first (about 50 s, or 503 browser_starting), which also releases that account's overdue syncs.

Always-fresh head read of pending outbound requests: refresh the newest from LinkedIn in-request (§5.8), then return the last N (sent_at DESC). The first page (cursor null) triggers the refresh; continuation pages read the already-refreshed DB. Account-scoped. Runs through the account's browser: a stopped or idle one is cold-started first (about 50 s, or 503 browser_starting), which also releases that account's overdue syncs.

Always-fresh head read: refresh the newest connections from LinkedIn in-request (§5.8), then return the last N (connected_at DESC) with a counts block. The first page (cursor null) triggers the refresh; continuation pages read the already-refreshed DB. Account-scoped. For richer slicing call search_linkedin_connections right after. Runs through the account's browser: a stopped or idle one is cold-started first (about 50 s, or 503 browser_starting), which also releases that account's overdue syncs.

Always-fresh head read of the basic-LinkedIn-messenger thread list for one account (§5.8 foreground refresh, then the last N threads from the refreshed DB, last_activity_at DESC). Never serves stale data: it 429s with bucket_saturated / sync_in_progress instead. Use before an inbox decision; use sync_my_linkedin_conversations for full backfill. Runs through the account's browser: a stopped or idle one is cold-started first (about 50 s, or 503 browser_starting), which also releases that account's overdue syncs.

LinkedIn Recruiter variant of get_my_latest_linkedin_conversations: always-fresh head read of the recruiter inbox for one account (§5.8 refresh-then-return over the talent wire, page size fixed at 15 by that wire). Same hard-429 guards; returns messenger_type='recruiter' rows whose recruiter_id is the candidate. Needs a Recruiter seat and its stamped seat number (422 recruiter_required / recruiter_seat_unresolvable). Runs through the account's browser: a stopped or idle one is cold-started first (about 50 s, or 503 browser_starting), which also releases that account's overdue syncs.

Sales Navigator variant of get_my_latest_linkedin_conversations: always-fresh head read of the SN thread list for one account (§5.8 refresh-then-return). Same hard-429 guards; returns messenger_type='sales_navigator' rows. Runs through the account's browser: a stopped or idle one is cold-started first (about 50 s, or 503 browser_starting), which also releases that account's overdue syncs.

Always-fresh head read of the followers list: refresh the newest from LinkedIn in-request (§5.8), then return the last N (created_at DESC) with a counts block. The first page (cursor null) triggers the refresh; continuation pages read the already-refreshed DB. Account-scoped. Runs through the account's browser: a stopped or idle one is cold-started first (about 50 s, or 503 browser_starting), which also releases that account's overdue syncs.

Always-fresh head read of ONE basic-messenger thread (§5.8 refresh of that conversation from LinkedIn, then the last N messages, sent_at DESC). Never stale: it 429s with bucket_saturated / sync_in_progress. Use before drafting a reply; use search_linkedin_messages for stored history. Runs through the account's browser: a stopped or idle one is cold-started first (about 50 s, or 503 browser_starting), which also releases that account's overdue syncs.

LinkedIn Recruiter variant of get_my_latest_linkedin_messages: always-fresh head read of ONE recruiter thread's messages (§5.8 refresh-then-return over the talent wire, dispatched with the account's seat). Requires a messenger_type='recruiter' conversation (a 422 messenger_type_mismatch names the right tool otherwise) and a Recruiter seat with its stamped seat number; same hard-429 guards. Rows: linkedin_type='inmail', type outbox for the seat's own messages and inbox for the candidate's. Runs through the account's browser: a stopped or idle one is cold-started first (about 50 s, or 503 browse…

Sales Navigator variant of get_my_latest_linkedin_messages: always-fresh head read of ONE SN thread's messages (§5.8 refresh-then-return). Requires a messenger_type='sales_navigator' conversation; same hard-429 guards. Runs through the account's browser: a stopped or idle one is cold-started first (about 50 s, or 503 browser_starting), which also releases that account's overdue syncs.

Fetch a single notification by sid: the rendered subject / body, delivery state, and failure reason if any.

Period-bound delivery-health aggregates over a filtered notification set: how many notifications were delivered, failed, and rate-limited in the window. Requires period {from,to}. Optional filter and a single group_by axis (event_name / status / channel).

Fetch one OAuth client by sid. include:["active_sessions"] lists agents connected through it (requires sessions.view). client_secret is never returned on a read.

Fetch a single certificate by sid: status, issuer, validity window, redacted last_error, and the HTTP-01 challenge data while an attempt is in flight (status='challenge' on a first issuance, 'active' during a renewal). Poll this after issue/renew until challenge is null: a first issuance ends 'active' or 'failed' with last_error; a renewal stays 'active', with last_error null when the new certificate is live and set when it failed (the current one keeps serving). The cert body and key are never returned.

Fetch a single support escalation by sid: the full body the team received, handoff state (intercom_ticket_id, handed_off_at) and the redacted delivery error if the handoff failed.

Fetch a single team by sid, with optional includes (applied subscription, owner, member counts).

List the tools in a toolset. Default (lite) returns name + title + one-line summary; pass verbose:true for full descriptions, safety flags, and parameter names. Run one via call_tool.

Fetch a single webhook by sid. Use include=latest_webhook_logs for the recent delivery view. secret is masked (null) on reads.

Period-bound aggregates over webhook deliveries: success_rate, failure_rate, p50/p95/p99 latency, total_retries, last_success_at / last_failure_at. The rates and the two timestamps count TERMINAL outcomes only (rows in status success / failed): a delivery still in its retry loop is neither, so it shows in counts.groups.status.retrying and total_retries here and in the webhook row's consecutive_failed_attempts / last_failure_at (which count every attempt), not in these rates; a period with nothing terminal reads null, not 0. Requires period {from,to} (≤ 90 days). Optional filter scopes the row …

Ignore one inbound connection invitation (outward action). On terminal success the invitation row is soft-deleted (removal_kind=ignored); no connection is created. Identify the invitation by its ln_ci_ sid.

Invite up to 25 members to a LinkedIn event, in ONE call: one invitation batch from the account's open LinkedIn tab, one browser round and one networking_general unit (40 a day, 180 s apart; 429 on saturation). event_ln_id is the digits of the event urn, the event_ln_id of a search_linkedin_events row (the number in /events/<id>/). A target is a member id (ln_id, preferred) or a nickname; a nickname alone costs one profile read first, and a Sales Navigator id is not an address here. LinkedIn decides who may invite and who may be invited: a member inviting 1st-degree connections to a public eve…

Start the ACME HTTP-01 flow for a registered domain. ASYNC: synchronously requests authorization from Let's Encrypt, stores the token + key-authorization, flips status→challenge, and returns the challenge data + a pending ref; the platform then self-checks, validates, finalizes and flips status→active in the background (poll get_ssl_certificate, or await the ssl-certificates.issued / .failed webhook). Use after create. Not idempotent: each call requests a fresh authorization. 409 conflict if the domain is already active (use renew), while an attempt is in flight (issuance_already_in_progress),…

Proxy countries a new browser can be given right now, with how many active proxies back each. Empty list = the pool is dry; create refuses a country with no stock (422 proxy_pool_empty).

List the saved cards / PayPal / wallets for the active workspace's paying user (proxied live from Paddle). The list is re-sorted so the billing card is items[0]; is_default:true is the card that last billed the workspace, so answer 'which card am I paying with' by reading it. Cards may be listed even with no applied subscription; empty if the user has no Paddle customer. Brand + last4 + expiry only (PCI). Requires billing.view.

List the cloud-browser slots the team currently occupies. Each slot carries the connected antidetect_browser sid, the connected user, and the connect / expiry timestamps. Read-only snapshot returned in result.items.

List the account shares your team RECEIVED: accounts on loan TO you. Reach for this whenever the question is about a BORROWED account (what did we borrow, from whom, until when, is it still active), and for search_account_shares when it is about an account your own team owns and lent out. Registered as an action route but it is a plain read, with the same envelope, filters and sorts as search. It is also the holder's only programmatic arrival signal, because the domain events fan out to the owner team alone: poll filter { status: { eq: "active" } } sorted by created_at asc. Rows belong to the …

List the available toolsets (domains) on this server. Each toolset groups related tools (e.g. linkedin.messaging, id.billing). Start here, then get_toolset_tools to inspect one, then call_tool to run a tool. Requires OAuth authorization (Bearer token).

Mark a conversation thread as read on LinkedIn's side (outward action). LinkedIn-side effect only, no stored read-state changes; the audit rides an activity-log row. Idempotent; safe to retry.

Mark a conversation thread as unread on LinkedIn's side (outward action), the hand-back-to-human signal after an agent triaged a thread. LinkedIn-side effect only; no stored read-state changes.

Mute or unmute one thread's notifications on LinkedIn (outward action). Pass the conversation sid + mute (true = mute, default; false = unmute); the change is dispatched to LinkedIn and mirrored on the stored row.

Pause the subscription effective the next billing period. DANGEROUS state change (server-side confirm gate); while paused the applied team is gated like suspended, slots/data retained, billing stops. No charge. The committed status arrives via webhook. Resume with resume_billing_subscription. Requires billing.manage.

Freeze recurrence: status becomes paused with paused_reason 'manual' and next_run_at is cleared, so no new run is minted. A run already in flight FINISHES (pausing never abandons it). Idempotent. Use to stop collecting over a holiday or while an outreach plan is being reworked; use delete_linkedin_auto_scrape to retire the job outright.

Freeze dispatch: status becomes paused with paused_reason='manual'. Queued jobs roll back at pre-flight and in-flight items finish their current step, then stop at the boundary; vendor calls already on the wire are never aborted. Pass hold_till to arm auto-resume at that moment, omit it to wait for an explicit resume_mass_action. Idempotent: pausing a paused run refreshes it, and a manual pause replaces a limit_reached hold (its hold_till goes).

Read-only proration preview for a quantity / bracket-price change BEFORE committing. Calls Paddle Pricing Preview and returns the immediate charge (upgrade) or next-period credit (downgrade), the resolved new bracket price, and whether it crosses a bracket boundary. No state change, no charge. This is the confirmation gate to show the user before change_billing_subscription. Provide at least one of quantity / price_sid. Requires billing.view.

Validate a bulk plan without running anything and mint the consent token create_mass_action consumes. ALWAYS the first call of a bulk dispatch. One pass, all findings at once: plan shape (1..3 steps), step-eligibility of each tool, scope shape and size (1..100), the generate-scope rule (step 1 must mint an object), the send-class schedule mandate. A tool outside the step vocabulary is 422 with field_errors["plan.steps.{i}.tool"][0].rule = "not_step_eligible". Nothing is persisted, charged or created. Result: preview (items_count, steps_per_item, dangerous_steps, eta, warnings), commit_token, …

Add or remove an emoji reaction on one stored message on LinkedIn (outward action). Pass the message sid + a reaction_type; the reaction is dispatched to LinkedIn and mirrored onto the stored row. Set remove:true to take YOUR reaction back (pass the same reaction_type you reacted with). Basic messenger only: an SN message or a non-2-… message_hash is refused before dispatch. Spends the messaging_general bucket.

Leave OUR reaction on any LinkedIn post OR comment (wire create-reaction): entity_urn takes a post urn in any family, a post URL carrying one, or a comment urn; a post is reacted on at its social thread (see entity_urn). The social-selling counterpart of create_linkedin_comment. Outward and fire-on-success: the post does NOT need to be tracked, nothing is persisted here. Identity-bound: linkedin_account_sid REQUIRED, spends the react_posts bucket (30/day at a 360 s floor), saturation returns 429. Returns reaction_urn (the reaction's key, naming the entity it landed on; null on drift or when Li…

Take a lent-out account back. Owner side, no holder consent. Target EXACTLY ONE of sid (ac_sh_) or filter; neither or both is 422 on sid_or_filter. FILTER MODE fans out over the loans you ISSUED, the server FORCES status to active so your filter can only narrow the set, and it drains INLINE at most 100 shares per call, minting no mass-action row. It also requires confirmation_count equal to the active-pinned pagination.total_count search_account_shares reports for the same filter; anything else is 409 confirmation_count_mismatch. Single-sid mode ignores it. ASYNC: the call stamps status closin…

Open the canary gate by hand: stamps canary_satisfied_at and releases every remaining item, the same sweep the canary would have triggered by succeeding. Use it when the first item failed for a reason you accept, or when you do not want to wait for it. Valid only while the run is live, canary_mode=first_item and the gate is still closed, else 409 invalid_transition. Releasing a PAUSED run stamps the gate but dispatches nothing until resume_mass_action: the pause dominates. A canary_failed run nobody decides on for 7 days (retry, release or delete) settles itself: its pending items are cancelle…

Remove add-on units from the subscription, effective next period (no refund, no immediate charge). Pass quantity to give back part of the line, or omit it to drop the whole line; result.remaining_quantity reports what is left (0 means the line is gone). The price_sid must be a live item on this subscription (422 addon_not_on_subscription otherwise). Works while a cancel or pause is scheduled. A give-back Paddle did not confirm (its answer lost, or a 5xx) is 409 billing_change_unconfirmed: read the subscription again before repeating it. DANGEROUS state change (server-side confirm gate). Requir…

Disconnect a 1st-degree connection on LinkedIn (outward, destructive). Dispatches the remove-connection browser verb (networking_general bucket); on terminal success the local row is soft-deleted (removal_kind=removed) and linkedin-connections.removed is emitted. Identify the connection by its ln_cn_ sid.

Remove one or more members from a group thread on LinkedIn (outward action). Pass the conversation sid + participant_ln_ids (1..20 bare LinkedIn profile ids, the ACoA... ln_id; never a urn: string, the SDK wraps the id itself). item is the stored thread as it was before the call (the participant list follows on the next inbox sync); result carries status success and the activity_log_sid of the call. A LinkedIn refusal is a typed error (409 linkedin_refused, or the account-level 409 / 422 codes), never a success with a failed status.

Rename a group thread on LinkedIn (outward action). Pass the conversation sid + the new title (1..256 chars). Group threads only: LinkedIn refuses a 1:1 thread, and that refusal is a typed error (409 linkedin_refused), never a success with a failed status. item is the stored thread as it was before the call (the title follows on the next inbox sync); result carries status success and the activity_log_sid of the call.

Force a re-issue of an existing certificate, ignoring the 30-day expiry window (operator-forced). ASYNC: same HTTP-01 path as issue and the auto-renew job, on the same row. On an active certificate the row STAYS active (it keeps serving and routing) while challenge carries the attempt: on success the persisted leaf / full chain / key are replaced and issued_at / expires_at re-stamped, on failure last_error is set and the current certificate keeps serving. On a pending/failed/expired row nothing is serving, so it flips status→challenge and ends active or failed like issue. Poll get_ssl_certific…

Rotate an antidetect browser onto another MANAGED proxy of the SAME country. Geo-binding is preserved, so this is the safe way to drop a flagged IP. Omit antidetect_browser_proxy_sid to take the least-loaded active proxy of that country, or pin one (a pin from another country is refused, 422 proxy_country_mismatch). Platform-owned browsers only, 422 managed_proxy_forbidden_for_owner; a platform row that never got a proxy is 422 proxy_not_managed; a country with no other active proxy is 422 proxy_replacement_unavailable. A running browser is stopped and started again so the new IP takes effect;…

Put the deliveries a broken endpoint left behind back on the wire: every webhook_logs row of this webhook created inside [from, to] whose status is in statuses (default failed + cancelled; success re-fires delivered events, opt-in) goes back to pending, oldest first, one row per second, and the normal scheduler delivers it under the same webhook_log_sid. Cancelled rows come back only when the platform cancelled them (webhook_failed / webhook_disabled / webhook_deleted), never an operator's manual cancel; rows in flight are never touched. from is required; the window spans at most 30 days and o…

Description is built at runtime.

Get a place for ONE image or video file, then pass its file_url to create_linkedin_post (images[].url or video.url) instead of base64. In a chat without HTTP (the user pasted or has the picture): give the user upload_link, ask them to open it and drop the file, and call create_linkedin_post with file_url once they confirm. With a shell: run the curl line (upload_link, replace <path>). Pass file_type to also get a pre-signed S3 POST form (upload). Never type base64 of a pasted image: the model sees pixels, not the file, and the bytes come out wrong. The link works once for 30 minutes, up to 35 …

Re-roll the one-time code on a pending invite, push its expiry (+7d), and re-send the invite email. Only valid on a status=invited row (else 409 invalid_transition).

Clear OUR platform-side pause (hold_till = null) on one row. On a spent budget (done_today_count >= daily_limit) the saturation latch re-holds at once, so this is a no-op that stays held: the cap has to grow first. On a HAND-MANAGED account (smart_limits_enabled false) prefer update({daily_limit:<higher>, reset_hold:true}), which raises the cap and resumes atomically. On a GOVERNED account (the default) daily_limit is the warmup's and cannot be raised by hand: target_limit only bounds the cap, the warmup ceiling grows with account age and sent activity across snapshots, and the ramp lifts the …

Reset one or more sync tracks for the account and re-run them from scratch. ASYNC: returns pending refs to poll; DESTRUCTIVE: discards sync cursors.

Resume a paused subscription; billing continues from the next period and the applied team re-derives active. DANGEROUS state change (server-side confirm gate). No charge. The committed status arrives via webhook. Requires billing.manage.

Re-arm a paused collector: status becomes active, paused_reason clears, consecutive_failures resets to 0 and next_run_at is set to now, so the next scheduler tick mints a run. Works on any paused job, including a paused one-shot (a repeat pass is cheap because identity dedup makes it near zero new). 409 invalid_status_transition when the job is already active: an exhausted one-shot stays active with a null clock, and resuming it is exactly how you run it again.

Unfreeze dispatch: status becomes active, paused_reason and hold_till are cleared, and pending items are re-planned onto a fresh jitter chain from now. Items that deferred mid-cascade restart at their current step, so completed steps are not re-run. Does NOT touch the canary gate: after a canary_failed pause only the retried canary dispatches, and release_mass_action_canary is what opens the gate. Resumed before its hold_till, a limit_reached run holds again at the first item the budget refuses. 409 invalid_transition if the run is not paused.

Re-enter FAILED items of a mass action AT their current_step: completed steps never run again, their step_log entries and minted objects stay. Target EXACTLY ONE of sid (ma_im_…) or filter (both or neither: 422 sid_xor_filter_required); the filter arm is not parent-scoped, so pass mass_action_sid unless you mean every run. Per item: status pending, retry_count++, the error, timings and wait_reason cleared; parents settle again when drained. Only failed items match (retried_count 0 is not an error), 10 retries each at most, never an item of a deleted run or a cancelled one: by sid 422 retry_lim…

Manually re-arm a webhook delivery row: flips status to pending, sets scheduled_at=now(), clears cancel_reason. retry_count stays (it counts executed attempts, a re-arm is not one). error_message is preserved (cleared only on the next successful terminal outcome). Allowed from every state but in_progress (409 lease_in_progress), cancelled included whatever the reason; rejected on a soft-deleted / disabled parent webhook (422). Many rows at once: replay_webhook on the parent, paced. Pass expected_status for a CAS write (409 on mismatch). Re-delivers to the integrator; state-changing.

Give a borrowed account back early. Holder side. Same shape as recall_account_share: EXACTLY ONE of sid (ac_sh_) or filter, filter mode server-pinned to status active, drained INLINE at most 100 shares per call with no mass-action row minted, and confirmation_count required with filter and matched against the active-pinned pagination.total_count of list_received_account_shares (409 confirmation_count_mismatch otherwise). The difference is the side: the filter resolves over the loans you RECEIVED, and a share you do not hold is 403 not_share_holder. ASYNC: it stamps status closing, then the dri…

Revoke a cloud-browser access key on a browser. Pass the cb_ak_ key to revoke one; omit key to revoke EVERY key on the row. Only removes the key; live cloud-browser sessions are not force-disconnected. DANGEROUS: cuts off remote access.

Disconnect an app: flip the grant to status=revoked, clear its refresh credential, and cascade-revoke every installation token (all teams) in one transaction, so the agent is cut off immediately. The envelope item is the post-action grant (it persists, revoked); result.revoked_sessions is the count cut. Idempotent (already-revoked → 0). 404 if the sid is not the caller's own grant.

End a session immediately: status active → revoked. The token is rejected from the next request (verifier cache flushed within 30-60s). This is the canonical "delete" for this entity; there is no delete tool. Idempotent: revoking an already revoked/expired session returns the row with result.already_revoked:true.

Swap the key's secret IN PLACE and return the new plaintext in result.plaintext_token EXACTLY ONCE: hand it to the user, never log it, unrecoverable. The key's sid / name / permissions / expires_at are unchanged. The previous secret stays valid until result.previous_token_expires_at (now + grace_seconds, default 24h) so the agent can update config without downtime. Use when a secret leaks or before offboarding. NOT idempotent: each call mints a brand-new secret. Rotating a revoked/expired key → 409.

Start an antidetect browser session by sid. Two-phase: transitions to queued_to_start, dispatches to an automation server, then settles into initializing / running / start_issue. Identify the browser by its ab_br_ sid in the body.

Mint a manual run immediately, off schedule, and return its run_sid in result. Asynchronous: a worker drives the page loop, so poll get_linkedin_auto_scrape_run for status, new_count and enrolled_count. Use when the operator will not wait for the next slot. Only one run may be in flight per collector: 409 run_in_progress while one is pending or in_progress, and 409 auto_scrape_not_active on a paused job (resume it first).

Build the LinkedIn URL of a people or company search, regular or Sales Navigator, from that search's filters: send exactly ONE of people / sales_nav_people / companies / sales_nav_companies. Facet values take an id or plain text; each text is resolved by the search's own typeahead (the option labelled exactly so, else the first; a multi-word miss is retried by its first word), at most 10 lookups per call, each a paced scraping read (Sales Navigator ones need an SN seat). A text nothing matches is a 422 naming the closest options, except on Sales Navigator titles and companies, where it stays f…

Sales Navigator’s decision-makers panel for ONE company: the bounded, seniority-weighted leadership/buying-committee list SN computes, in the Sales Navigator row shape (position, company, region, degree, seniority, tenure, About text, badges). SN-capable executor required.

List the people currently working at ONE company (the company page’s "employees" people-search, page-numbered). Heavy, page-numbered list.

Direct LinkedIn read (bypasses our DB): one page of the REPLIES under ONE comment, live, the half scrape_linkedin_get_post_comments cannot read (its wire fetches no replies; replies_count there is a count). Same row shape as the comments read: the reply AND who wrote it (content, posted_at, comment_permalink, reactions_count + member id, nickname, name, headline), annotated with is_own. Target the comment by its urn as the comments read returns it in comment_ln_id (urn:li:comment:(activity:<postId>,<commentId>)), or in LinkedIn's fsd form (urn:li:fsd_comment:(<commentId>,urn:li:activity:<postI…

Direct LinkedIn read (bypasses our DB): one page of the COMMENTS on ONE post, live. This is the only comments read there is - a row carries the comment AND the person who wrote it (content, posted_at, comment_permalink, reactions_count, replies_count, is_pinned, is_edited + member id, nickname, name, headline), annotated with is_own, so reading "what was written" and "who commented" is a single call and never two. Target any post by URL, activity URN, or the backend urn a company-page post / newsletter issue / group thread carries (share, ugcPost, groupPost) in post. Top-level comments only: r…

Direct LinkedIn read (bypasses our DB): live pull of who is reacting to ONE post - or ONE COMMENT - right now, as transient reactor objects with reaction_type in OUR write vocabulary (interested = the event-post reaction), annotated with is_own. Target a post by URL or urn in any family (activity, share, ugcPost, groupPost) in post, or target a comment by its urn (either form: urn:li:comment:(...) or the fsd urn:li:fsd_comment:(...)) to read the comment's reactors. LinkedIn files a post's reactions under its social thread, which is the ugcPost or groupPost urn for those posts and the activity …

Direct LinkedIn read (bypasses our DB): live pull of the profiles that RESHARED one post, the third and typically highest-intent leg of the engagement trio. Targeting mirrors the reshare feed's own grammar (2026-08-21): a post URL, an activity URN, or a backend urn:li:share: / urn:li:ugcPost: urn verbatim - NOT urn:li:groupPost:, which is refused 422 reshare_target_unsupported (a group post has no reshare feed). is_own annotated. When exposed, resharer_commentary carries the added text and reshare_urn is the reshare’s own activity URN (feed it back into get-post-comments / -reactors). One wire…

Facet-id typeahead for the REGULAR (non Sales Navigator) search: turn a human term ("United States", "SaaS", "Acme") into the id a filter member needs. One type per call, and the type picks the member: people → followers_of, connections → connections_of, location → locations, company → current_companies, industry → industries, service_category → service_categories. Rows are the dropdown itself, best match first, about ten of them, with no paging and no size knob. An empty rows list means the dropdown offered nothing for that term, which is an answer, not an error. It types into the account's a…

LinkedIn Recruiter facet-id typeahead: resolve one Recruiter search facet (type) for a typed query into the ids the scrape_linkedin_search_recruiter_people filters take (urn:li:ts_*:N; the lowercase language name for spoken_languages). A THIRD id space: neither the flagship nor the Sales Navigator lookup ids fit here. Eleven kinds, all text facets (query required); LinkedIn answers a fixed 10. Needs a Recruiter-seat executor. Costs a scraping-bucket slot per call.

Sales Navigator facet-id typeahead: resolve one SN facet (type) into the opaque ids the SN search filters need. type is a node salesApiFacetTypeahead kind passed through verbatim; the seven text facets resolve query, the rest return their fixed / account-scoped list. Type → target filter member: TITLE → current_titles/past_titles; BING_GEO → locations/company_headquarters; INDUSTRY → industries; COMPANY_WITH_LIST → current_companies/past_companies; GROUP → groups; SCHOOL → schools; CONNECTION_OF → connections_of; ACCOUNT_LIST → account_lists (company search). Skip it for the static kinds (COMP…

One page of a regular LinkedIn company search, addressed EITHER by `filters` (keywords, geo ids, industry ids, headcount buckets) OR by a pasted /search/results/companies/ `url`: exactly one of the two, never both, never neither. Rows are company previews, not people, carrying the card's industry, followers (LinkedIn's rounded count) and location next to the identity. Same engine and the same company rows either way; page on with paging.has_more. For revenue, growth, follower, Fortune and buying-signal facets use scrape_linkedin_search_sales_nav_companies instead: this engine has none of them.

One page of a LinkedIn LEARNING course search, the sixth row kind here: `filters` OR a pasted /search/results/learning/ `url` (that screen, NOT /courses/), exactly one of the two. filters is a REQUIRED keywords plus two closed vocabularies, difficulty and time_to_complete, whose snake_case values the NODE maps onto LinkedIn's own labels, so never send a label yourself; the screen's software and subject facets need the url form. Rows are courses keyed by course_slug (this wire has no numeric id), with a tracking-free /learning/ URL, title, instructor, a normalised duration, the release and view…

One page of a LinkedIn EVENT search. `filters` carries keywords and NOTHING else (this engine has no location, date, type or organizer facet, and any other key is refused by name), so a pasted /search/results/events/ `url` is the only way to any facet the events screen itself offers: send exactly one of the two. Rows are events keyed by event_ln_id, with a tracking-free /events/ URL, title, the date and location lines as printed, the organizer when the card names one, the blurb, the attendee counter (0 is real, null is unread) and a cover image. The English dependency is PARTIAL: rows still co…

One page of a LinkedIn GROUP search, the fifth row kind on this surface. `filters` carries keywords and nothing else, exactly like the events search, so a pasted /search/results/groups/ `url` is the only way to anything the groups screen offers beyond a keyword: send exactly one of the two. Rows are groups keyed by group_ln_id, with a /groups/ URL, the name, Public or Private, the member counter both as printed and parsed (0 is real, null is unread), a best-effort blurb and a logo. WARNING, the English dependency is TOTAL, worse than the jobs search: the name is read out of English UI copy and…

One page of a LinkedIn JOB-POSTING search, addressed EITHER by `filters` (keywords is REQUIRED here, which no other engine on this surface demands) OR by a pasted /jobs/search-results/ `url`, which is the only way to hybrid or on-site work, several locations, a radius around one, verified jobs and the other facet segments LinkedIn ships: exactly one of the two. Rows are postings keyed by job_ln_id, with a tracking-free /jobs/view/ URL, title, hiring company, location plus workplace_type, listing age, the salary line as printed, and the Easy Apply / early-applicant / verified flags. Card text i…

One page of a regular LinkedIn people search, addressed EITHER by `filters` OR by a pasted search `url`: exactly one of the two, never both, never neither. Use filters when the agent composes the search itself, url for a search already built in the LinkedIn UI or for anything the filter vocabulary cannot express. Same engine and the same person rows either way; page on with paging.has_more. Rows carry the card's headline, location and degree badge next to the identity (position / company_name are Recruiter-only). commercial_use_limit_hit true means LinkedIn's monthly search paywall fired and r…

LinkedIn content search: find POSTS by keywords, recency or author. The discovery front door for post-engagement plays (feed the returned post_ln_id into the commenters / reactors / resharers tools). Addressed EITHER by `filters` (keywords REQUIRED) OR by a pasted /search/results/content/ `url`, which the node parses back into the same filter object: exactly one of the two, never both, never neither. CURSOR paginated, unlike every other search here: feed paging.next_cursor back verbatim and size the page with page_size. A page is the end only when LinkedIn itself answers that the window is emp…

One page of a LinkedIn PRODUCT search, the seventh row kind here: `filters` OR a pasted /search/results/products/ `url`, exactly one of the two. filters is a REQUIRED keywords plus a one-way free_version toggle and two arrays of digit-string ids that come from DIFFERENT places: product_category from param-id-lookup type=product_category, product_company from the ordinary organization id space. Nothing reconciles them, so a swapped id returns an empty page, not an error. Rows are product pages keyed by product_slug (the wire calls it product_id, but it is a slug and must never be sent back as a…

One page of a LinkedIn Recruiter (talent) people search, by a structured filters object (the Recruiter facets: titles, skills, companies, locations, postal codes, industries, education, languages, seniority, function, company size and type, year sliders, network, open-to-work) OR by a pasted Recruiter search url. A Recruiter URL carries no filters, only the searchHistoryId of the search LinkedIn keeps on the seat, so the url half replays that stored search on your page; every answer returns search_history_id and search_url, so page 2 onwards is addressed by the URL alone. 25 hits a page, page …

One page of a Sales Navigator ACCOUNT search, the one engine here that filters on annual revenue, company and per-department headcount growth, department headcount, follower buckets, Fortune tier and buying signals (leadership changes, funding events). Addressed EITHER by `filters`, whose typeahead members take ids from scrape_linkedin_sales_nav_param_id_lookup while the static enums are inline, OR by a pasted /sales/search/company `url`: exactly one of the two. SN-capable executor required.

One page of a Sales Navigator people search: richer facets than the regular engine (seniority, function, tenure, headcount, company type), no commercial-use limit, SN URNs (sn_id) on the rows. Every row carries the lead's current position and company (with the numeric company_ln_id), region, degree, seniority, tenure, About text and Sales Navigator badges, read from the search page's own answer at no extra cost, and paging.total is LinkedIn's count of the search. Addressed EITHER by `filters`, which carry the COMPLETE SN facet vocabulary, OR by a pasted /sales/search/people `url`: exactly one …

One page of a LinkedIn SCHOOL search, the eighth row kind here: `filters` OR a pasted /search/results/schools/ `url`, exactly one of the two. filters is a REQUIRED keywords and NOTHING else, the same one-member shape the events search has, so every facet the schools screen offers lives only in the url form. There is NO school-id filter: the ids param_id_lookup returns for type=school fit nothing here. Rows are school pages keyed by school_slug (the wire calls it school_id, it is a slug, it can be URL-encoded, and it is not that lookup id), with a tracking-free /school/ URL, name, location line…

One page of LinkedIn's service-provider marketplace (freelancers and agencies), addressed EITHER by `filters` (keywords, LinkedIn's own numeric service-category and geo ids, connection degree, profile language) OR by a pasted /search/results/services/ `url`, which is how to reach anything those five cannot express: exactly one of the two. Rows are the same person previews the people search returns, because the services screen carries no ratings and no service labels in its results, only provider profiles.

LinkedIn’s "similar companies / pages people also viewed" list for ONE target company: lookalike account expansion. One-shot list.

LinkedIn’s "people also viewed" browsemap for ONE seed profile: lookalike expansion from a known-good persona. IMPORTANT: address by profile.nickname (the vanity slug) ONLY, because the wire navigates by vanityName, so a ln_id/sn_id URN is refused not_dispatchable (resolve it via enrich_linkedin_person_lite_profile first, then pass the nickname). Returns ~20 cards; rows carry ln_member_id + nickname + full_name + headline (no ACoAA id, no avatar, no degree). One-shot list (no pagination); limit caps the cards.

List the account shares your team ISSUED: accounts you lent OUT to another workspace. Sharing is TEMPORARY and revocable; permanent ownership transfer is a web-app-only flow with no MCP tool, so never offer this as a way to give an account away. This is also the polling surface, since there is no get tool and no /{sid} route: read one loan with filter { sid: { eq } } and watch status until active (the holder can work), failed (it never started, read failure_reason), or terminal recalled / returned. filter.owner_account_sid answers 'is this account lent out and to whom'; holder_over_slot finds …

List antidetect-browser runtime log rows for the team with filters, sorting and cursor pagination. This is the operational trail behind a browser's status (start/stop, runtime errors, proxy issues, logouts). Returns a counts block of predicate tallies; include[] can eager-load the antidetect_browser. Scope to one browser with antidetect_browser_sid.

List antidetect browser proxies (platform-wide pool) with filters, sorting and cursor pagination. Live proxies by default (filter {"deleted_at": {"is_null": true}}). Credentials (ip / port / username / password) are masked to null on this public read surface.

List antidetect browsers on the team with filters (name lookup via the vendor_name filter, eq/in), sorting and cursor pagination. Live browsers by default (filter {"deleted_at": {"is_null": true}}). Returns a counts block of predicate tallies; include[] can eager-load linkedin_account, antidetect_browser_proxy and antidetect_browser_logs. Use this to find a browser sid before run / stop / delete.

List the team's API keys for an access audit: which keys exist, what each can do (permissions), their status, when each was last_used_at and when each expires. Filter by status for live vs dead keys, by last_used_at.lt for stale keys to revoke at offboarding, or by expires_at for keys expiring soon. The secret is never returned (only token_prefix + token_last4). include:["metrics"] attaches per-key counts; page_size:0 returns counts only.

List the team's external API requests newest first: every call made with an api key or an OAuth client (your own calls included), as logged by the service that answered it, merged across id, linkedin and orchestration. One row per request: the client (key or OAuth client, with its name), the route and entity, the HTTP status and its family, the typed error it failed with (error_code, error_reason, error_cause), the account it named, the duration, the trace id. Use for "what did our agents do", "show the failing requests since noon" (filter status_family in [4xx,5xx]), "why are these all 429" (…

List the Paddle-synced product catalog (the base plan + add-ons) with filtering, sorting and cursor pagination. Filter by type to split plan vs add-on, is_active for the live catalog, or q for an infix match over name/slug. Each row carries the per-unit limits grant. Read-only: the catalog is authored in Paddle, never here. page_size:0 returns counts only.

List the caller's billing subscriptions: the ones they bought (owner = caller, including floating subscriptions applied to no team) plus the one applied to a team they can read. Filter by status, team_sid:{is_null:true} for floating, paddle_subscription_id:{is_null:true} for the internal sentinels (free/partner), or current_period_ends_at for expiry windows. include price / product / team / latest_transactions to hydrate context. page_size:0 returns counts only.

List billing transactions (invoices / charges) for the caller: one row per Paddle transaction, newest first. Filter by status / origin / collection_mode / currency / billed_at window, or locate one by invoice_number. include subscription / owner / team to hydrate context. Read-only, append-only ledger; page_size:0 returns counts only. Requires billing.view.

List cloud-browser sessions on the team with filters, sorting and cursor pagination. This is the audit trail of who connected to which browser, from where, and how each login attempt resolved. The smart-link access_key is redacted to cb_ak_ followed by asterisks and the key's last 4 characters, so a session can be attributed to one of the browser's access keys without exposing a redeemable token; it is null only when there was no key at all (an internal session). It is not a public filter.

List/filter the request history: what was asked, where it ran, what came from cache. The go-to tool for retry forensics (idempotency_key:{eq}), per-person request history (ln_member_id:{eq}) and mid-flight visibility (status:{in:["pending","running"]}). This is a read-only ledger. To RUN scraping/enrichment call the linkedin-scraping / linkedin-enrichment surfaces instead.

Search the gtm-api.com product knowledge base (help articles + Q&A). Returns the most relevant article chunks with title, section and content. Query in ENGLISH, phrased in help-article wording (e.g. "connect LinkedIn account antidetect browser", "smart limits warmup"). Read ALL returned chunks: answers are often assembled from several. Knowledge only, no account data: pair with platform tools for the user's own state.

List activity-log rows, one per plugin call (Task↔Result cycle): pending on dispatch, then success / failed / skipped. Use for: "why is account X failing" (status:failed + created_at window, read error_message/error_code), inspecting in-flight pending tasks, cross-referencing a Grafana trace_id, and polling an MCP-triggered async action by sid until status flips terminal. NOT for LinkedIn quota hits (linkedin-account-quota-hits), the rolling limit count (linkedin-account-smart-limits), or account state (linkedin-accounts). No q. Sort: created_at (default desc) | duration_ms. include[]: linkedi…

List per-target block observations for the team: one permanently-deduplicated row per (account, target) whenever a target profile blocked one of our accounts (established by the §5.6 check-target-block). Use for: "did target X block any of our accounts" (filter target_ln_member_id, no account filter → crosses the team), churn caused by blocks (include linkedin_connection), a hostile-segment trend (created_at window + total_count), reverse-lookup from a failed activity_log row or a soft-deleted connection. NOT for platform-wide locks (weekly cap / InMail rate-limit → linkedin-account-quota-hits…

List LinkedIn-side block events (weekly connection-request cap, InMail rate-limit, a 429 on any action bucket, …) for the team: immutable, append-only, one row per (account, reason, bucket) per 12h dedup window. Use for: "is this account currently locked" (linkedin_quota_hit_till: { gt: "<now>" }), block-frequency trend, and "at what action volumes do blocks happen" (read the daily_count distribution). include[] linkedin_account / linkedin_account_snapshot correlate the block with account state at hit time. NOT for setting/clearing a lock (that lives on linkedin-account-smart-limits.linkedin_q…

List per-limit_type policy rows (one account owns 15 public buckets: send_connection_requests, send_messages, send_inmails, scraping, enrichment, custom_request, …) with filters, sorting, cursor pagination and a counts block (status / limit_type breakdowns). Whether the warmup governs a row is the ACCOUNT's smart_limits_enabled, not a row field. Use for: "which limits are at their daily cap / held / blocked by LinkedIn" (status filter; held means the daily budget is spent), "can account X still send InMails today" (filter linkedin_account_sid + limit_type, read status + daily_limit − done_toda…

Per-account warmup snapshots over time (immutable, append-only, captured ~every 22h by the scheduler). Use for: a warmup trend over N days (filter linkedin_account_sid + created_at range), before/after compare (paused automation, rotated proxy/nickname), and reading warmup_breakdown + tips to explain WHY a warmup_score is what it is (score = round(100 × ∏(1 − penalty_pct/100)) over 6 compounding drivers). For the LATEST snapshot per account use linkedin-accounts.search with include[]=linkedin_account_snapshot (1:1); searching here for the latest is more expensive. No q (no text-searchable fiel…

List sync runs: the backend-owned progress tracker for one paginated sync of one data surface (connections, connection_requests, connection_invitations, conversations, sales_navigator_conversations, followers) or a §5.7 composition (snapshot, premium_check). Use for: "is account X fully synced / how far along" (filter linkedin_account_sid + status in [pending, in_progress]), "which accounts are stuck mid-sync" (status in_progress, sort last_progress_at), "how fresh is the connection data" (latest completed connections run → finished_at). Runs are not created here; the write surface is linkedin…

List LinkedIn accounts (senders) on the team with operator filters, sort and cursor pagination, plus an always-present counts block (total, premium / SN / Recruiter, active_today, stale, signed_out). Also the way to find an account sid before calling account-scoped tools. For ANY health or availability question, request include antidetect_browser: login state lives on the bound browser row, whose status login_issue means the sender is signed out of LinkedIn. The item status field is platform lifecycle and stays active through a logout, so never read it as health. counts.signed_out_count flags …

Read the leads a collector has captured: one row per unique person or company, deduped across every run, each carrying flat identifiers plus the latest payload (name, headline, location, industry). Use for: the whole registry of a job (filter linkedin_auto_scrape_sid), the fresh delta of one run (first_seen_run_sid, the ingest path once a run completes), is this person already collected (parent sid plus ln_member_id or company_ln_id), and which leads keep re-appearing (seen_runs_count gte 3). page_size 0 returns counts.total_count, which IS the unique-lead count because dedup is built into the…

List executions of the collectors: one row per pass of one auto-scrape page loop, with its page progress and its delta (new_count, seen_count, enrolled_count). Use for: the history of one job (filter linkedin_auto_scrape_sid, sort run_number desc, page_size 1 for the latest), why collection stopped (status failed, then read error_message), which runs produced (sort new_count desc), and which fed a mass-action (mass_action_sid). NOT for the leads themselves (search_linkedin_auto_scrape_results on first_seen_run_sid) and NOT for starting a run (run_linkedin_auto_scrape_now): runs are server-mint…

List the team's collectors: saved jobs that paginate one LinkedIn or Sales Navigator list surface on a cadence and file deduped leads. Use for: which collectors are live or paused and why (status, paused_reason), what a given account collects (linkedin_account_sid), which ones feed outreach (mass_action_sid, is_null:true = collect-only), what runs next (sort next_run_at asc), and which produce (total_new_results). NOT for the leads themselves (search_linkedin_auto_scrape_results) or for one execution (search_linkedin_auto_scrape_runs). q: substring of the title, the ln_as_ sid or the pasted so…

List inbound LinkedIn connection invitations we received, with filters (including an exact-match note filter; there is no free-text q on this entity), sorting and cursor pagination. Pending rows have removal_kind IS NULL; terminal rows are accepted / ignored / expired (deleted_at set). include[] can eager-load linkedin_account.

List outbound LinkedIn connection requests (invitations we sent) with filters, sorting, cursor pagination and filter.q, a LIKE (substring) over the note. Pending rows have removal_kind IS NULL; terminal rows are accepted / withdrawn / expired (deleted_at set). include[] can eager-load linkedin_account.

List an account's 1st-degree LinkedIn connections with filters, sorting, cursor pagination and filter.q, a LIKE (substring) over the contact name. Live rows by default (filter {"deleted_at": {"is_null": true}}); pass {"deleted_at": {"is_null": false}} for churn analysis. Returns a counts block of predicate tallies; include[] can eager-load linkedin_account, the source request/invitation, conversations and last_messages.

List LinkedIn message threads for the team across both messenger surfaces (basic LinkedIn + Sales Navigator) with operator-object filters (account, contact ids, conversation_hash = LinkedIn's own 2-…== thread id, messenger_type, event-count, activity / message-sync clock ranges), sort, cursor pagination, and include[] for the parent account and the last 50 messages. Live rows by default; page_size:0 for count-only. Given a thread id by the user, look it up with filter.filter {"conversation_hash": {"eq": "<hash>"}}: q is a nickname LIKE and will not find it.

List stored followers of team accounts with filters, sorting, cursor pagination and filter.q, a LIKE (substring) over the follower name. Returns a counts block. include[] can eager-load linkedin_account plus the funnel probes linkedin_connection / linkedin_connection_request; both absent means a warm, untouched prospect.

List LinkedIn messages (basic DM + Sales Navigator + InMail) with operator-object filters (account, conversation, channel, direction, contact ids, date ranges) and filter.q, a LIKE (substring) over body + subject (message text, not contact names). Supports include[], sort, cursor pagination. page_size:0 for count-only. To read a single message, filter by {sid:{eq:"ln_ms_…"}}.

Per-target drill-down of a mass action: one row per target with current_step, the object cursor (object_type / object_sid, on a generative run what the row created) and step_log[], one entry per plan step with status (running / deferred / succeeded / failed / skipped), executor_ref (the key a send step went out under, next to its doubt fields), created_object_sid for steps that minted one, and error_message. The last step_log entry says what failed and why, earlier ones what completed: a failed item keeps the effects of its finished steps (fail-forward), created_object_sid is the cleanup surfa…

List the team's bulk runs with filter, sort and cursor pagination. Filter by title (eq / in, or q to search it), status (active / paused), paused_reason, target_entity, canary_satisfied_at (is_null:true = the canary gate is still closed), or the created / updated / started / settled time ranges. status is a CONTROL axis, not an outcome: to learn how a run went call get_mass_actions_metrics or get_mass_action with include=metrics. Stopped runs are excluded unless deleted_at is filtered explicitly. page_size:0 returns the count alone.

List notifications (email and in_app channels) for the team/user with filtering, sorting and cursor pagination: the user inbox ("what was sent to me?"), admin audit ("what did the system email Jane about?"), or failure triage (status:failed in the last 24h). No full-text search. Returns a counts block of predicate tallies (by status / event_name / channel). Bodies are omitted from list rows; call get_notification for the rendered body. On gtm-api.com every row is channel email: the in_app channel, read_at and the mark-read verbs are a shared-contract surface the GetSales side writes, so read_a…

List the caller's connected apps (standing OAuth consent grants). Always scoped to the caller's own grants, never cross-user. Filter by status (active vs revoked history), oauth_client_sid, or team_scope_mode; include client (name + ceiling), teams (in-scope team names), and active_sessions (live installation tokens). This is the user's view of who has access to their workspaces. page_size:0 returns counts only.

List registered OAuth applications for the caller's team (plus platform clients when team_sid.is_null). Filter by status, client_id, registration_kind, is_confidential; include:["active_sessions"] to see the agents connected through each app (requires sessions.view). No full-text: filter by name / client_id. page_size:0 returns counts only.

List sessions. Default scope is the caller's own active sessions ("Active sessions"); pass kind:{eq:"oauth"} for "Connected agents", or status to see revoked/expired history. Each row carries the derived is_current flag (true for the caller's own request) so "log out everywhere except this device" can skip it. Returns a counts block. page_size:0 returns counts only.

List the team's TLS certificates for custom email domains: which domains are registered, each status, issuer, issued_at, expires_at, and the redacted last_error for failures. Filter by status for live vs failed, by expires_at:{lte} for certificates expiring soon, or by domain for a specific FQDN. The certificate body and private key are never returned. Returns a counts block of predicate tallies; page_size:0 returns counts only.

List the team's support escalations with filtering, sorting and cursor pagination: the ops view ("what escalations are open?", "did this session already escalate?"). Returns a counts block of predicate tallies (by status / reason). Bodies are omitted from list rows; call get_support_request for the full text. No full-text search.

List members and pending invites in the caller's team: render the Members tab, find pending invites (filter.user_sid.is_null or filter.status.eq="invited"), or look up a member by email (q). include:["user"] hydrates the resolved profile (absent for pending invites). Returns a counts block. page_size:0 returns counts only.

List the caller's teams ("my workspaces"): teams they are a member of, plus teams they own. Filter by status to find suspended workspaces, or by subscription_sid.is_null for teams with no capacity. q does an infix match on name. include[] hydrates subscription / owner / member counts. Returns a counts block. page_size:0 returns counts only.

List webhook delivery rows for the caller's team with filter, sort, include and group-counts. Deliveries from every producer service (LinkedIn, email, …) land in this one log; filter per webhook, per account_sid, per source_service, per event type, per HTTP code or status; include=webhook. Returns a counts block (groups by status / event_type / response_code / webhook_sid / account_sid). Use for delivery auditing and integrator-outage debugging. For period-bound success rates use get_webhook_logs_metrics; single-row lookup is a filter on sid.

List webhook subscriptions owned by the caller's team with filter, sort and cursor pagination. Filter by status, subscribed event types (events.contains / contains_any), account narrowing or name; include=latest_webhook_logs for the recent-delivery view. secret is masked (null) on every read. Use this to find a webhook sid before calling webhook-scoped tools.

Bind the account's browser to ONE of the member's Recruiter contracts (the contract chooser's Select, wire select-recruiter-contract) and stamp the seat that comes with it. contract_id is the ts_contract NUMBER from get_linkedin_account_my_recruiter_contracts, never a urn. Pick a CORPORATE row: the wrong row binds the browser to the wrong inbox, and a member on several contracts is exactly who this is for; the premium check never binds one by itself. A seat in the answer marks recruiter_status active. 422 contract_not_offered lists the rows on offer in context.offered; 422 contract_not_selecta…

Send one outbound LinkedIn connection request. Address the person by profile_id (ln_id or sn_id URN) or public_identifier (slug or /in/ URL). Checks: daily limit, note cap (200 free / 300 premium), 21-day resend cooldown. A row only when LinkedIn confirms. Sends once per client_reference and person: a repeat is answered, never sent twice; on a 409 read error.context.send_outcome, never resend under a new key. A request on record under another key or none: 422 resend_not_available, context.cause pending, accepted, cooldown (resend_available_at), sync_reset, or linkedin (LinkedIn alone holds the…

Description is built at runtime.

Description is built at runtime.

Description is built at runtime.

Description is built at runtime.

Description is built at runtime.

Set the private operator tag on one sender. `label` is team-authored free text (pod, campaign, owner) stored on the account row and visible only inside the owning workspace: LinkedIn never sees it and no recipient sees it. It is not the sender's name, which is LinkedIn's own (full_name) and is not editable by any tool. Send label to replace the tag, null to clear it; the key is required, so an empty call is a schema error. Filter on it with search_linkedin_accounts filter.label.

Add, edit or remove ONE position (work experience entry) on the connected account's OWN LinkedIn profile. No position_id = add (title, company_name and start_date required, end_date unless is_current). position_id = edit: send only the fields that change, the backend reads the position's form first and submits it whole (the LinkedIn wire replaces the form); is_current: true drops the end date, an end_date ends a current position. position_id + delete: true = remove it (the backend reads the form and mirrors it into the delete, as LinkedIn's own editor does). position_id is the numeric id each …

Create, update, republish or unpublish the connected account's OWN LinkedIn services page ("Providing services"): one tool, the page's state picks the LinkedIn action. No page yet: description and services (1..10 standardized-skill ids; get_linkedin_account_my_services lists the 16 top-level ones) are required and the page is created live with LinkedIn's onboarding defaults for what you omit. A page exists: send only what changes, the rest keeps its stored value; a page that was unpublished comes back on the profile with any save, and republish: true with no field does just that (LinkedIn has …

Switch smart-limit governance on or off for the WHOLE account, every bucket at once (no per-bucket toggle). The switch remembers nothing: a real flip in EITHER direction first resets every limit row to the platform defaults (daily_limit = the bucket's platform max, delay_in_seconds = the flat default, target_limit = the platform default, hold cleared). ON: the warmup then sets every row's daily_limit / delay_in_seconds (re-derived from the latest snapshot) and update_linkedin_account_smart_limit refuses those fields with 409 smart_limits_governed; target_limit and learning_enabled stay yours. …

Wire this collector to a mass-action: from the next run on, every newly discovered lead is appended to that run as one item, which is how collection turns into outreach. Author the run FIRST on the mass-actions mount (preview_mass_action, then create_mass_action, normally with scope kind none) and pass its ma_ac_ sid here. Slot semantics: an existing link is replaced and returned as previous_mass_action_sid, and that older run keeps draining what it already holds. A run in flight is unaffected, it keeps the link it was minted with. 422 when the mass-action is missing, foreign, deleted, or its …

Description is built at runtime.

Stop an antidetect browser session by sid. Default is graceful (queued_to_stop → stopped on the node teardown confirmation); now:true commits stopped immediately and dispatches a best-effort teardown. Identify the browser by its ab_br_ sid in the body.

Refresh the outbound sent-invitations snapshot for one account by inserting a sync_run (upsert-only). ASYNC: returns pending refs to poll or await the linkedin-connection-requests.sync-completed webhook.

Kick off a fresh inbound-invitations sync for one account by inserting a sync_run. ASYNC: returns pending refs to poll or await the linkedin-connection-invitations.sync-completed webhook.

Kick off a background connections sync for one account by inserting a sync_run. The pages add and update rows; a live row the run should have listed and did not goes to the check-target-block, whose read removes a severed edge (linkedin-connections.removed lands shortly after the run). ASYNC: returns pending refs to poll or await the linkedin-connections.sync-completed webhook. For an in-request head refresh use get_my_latest_linkedin_connections instead.

Start a background sync run that reconciles the full basic-LinkedIn-messenger thread directory for one account. ASYNC: returns a pending ref (sync_run_sid) to poll; changed threads have their messages pulled inline. Use for initial backfill / full reconciliation; for a fresh inbox head use get_my_latest_linkedin_conversations.

Start a background sync run that reconciles the LinkedIn Recruiter inbox (the talent mailbox a recruiter seat owns) for one account: messenger_type='recruiter' threads with the candidate's recruiter_id, their messages drained inline. ASYNC: returns a pending ref to poll. Needs a Recruiter seat on the account AND its stamped seat number (422 recruiter_required / recruiter_seat_unresolvable otherwise; check_linkedin_account_premium_subscription with checks: ['recruiter'] refreshes both). Walks the INBOX tab and then UNRESOLVED (a thread this seat opened sits there until the candidate replies), n…

Start a background sync run that reconciles the full Sales Navigator thread directory for one account. ASYNC: returns a pending ref to poll. Separate sync_type and cadence from the basic-LinkedIn sync so SN-only lanes never touch basic-messenger rate limits.

Synchronously POST a synthetic payload to the webhook target_url and return the receiver response (HTTP status, duration, error kind). Verifies endpoint health / signature handling without waiting for a real event; does NOT write to webhook_logs and does NOT affect the consecutive-failure counter. Allowed while status=failed (revival flow); rejected while status=off. Rate-limited to 10 calls/min per webhook. Outward live HTTP probe.

Move structural ownership of the team to another active member. Owner-only (an admin cannot transfer). Transferring to the current owner is a no-op. This is the only way to change owner_user_sid, and the prerequisite for the current owner to leave the team.

Detach a subscription from its team, returning it to floating on the buyer's balance. DANGEROUS: removes the team's capacity (the team goes suspended if this was its only applied subscription); does NOT cancel billing or refund. Used to move a subscription to another team. Requires billing.manage.

Drop a scheduled cancel before it takes effect; billing continues as if cancel was never asked. Decided on the live Paddle state: nothing pending is a success no-op (cleared:false), a scheduled pause or resume is refused with 409 scheduled_change_is_not_cancel naming the verb that clears it, and an already canceled subscription is too late to undo. Synchronous, no charge, no pending block. Also the unlock a 409 subscription_locked_pending_changes points at. Requires billing.manage.

Retract ONE skill endorsement this account holds on a 1st-degree connection (wire unendorse-skill, ?action=unendorse): the undo of endorse_linkedin_account_skill / endorse_linkedin_account_skill_by_id, addressed by the same skill_id. Spends the SAME endorse_skills bucket as the endorse it reverses (verb-pair rule; an undo is paced 2 s, not the bucket delay, so a do/undo pair fits back to back). Returns the echoed skill urn, endorsed_by_viewer (false after unendorse) and the global endorsement_count, plus the activity-log row. Retracting the LAST endorsement of a skill collapses its person-skil…

Stop following a LinkedIn member as this account, the inverse of follow_linkedin_member. NOT a disconnect: it leaves a 1st-degree connection intact and only stops that member's posts reaching the feed, so it is how you mute someone you still want to stay connected to. Severing the relationship is remove_linkedin_connection. IDEMPOTENT: unfollowing someone this account does not follow returns 200 with the same terminal state, so a repeat is a success, not an error, and it still spends one networking_general unit (40 a day, 180 s apart). Pass target.nickname whenever you know it, even alongside …

Remove OUR reaction from a LinkedIn post or comment, addressed by the same entity_urn react_linkedin_post took (wire delete-reaction). Undo a reaction left by mistake or by a play that has been retargeted. Takes no reaction_type: LinkedIn holds at most one reaction per account per entity, so removal is unambiguous. Identity-bound: linkedin_account_sid REQUIRED, spends the SAME react_posts bucket as reacting (30/day), but an undo is paced 2 s, not the bucket delay, so a reaction and its removal fit back to back; saturation returns 429. A post is addressed at its social thread exactly like react…

Cut the outreach wire: clear mass_action_sid so the collector goes back to collect-only from the next run. This does NOT stop the mass-action. Leads already enrolled keep running, and stopping them is delete_mass_action on the mass-actions mount. A run in flight keeps enrolling into the link it was minted with. 409 no_mass_action_set when nothing is linked. To point the collector at a different plan, call set_linkedin_auto_scrape_mass_action instead: it replaces the slot in one call.

Change the proxy of an existing antidetect browser, country included. Supply EXACTLY ONE source: antidetect_browser_proxy_sid, proxy_country_code or custom_proxy_config. EVERY arm needs browser_owner=platform: a profile bound by id keeps its proxy in the vendor (422 managed_proxy_forbidden_for_owner / 422 custom_proxy_forbidden_for_owner). custom_proxy_config is probed first (422 custom_proxy_unreachable_* changes nothing), takes the exit country measured there, and RELEASES any armed 5G slot. Zero sources 422 proxy_assignment_missing, more than one 422 proxy_assignment_conflict, empty pool 42…

Partial update of name / permissions / account_sids (the key's identity and secret are untouched; use rotate_api_key to change the secret). Each list is a FULL replacement, clamped to the STORED issuer's current authority on its axis (403, reason grant_exceeds_ceiling): permissions inside their token set, account_sids inside their slice (null = all accounts, grantable only under an unrestricted issuer slice). At least one field is required. A change takes effect at once: id tells every channel service to forget the key's cached verdict (a peer the fan-out cannot reach falls back to its 5-minut…

Patch the authenticated user's own profile: first_name / last_name / avatar_url / phone / timezone / country / config only. email (change-email flow), password (change-password flow), auth_provider, email_status and all sids are rejected if sent. At least one field required. config merges key-by-key. Same subject as get_current_user: an API key has no user to patch and answers 403 with context.reason=not_a_user_actor.

GATE: on a governed account (smart_limits_enabled true, the default) daily_limit / delay_in_seconds belong to the warmup; moving either is 409 smart_limits_governed: never promise a raised cap there. target_limit only BOUNDS (the row follows min(smart_limit, target_limit)): a target above the warmup ceiling changes nothing today; a young or dormant account sits at 1..2 for weeks (see warmup_breakdown). The other way: set_linkedin_account_smart_limits({enabled:false}), said out loud as removing ban protection. One row (daily_limit / target_limit / delay_in_seconds / learning_enabled; one field …

Set the account's weekly sync schedule: the timezone, the allowed per-weekday time windows, and per-track interval entries, each its track's floor or longer (15 minutes for an inbox, which is real-time mode: the browser stays awake inside the window; an hour for the rest; one below the floor is refused with 422). Replaces the stored sync_config wholesale (send the full desired config, not a delta). Returns the updated account. SINGLE account: to reschedule a fleet, author a mass action on /mcp/orchestration/mass-actions with the step `linkedin-accounts.update-sync-config` (scope objects) so th…

Patch a collector. Only title and replay_frequency are writable, and at least one must be sent (else 422 nothing_to_update). The source is immutable by design: a different source is a different collector, so create a new one. The outreach link moves through set_linkedin_auto_scrape_mass_action / unset_linkedin_auto_scrape_mass_action, and status through pause_linkedin_auto_scrape / resume_linkedin_auto_scrape. A cadence change re-plans next_run_at only when the clock is already armed; a run in flight keeps its claim and picks the new cadence up when it finalizes.

Partial self-service edit of the grant's mutable fields WITHOUT re-running the browser consent: team_scope_mode, consented_team_sids (full-replace, non-empty when mode=selected), and permissions (full-replace, must stay ⊆ the client ceiling). Each submitted team is re-checked against live membership (403 if not a member). Narrowing is security-positive; you can never exceed the ceiling via update. Changes are frozen-at-mint, so live tokens keep their claims until their short TTL; use revoke for an immediate cut. At least one field required. 404 if not the caller's own grant.

Partial update. Editable: name, redirect_uris, permissions, grant_types, status (redirect_uris / permissions full-replace). status:"disabled" cascade-revokes the client's oauth grants and issued tokens. Tightening permissions affects only future mints: live tokens keep their frozen set; use disabled / delete for an immediate cut. client_id / is_confidential / registration_kind are not editable. At least one field required.

Metadata-only partial update. No certificate-affecting field is mutable here: domain, status, challenge, issuer and validity are driven by the ACME actions and jobs, never by update. v1 has no client-mutable field, so any body returns 422 nothing_to_update; the endpoint exists for surface symmetry.

Rename a team or edit its config. Only name / config are mutable; owner_user_sid (transfer-ownership), status (derived), subscription_sid (apply/unapply) and limits (system) are read-only and silently rejected. At least one field required.

Re-scope an existing member: replace permissions and/or account_sids. email / status / user_sid / team_sid are read-only (rejected silently). At least one field with an ACTUAL change required (a value-identical PATCH answers 422 nothing_to_update). The change applies immediately: the member's live tokens are invalidated and re-minted with the new grant on their next request (agents re-exchange). Bounded by the caller's own grant (403 grant_exceeds_ceiling); the structural owner's seat is not re-scopable (409 owner_cannot_be_rescoped - move ownership via transfer_team_ownership).

Patch a webhook. Editable fields: name, target_url, events, filters, status. status:'on' on a failed webhook resets the consecutive-failure counter and resumes deliveries, but re-issues nothing: the rows the disable cancelled come back with replay_webhook. status:'failed' cannot be set manually. events and filters are FULL replacements, not merges. secret is NOT writable here (rotation is admin-internal). State-changing.

Visit a target person's profile from this account (warm-up / signal action). Outward action on LinkedIn.

Withdraw a pending outbound connection request (outward, destructive). Dispatches the withdraw-invitation browser verb (networking_general bucket); on terminal success the row is soft-deleted (removal_kind=withdrawn) and a 21-day resend cooldown begins. Identify the request by its ln_cr_ sid.