Linxa MCP reference

50 tools for a controlled LinkedIn & CRM workflow

Linxa is the control plane behind your agent: it owns queueing, pacing, schedules, retries, CRM synchronization, and idempotency. Your agent decides with context; Linxa executes within the limits you approve.

Connect MCP Back to MCP overview

Connect your MCP client

Create a token in Linxa MCP Setup, keep it in your local environment, then follow the platform-specific instructions below. Every client connects to the same hosted Streamable HTTP endpoint.

About the guided-onboarding profileThe MCP server ships with a curated onboarding configuration profile. This profile is labeled for development use in the committed README and is not intended for production client setups. If you are configuring a production environment, use the standard token-based setup described below and ignore any onboarding profile references you encounter in the source.

Endpoint

https://app.uselinxa.com/api/mcp/rpc

Transport

Streamable HTTP

Authentication

Bearer token from Linxa MCP Setup

Keep the token private

Never paste a token into a chat, screenshot, repository, or shared project file. If it is ever shared, revoke it in Linxa MCP Setup and create a replacement.

Claude Desktop & Cowork

RecommendedOfficial platform docs ↗

Use a remote connector—there is no package to install and no local configuration file to edit. In Claude, open Settings → Connectors → Add custom connector.

Name it Linxa and paste this server URL: https://app.uselinxa.com/api/mcp/rpc.
Under Authentication, choose No sign-in. Linxa uses an MCP token, not OAuth.
Under Request headers, choose authorization. In the value field enter the full value below—including Bearer and the space.

Bearer <your Linxa MCP token>

Keep Required enabled, click Add, then click Connect on the connector page. A successful connection does not open an OAuth sign-in page.

In a new Cowork task, enable Linxa from + → Connectors. Keep write-capable tools on “Needs approval” while you get started.

If Claude says “Couldn’t reach Linxa”: remove the connector and add it again. Check that the header value begins exactly with Bearer ; a token by itself will not authenticate.

Claude Code

Tested on macOSOfficial platform docs ↗

Install Claude Code first if claude --version reports “command not found”. Node.js 18+ is required.

npm install -g @anthropic-ai/claude-code
claude --version

Set the token for this shell, then add Linxa in user scope. User scope makes it available in every local project; local scope only applies to the directory where it was added.

export LINXA_TOKEN=YOUR_NEW_TOKEN
claude mcp add --scope user --transport http linxa https://app.uselinxa.com/api/mcp/rpc \
  --header "Authorization: Bearer $LINXA_TOKEN"
claude mcp list

Restart Claude Code in the target project. Type /mcp to confirm that Linxa is loaded.

Codex CLI, IDE extension, or ChatGPT desktop

Official platform docs ↗

Codex clients on the same computer share ~/.codex/config.toml. Add this user-level configuration, then start or restart Codex with LINXA_TOKEN available in its environment.

[mcp_servers.linxa]
url = "https://app.uselinxa.com/api/mcp/rpc"
bearer_token_env_var = "LINXA_TOKEN"
default_tools_approval_mode = "writes"

export LINXA_TOKEN=YOUR_NEW_TOKEN
codex mcp list
codex

In the Codex terminal UI, type /mcp to verify the server. The writes approval mode keeps external actions behind a confirmation.

Cursor

Official platform docs ↗

Create ~/.cursor/mcp.json to use Linxa in every workspace, or .cursor/mcp.json for one workspace. Restart Cursor after saving.

{
  "mcpServers": {
    "linxa": {
      "url": "https://app.uselinxa.com/api/mcp/rpc",
      "headers": {
        "Authorization": "Bearer ${LINXA_TOKEN}"
      }
    }
  }
}

Set LINXA_TOKEN in the environment that launches Cursor. In Agent chat, open the MCP tools list and leave write tools set to request approval.

Kiro

Official platform docs ↗

Open the Kiro MCP panel and edit the global ~/.kiro/mcp.json, or a workspace .kiro/mcp.json. When prompted, approve LINXA_TOKEN in Settings → “Mcp Approved Env Vars”.

{
  "mcpServers": {
    "linxa": {
      "url": "https://app.uselinxa.com/api/mcp/rpc",
      "headers": {
        "Authorization": "Bearer ${LINXA_TOKEN}"
      }
    }
  }
}

