← Home

The MCP server

Thirty-seven tools that only read. Thirty that need your permission.

LiveCRM is an MCP server as well as a product. Point your agent at it and it can ask anything about your CRM for nothing, and change nothing without a grant you issued.

The gap this closes. An agent handed a CRM API key has everything or nothing. The credential that lets it read your pipeline is the same credential that lets it delete your pipeline, so the only careful answer has been to not connect it at all.

Connect it

Point your client at the server.

The connector is open to LiveCRM accounts. If you have one, sign in and add it. If your company is new to LiveCRM, start a free trial. If it already uses LiveCRM and you do not have access yet, ask an admin for an invite.

MCP server URL

Paste this into your client's connector field. It is not a page to open. Note the api. subdomain: this page is livecrm.ai/mcp, the server is api.livecrm.ai/mcp, and the two are not interchangeable.

  1. You do not need to sign in first. If you are signed out when you connect, LiveCRM asks you to sign in or create an account and then returns you to the consent screen to finish.
  2. In Claude, connect from the directory. LiveCRM is listed in Claude's connector directory. Open the LiveCRM listing and connect. There is no URL to paste.
  3. In any other client, use its setup below. Each one signs in the same way: the first time it connects, your browser opens the LiveCRM sign-in and consent screen. There is no API key to copy.

Setup by client

Claude Code

claude mcp add --transport http --scope user livecrm https://api.livecrm.ai/mcp

Then run /mcp inside Claude Code and choose LiveCRM to sign in. Leave out --scope user to add it to the current project only.

Cursor

Add this to ~/.cursor/mcp.json to use it everywhere, or to .cursor/mcp.json in a project:

{
  "mcpServers": {
    "livecrm": {
      "url": "https://api.livecrm.ai/mcp"
    }
  }
}

VS Code

Run MCP: Add Server, choose HTTP, and paste the server URL. Or add this to .vscode/mcp.json:

{
  "servers": {
    "livecrm": {
      "type": "http",
      "url": "https://api.livecrm.ai/mcp"
    }
  }
}

ChatGPT

Turn on developer mode in Settings, then add a connector with the server URL and OAuth sign-in. Which plans can do this, and where the setting sits, changes often, so check OpenAI's help pages if your menus look different.

Any other client

Any client that supports remote MCP servers over streamable HTTP with OAuth connects with the server URL alone.

Approving sends you to a consent screen naming the client, your workspace and the account you signed in as, listing the capabilities it is asking for; those are the fourteen permissions set out further down this page.

Try asking

  • How many of our contacts have no email address?
  • Find duplicate accounts and show me the groups you are most sure about.
  • Which of our contacts have changed jobs recently?
  • Standardize the job titles on our contacts, and show me what would change before anything is written.
  • What did LiveCRM change in our CRM this week? Undo the last change.

That URL is this hosted deployment. A customer hosted deployment serves its own, because the issuer and the audience a token is minted for both derive from that deployment's own base URL, and a token issued by one cannot be replayed against another.

Sixty-seven tools, each one a call your agent can make against your own CRM. 37 of them only read.

Every tool declares what it does to the world. Whether it only reads, whether it destroys something, and whether it leaves this deployment at all. Those are not documentation: they are set per tool and required when the tool is defined, so a client can decide what needs confirming before it calls anything.

Capabilities, not read and write. Two values answer none of the questions an administrator actually has. May this agent create a run but not dispatch it. May it enrich but not merge. May it read the audit trail but not the records. Those are the questions, and they need a vocabulary with more than two words in it.

The division

Asking is free. Acting is granted.

The split is not a convention the server follows. It is declared per tool and enforced at the token.

37 tools that only read

They answer from this deployment's own mirror of your CRM. Free, immediate, and impossible to regret.

  • crm:read
  • count_crm_records
  • get_crm_record
  • list_crm_connections
  • list_crm_users
  • list_filterable_fields
  • runs:read
  • get_data_health
  • get_operational_health
  • get_plan
  • get_readiness_recommendations
  • get_readiness_scan
  • get_run
  • get_run_records
  • get_usage_summary
  • list_employer_changes
  • list_plans
  • list_runs
  • list_search_criteria
  • preview_plan_reversal
  • runs:preview
  • preview_enrichment_run
  • preview_records_run
  • templates:read
  • get_assignment_config
  • get_default_rule_config
  • get_market_whitespace
  • get_normalize_catalog
  • get_persona_whitespace
  • get_rule_template
  • get_tam
  • get_tam_outward
  • list_rule_templates
  • list_whitespace_companies
  • preview_normalize_scheme
  • dedup:read
  • get_duplicate_group
  • list_duplicate_groups
  • audit:read
  • get_audit_event_records
  • list_audit_events
  • queue:read
  • list_queue_actions
  • list_queue_history