Kiro hot-reloads MCP configuration. Check that Linxa appears in the MCP panel before using it.

OpenClaw

Official platform docs ↗

Set the token in the environment used by OpenClaw, register Linxa as a Streamable HTTP server, then probe it.

export LINXA_TOKEN=YOUR_NEW_TOKEN
openclaw mcp set linxa '{"url":"https://app.uselinxa.com/api/mcp/rpc","transport":"streamable-http","headers":{"Authorization":"Bearer ${LINXA_TOKEN}"}}'
openclaw mcp doctor linxa --probe

If the running OpenClaw process does not reload automatically, restart it after saving the configuration.

Read-only verification prompt

After the platform reports Linxa as connected, paste this into its chat. It confirms authentication without changing data.

Use the Linxa MCP tool linxa_get_user_settings. Show my current plan and settings. Do not perform any write actions.

Then try the compact inbox workflow. It should use one Linxa call and must not inspect every conversation:

Use linxa_get_next_actions only. Answer “What conversation needs my attention?” in at most 5 bullets. Do not call other Linxa tools or shell commands. Do not perform write actions.

Avoid the common setup failures

claude: command not found

Install Claude Code and confirm claude --version. Do not use sudo npm install -g.

Linxa is missing when Claude starts in another project

Remove the local entry and add it again with --scope user; then restart Claude Code.

Claude Desktop or Cowork says it couldn’t reach Linxa

Use No sign-in, then set the authorization request-header value to Bearer YOUR_MCP_TOKEN. The word Bearer and its trailing space are required. Do not use an OAuth client ID or secret.

HTTP 401 “Invalid MCP token”

The token is empty, expired, or copied incorrectly. Regenerate it in Linxa MCP Setup, export it in the current shell, remove the server, add it again, then run the platform status command.

The server connects but Linxa tools are missing or outdated

Start a new client session or restart the app, then inspect /mcp in Claude Code/Codex or the MCP panel in an IDE. Clients cache the tool catalog when a session begins, so reconnect after Linxa adds methods.

A token was pasted into a chat or committed

Revoke it immediately in Linxa MCP Setup, issue a replacement, then update the client’s private user-level configuration.

Preview before action

Use dry_run for supported writes. A preview is not permission to execute the external action.

Idempotent writes

Send a unique idempotency_key for each write. It is required when a sequence is started.

Status is the source of truth

Queued, drafted, and scheduled are pending. Say an invite was sent only when the status is delivered.

From a user request to the right tools

These are complete workflows, not single-method demos. The agent should keep exact IDs from one step to the next and stop for approval immediately before an external action.

“Show who engaged with my latest post and prepare a reply to this comment.”

The agent keeps the exact post and commenter IDs, shows the reply in full, and publishes only after the user approves the preview.

linxa_list_my_posts → linxa_get_post_engagement → linxa_reply_to_post_comment (dry_run) → explicit approval → linxa_reply_to_post_comment

“What conversation needs my attention?”

One Needs Attention thread, or ten recent follow-ups with due status when that folder is empty. No full-inbox dump.

linxa_get_next_actions

“Prepare replies to Akbar, Rajesh, and Ilija. Do not send.”

Names are resolved to exact conversation IDs and drafts are saved with conversation, product, stage, post, and comment context.

linxa_get_next_actions → linxa_prepare_replies → linxa_list_drafts

“Make Rajesh’s reply shorter and send the three approved replies.”

The edited draft is previewed in full. Only the approved conversation IDs are queued, with no implicit “send all”.

linxa_save_draft → linxa_send_drafts (dry_run) → linxa_send_drafts → linxa_get_action_status

“Get the ICP for my product URL, but only fill missing pain points and value proposition.”

Selective sections reduce model work and missing_only preserves product rules that are already populated.

linxa_create_product → linxa_generate_product_rules

“Find people interested in this service URL and prepare an invite, first message, and three follow-ups.”

A source-bound audience and reviewed sequence are prepared. Invitations or messages do not start until explicit approval.

product → rules → search → search status → leads → sequence → audience → start preview

“Pause the sequence, change follow-up two, and resume it.”

Unstarted queued messages are cancelled on pause; the edited version is previewed before delivery resumes.