30 that change something

Each sits behind a named permission. Holding one does not imply holding another.

  • runs:create
  • create_alert_run
  • create_assignment_run
  • create_deduplication_run
  • create_enrichment_run
  • create_job_change_run
  • create_mass_update_run
  • create_normalize_run
  • create_plan
  • create_records_run
  • create_score_run
  • create_segmentation_run
  • create_verification_run
  • update_plan_inputs
  • runs:dispatch
  • dispatch_run
  • fire_plan
  • run_job_change_sweep
  • set_plan_schedule
  • runs:reverse
  • reverse_audit_event
  • runs:delete
  • delete_run
  • templates:write
  • create_rule_template
  • delete_rule_template
  • set_assignment_config
  • set_contact_owner_inheritance
  • set_new_employer_record
  • set_owner_mode
  • set_tam
  • update_rule_template
  • dedup:merge
  • approve_duplicate_group
  • reverse_duplicate_group
  • queue:propose
  • queue_action

The vocabulary

Fourteen permissions, written for the person granting them.

This is the whole list. What an agent may do on its own, and what it must bring back as a proposal, is a permission you set at the tenant level, not a prompt it can talk its way around.

crm:read Read the mirrored CRM records and the field catalog 5 tools
runs:read Read runs, their outcomes and why records were not written 9 tools
runs:preview Preview what a run would do, without running it 2 tools
runs:create Create runs, which do nothing until dispatched admin
runs:dispatch Execute runs, which writes to the connected CRM admin
runs:reverse Reverse a run that has already written admin
runs:delete Delete runs, which discards their outcome and funnel permanently admin
templates:read Read the rule and mapping configurations, the TAM and its market whitespace 11 tools
templates:write Create and change rule and mapping configurations admin
dedup:read Read duplicate groups and what merging one would do 2 tools
dedup:merge Merge duplicate records, whose undo is unmerge rather than a run-level reverse admin
audit:read Read the audit trail 2 tools
queue:read Read the review queue and its history: what is waiting for a person, and what was approved, rejected or rolled back 2 tools
queue:propose Propose CRM changes into the review queue, which change nothing until a person approves each one admin

The posture

Propose everything. Execute nothing.

On Growth and Enterprise, that sentence is a pair of permissions rather than a product tier.

Creating a run and dispatching it are separate permissions, and that separation is what makes the autonomy question a grant rather than an architecture. An agent holding the first and not the second can research your CRM, compose the exact operation that would fix what it found, scope it, and hand it to a person. It cannot write a single field.

Full autonomy is both permissions. Moving between the two is an administrator changing a grant, not a migration, not a different product, and not a setting the agent can reach.

Merging is held apart from everything else. A run writes under one audit event and reverses as a unit; a merge is the one operation whose undo is a different surface entirely. Bundling it with the permission to dispatch would mean granting the reversible and the irreversible with one word.

Blast radius

Most of it never leaves the building.

Nine of the 67 tools can reach anything outside this deployment.

Every read but one answers from LiveCRM's own mirror of your CRM, its own catalog and its own tables. The exception lists the companies a market segment is missing, and it does so with your data provider's free company search: no credits, and nothing written. The tool called count records is called that because it counts records, and it touches your CRM to do it exactly never.

The ones that do leave are declared as such, one by one, so a client knows before it calls. That is the same annotation MCP asks for and most servers set once for the whole catalogue.

The rest of it

What the tools operate on.

The eleven tools
The corrections themselves. Most write tools here are one of them, created and dispatched.
Runs
What a create tool makes. Scoped, saved, and doing nothing until something dispatches it.
Plans
An ordered sequence of runs, each one a tool call with its scope.
The Console
The same surface with a person in it, where every write is held as a plan to confirm.

Both sides of the desk

Give your agent the half that knows your CRM.

Point it here alongside the research tools it already has. One asks what is out there; this one knows what you already hold, and is the only one permitted to change it.