linxa_pause_sequence → linxa_get_sequence → linxa_update_sequence → linxa_start_sequence (dry_run) → linxa_start_sequence

“Show our open deals in the Growth pipeline and move Acme Corp to Negotiation.”

The agent discovers the pipeline and stage IDs, fetches the bounded open deals page, inspects the target deal’s expected_updated_at timestamp, and moves the stage only after explicit approval.

crm.list_pipelines → crm.list_deals (pipeline_id, status="open") → crm.get_deal → crm.move_deal (explicit approval)

“Check if Linxa suggested any deals from replied conversations, and confirm Jordan.”

The agent inspects AI-suggested deals for the pipeline, displays candidate details, and promotes the suggestion to an active stage with a unique request_id upon user confirmation.

crm.list_pipelines → crm.list_deals (pipeline_id, status="suggested") → crm.confirm_suggestion (explicit approval)

Tool reference

Read tools can be called directly. Preparing or editing a draft does not send it. Review proposed content and obtain explicit approval immediately before an external action or CRM mutation: enabling autopilot, starting a sequence, sending approved drafts, scheduling a message, sending a notification, queuing an invitation, or mutating CRM deals (creating, moving stages, reassigning, commenting, confirming, or rejecting).

Posts and engagement signals

Read your own posts and their audience, then publish a new comment or an exact reply only after a dry-run preview and explicit approval.

linxa_list_my_postsRead

Input: Optional: limit (1–50), offset (0–1000)

List the token owner’s stored LinkedIn posts with content, media, engagement counts, and sync status.

linxa_get_post_engagementRead

Input: post_id

Read the people who reacted or commented on one owned post, including comment text and whether the owner already replied.

linxa_comment_on_postExternal action

Input: post_id, text; dry_run, then approval_token and idempotency_key

Preview and publish a top-level comment on one owned LinkedIn post. Show the exact text and post before requesting approval.

linxa_reply_to_post_commentExternal action

Input: post_id, profile_id, text; dry_run, then approval_token and idempotency_key

Preview and publish a reply to one exact commenter on an owned post. The server blocks duplicate replies already recorded by Linxa.

Inbox, replies, and action status

Find the conversations that matter, prepare grounded replies, and send only the exact drafts the user approved.

linxa_get_next_actionsRead

Input: None

Return the newest Needs Attention conversation with its Smart Inbox link. If that folder is empty, return ten recent Need Follow Up items with due status and a recommended-for-reply flag.

linxa_list_conversationsRead

Input: Optional: limit, label, search

List or search inbox conversations.

linxa_get_conversationRead

Input: conversation_id

Read the complete message thread for one conversation.

linxa_get_conversation_contextRead

Input: conversation_id; optional include_messages, include_recent_posts, include_private_comments, post_limit

Load the owned thread, relationship stage, product, recent recipient posts, private comments, and a context version in one call. Use this for custom reasoning; normal replies should use linxa_prepare_replies.

linxa_get_profile_postsRead

Input: conversation_id; optional limit

Read recent posts from the participant in an owned conversation for optional personalization.

linxa_list_commentsRead

Input: conversation_id

Read private Linxa comments for one owned conversation.

linxa_get_repliesRead

Input: Optional: since

Retrieve recorded LinkedIn replies.

linxa_get_action_statusRead

Input: action_id

Read the state of an invite, queued message, draft, lead search, or sequence action.

linxa_get_user_settingsRead

Input: None

Read the current plan, timezone, LinkedIn-session state, and Telegram connection state. It does not return usage quotas.

linxa_add_commentWrite

Input: profileId, comment

Add a CRM-style note to a lead.

linxa_mark_as_readWrite

Input: chat_id

Mark an inbox conversation as read.

linxa_prepare_repliesWrite

Input: conversation_ids; optional type, instructions, force_regenerate, allow_no_further_contact, allow_early_follow_up, dry_run

Reuse the Smart Inbox Next Message pipeline to prepare and save drafts for 1–10 exact conversations. It blocks no-further-contact and early follow-ups unless explicitly overridden, and never sends.

linxa_list_draftsRead

Input: Optional: conversation_ids, limit, cursor

List saved Smart Inbox drafts, including staleness and context-version information. The default is the ten newest.

linxa_save_draftWrite

Input: chat_id, text; optional scheduled_at, dry_run

Save or replace the draft for one exact owned conversation. Use it after custom editing.

linxa_delete_draftWrite

Input: chat_id; optional dry_run

Delete the unscheduled draft for one exact owned conversation without deleting the conversation.

linxa_send_draftsExternal action

Input: conversation_ids; dry_run, then approval_token and idempotency_key

Preview recipients and full texts, then queue only the exact approved drafts. Approval expires after 15 minutes and any draft change invalidates it.

linxa_notifyExternal action

Input: message

Send a Linxa notification through the configured channel.

linxa_inviteExternal action

Input: profileId; optional text, comment

Queue a LinkedIn invitation for an eligible profile.

Products and ICP

Put a product definition and ideal-customer profile behind every lead decision.

linxa_list_productsRead

Input: None

List the products and ICP rules in the account.

linxa_get_productRead

Input: product_id

Read one product and its configuration.

linxa_create_productWrite

Input: name; optional description, synonyms, website

Create a product context for matching and outreach.

linxa_update_productWrite

Input: product_id plus changed fields

Update product details or ICP fields.

linxa_generate_product_rulesWrite

Input: product_id; optional sections, mode, dry_run

Generate only the requested description, ICP, pain points, value proposition, benefits, or messaging rules. Use missing_only to preserve populated sections or regenerate to replace them.

Autopilot and lead search

Search asynchronously, work from scored results, and keep delivery limits inside Linxa.

linxa_get_autopilotRead

Input: None

Read the active autopilot configuration.

linxa_set_autopilotExternal action

Input: enabled, daily_limit, schedule, product_id, min_icp_match

Configure a controlled autopilot; schedule accepts any_time, business_hours, morning, afternoon, or evening.

linxa_search_leadsWrite

Input: search_url or persona, product_id; optional limit

Start an asynchronous lead search.

linxa_get_lead_search_statusRead

Input: request_id

Check search progress and retrieve its result reference.

linxa_list_leadsRead

Input: Optional: minScore, productId, source_request_id, limit

List discovered leads and narrow them to a search result.

Sequences

Compose first; send only after the messages, audience, timing, and scope are reviewed.

linxa_list_sequencesRead

Input: None

List configured sequences.

linxa_get_sequenceRead

Input: sequence_id

Read a sequence and its steps.

linxa_get_sequence_statsRead

Input: sequence_id

Read sequence state, enrollments, queued/attempted/delivered/failed messages, and next execution time.

linxa_create_sequenceWrite

Input: name, product_id

Create a draft sequence.

linxa_generate_sequence_stepWrite

Input: sequence_id, step_order, template or prompt

Generate a candidate step for review.

linxa_update_sequenceWrite

Input: sequence_id, steps (1–5)

Save step content, mode, and delays.

linxa_set_sequence_audienceWrite

Input: sequence_id, source_request_ids; optional dry_run

Preview and save exact owned lead-search sources as the audience. A missing audience never means all contacts.

linxa_start_sequenceExternal action

Input: sequence_id, idempotency_key; optional dry_run

Preview, start, or resume delivery. The server blocks incomplete steps and sequences without an explicitly saved audience.

linxa_pause_sequenceWrite

Input: sequence_id; optional idempotency_key

Pause active enrollments and cancel queued messages that have not started, so steps can be edited safely before resume.

CRM pipelines and deals

Manage sales pipelines, stages, and deal flow when CRM is enabled on your team. Use crm.list_pipelines first to discover available pipelines and stages; choose an exact pipeline and status before listing deals. Every mutation requires explicit user approval and a unique request ID. CRM tools never send LinkedIn messages or emails.

crm.list_pipelinesRead

Input: None

List the team-visible CRM pipelines and their configured stages. Call this first before listing deals if the user has not named an exact pipeline.

crm.list_dealsRead

Input: pipeline_id, status; optional: owner_user_id, stage_type, limit (1–100, default 25), offset (default 0)

List one bounded page of team-visible CRM deals for a chosen pipeline and status (suggested, open, won, lost, rejected). If called without pipeline_id or status, returns needs_input with available pipelines and statuses. Returns total and next_offset for pagination. AI-hidden comments are never returned.

crm.get_dealRead

Input: deal_id

Get one team-visible CRM deal and its details, including stage, contact, owner, and AI-visible internal comments. Comments marked includeToAi=false remain hidden.

crm.create_dealWrite

Input: contact_id, product_id, request_id; optional: stage_id, owner_user_id, title, value, currency, expected_close_date, idempotency_key

Create a new CRM deal for an existing contact after explicit user approval. Never sends a LinkedIn message or email.

crm.move_dealWrite

Input: deal_id, expected_updated_at, request_id; optional: stage_id, stage_name, stage_type, idempotency_key

Move a CRM deal to a new stage after explicit user approval. Resolve the exact deal first with crm.get_deal and pass its current expected_updated_at timestamp for conflict protection.

crm.set_ownerWrite

Input: deal_id, owner_user_id, request_id; optional: idempotency_key

Assign a CRM deal to a current team member after explicit user approval.

crm.add_commentWrite

Input: deal_id, body, request_id; optional: idempotency_key

Add an AI-visible internal comment to a CRM deal after explicit user approval. This note is internal and never contacts the prospect.

crm.confirm_suggestionWrite

Input: deal_id, request_id; optional: owner_user_id, stage_id, idempotency_key

Confirm an AI-suggested lead into an active CRM deal stage after explicit user approval.

crm.reject_suggestionWrite

Input: deal_id, request_id; optional: idempotency_key

Reject an AI-suggested deal after explicit user approval, preventing automated re-suggestion.

Response and approval contract

ok means the requested result is available. For asynchronous work, inspect the returned action or request ID rather than assuming completion.
preview shows exactly what would happen. It does not authorize the write and must be followed by a separate approved call.
drafted, queued, or scheduled are not delivery confirmations. Follow the returned action_id until the terminal status is available.
needs_input means the agent should ask for the missing field. For example, crm.list_deals returns needs_input with code PIPELINE_AND_STATUS_REQUIRED and the list of available pipelines and statuses if called without an exact pipeline and status. The agent must prompt the user to choose rather than guessing.
crm.list_deals pagination returns total and next_offset. The agent should call again with next_offset only when the user explicitly requests another page, rather than exhausting pages automatically.
CRM mutation safeguards: All CRM writes (crm.create_deal, crm.move_deal, crm.set_owner, crm.add_comment, crm.confirm_suggestion, crm.reject_suggestion) require a unique request_id, record MCP as the action source, exclude AI-hidden comments (includeToAi=false), and never send a LinkedIn message or email.
Concurrency protection on deal moves: crm.move_deal requires expected_updated_at matching the deal's current timestamp from crm.get_deal to prevent overwriting concurrent updates.
error is terminal for that call. Surface its code and message, then adjust only after the user provides direction.
SEQUENCE_STEPS_INCOMPLETE and SEQUENCE_AUDIENCE_REQUIRED are safety stops: complete the content and save an explicit owned audience before trying again.

Safe agent recipes

Build only the missing ICP

1Create or read the product.
2Call linxa_generate_product_rules with explicit sections and mode=missing_only.
3Read the product back before using it for lead search.

Find and sequence leads

1Start a search, retain request_id, and poll its status.
2Attach that exact source with linxa_set_sequence_audience and preview the matched count.
3Show every message and delay; start only after explicit approval.

Prepare replies without sending

1Call linxa_get_next_actions once and retain conversation IDs.
2Use linxa_prepare_replies for normal Smart Inbox-quality drafts.
3List the saved drafts and wait for editing or send instructions.

Send exact approved drafts

1Call linxa_send_drafts with exact conversation_ids and dry_run=true.
2Show every recipient and full message; ask for explicit approval.
3Use the returned approval_token within 15 minutes, then check every action_id.

Reply to a post comment

1List owned posts and retain the exact post_id.
2Read engagement and retain the commenter profile_id.
3Preview the exact reply with dry_run=true, show it to the user, then use the approval_token only after explicit approval.

Discover pipelines and progress a CRM deal

1Call crm.list_pipelines to inspect team pipelines and stage IDs when the pipeline is not specified.
2Ask the user to choose an exact pipeline and status before calling crm.list_deals.
3Fetch the target deal with crm.get_deal to retrieve its current expected_updated_at and context.
4Obtain explicit user approval before calling crm.move_deal with expected_updated_at and a unique request_id.