Account MCP Server

Overview

The Account MCP server lets an AI agent take actions in your CallMissed account through the Model Context Protocol. Point any MCP client at one URL, sign in with your CallMissed account or pass an API key, and the agent gets 331 tools: draft, build and configure voice agents end to end, set up how inbound calls are answered with flows, menus and queues, place and inspect phone calls, read transcripts, build and run outbound calling campaigns, work the shared inbox and the support desk, search and update the CRM and set up its pipelines, custom fields and lead scoring, summarise and score calls, send WhatsApp messages, catalog products and Flow forms, send email, generate images, connect and disconnect WhatsApp, Facebook, Instagram, integrations and knowledge sources, wire up webhooks and managed prompts, version and roll back an agent, run evaluation suites and A/B experiments, and check what it all cost.

It is hosted, so there is nothing to install and nothing to run locally.

Endpoint

https://api.callmissed.com/api/v1/mcp

The transport is Streamable HTTP: every call is a single POST that returns one JSON response. There is no session to open or close, so the server works behind any load balancer and needs no sticky routing. GET and DELETE return 405 by design, because this server does not offer a server-initiated event stream.

The server answers initialize, tools/list, tools/call, resources/list and resources/read, and declares the tools and resources capabilities.

Connect

Two ways in. Both reach the same tools; they differ in how the connection is authorised and how much you have to set up.

Option 1: sign in with your CallMissed account

The easy path, and the recommended one. Paste the server URL into your client, click Connect, sign in to CallMissed, and tick what the connection is allowed to do. There is no key to create and nothing to paste into a header.

https://api.callmissed.com/api/v1/mcp

Paste that URL exactly as written, path included. Discovery is bound to the URL you type, so a shortened or altered one is not recognised as this server and sign-in never starts.

If your client cannot complete the sign-in, use an API key instead (option 2 below).

Choose what to allow

The consent screen offers five permission groups.

Read your data is the only group ticked when the screen opens. The other four start off and are granted only if you tick them yourself, so a single click cannot hand an agent the ability to message a customer or spend credits.

Building an agent is its own tick rather than part of Take actions: letting an assistant send a WhatsApp message should not also let it rewrite the instructions, voice and tools of the agent answering your phone. Running an eval suite or an A/B experiment sits on that same tick, because it is work done on the agents it already governs.

At least one group has to be ticked. Approving nothing would create a connection that fails every call, so the consent screen asks you to choose something or press Deny.

Against the tool tables further down: Read your data covers every :read scope, including the campaign, CRM-setup, support-desk, commerce, prompt and eval reads; Read call transcripts grants the stt, tts and llm permissions the three voice-session tools need; Take actions covers the record, CRM-setup, support-desk, messaging, commerce, telephony and campaign :write scopes plus whatsapp:send and the image and email permissions; Set up and change your agents covers bots:write, knowledge:write, squads:write, evals:write and experiments:write; and Configure your workspace covers webhooks:write, integrations:write, prompts:write and whatsapp:write.

The connection appears as an API key

Approving creates an API key on your account named MCP connection: {host}, where the host is the one shown on the consent screen as the client that asked. You will find it at Developer → API keys in the console next to your other keys, carrying exactly the scopes you ticked, with the same budget, rate limit and credit accounting as any key you make by hand. Request logging is off for it.

Its value is never shown and cannot be revealed or copied out, so it can only ever be used by the connection it was made for.

To disconnect, deactivate that key. That is the whole revocation story: once the key is inactive, every token issued to that connection stops working immediately.

Staying connected

The access token your client receives is short-lived and your client renews it in the background using the refresh token issued alongside it. You are not asked to sign in again each time you use the tools. You will be asked again if you deny, if the key is deactivated, if you want to change what is allowed, or after the connection has gone unused for a long stretch.

Discovery endpoints

A client finds the flow from the URL you paste, by fetching these:

The flow itself is a standard OAuth 2.1 authorization code exchange:

Two things to know if you are writing the client yourself:

• PKCE with S256 is required. There is no client secret, so a request without code_challenge_method=S256 is refused.
• client_credentials is not supported. The only grant types are authorization_code and refresh_token, because every connection needs a person to approve it on the consent screen.

There is no registration step. client_id is an https:// URL that identifies your client, and the consent screen shows its host as plain text so the person approving can see who is asking.

Redirect addresses are limited to ones CallMissed has approved, plus loopback addresses for native apps. Any other redirect_uri is refused with a 400 before the consent screen is ever shown, so nothing is redirected to an address we have not vetted.

Option 2: connect with an API key

For clients that do not do the sign-in flow, and for calling the endpoint yourself, pass an API key from your dashboard exactly as you would for any other CallMissed endpoint:

Authorization: Bearer cm_your_api_key

A dashboard login token is refused with 401, even though it works elsewhere in the API. Scope checks are what keep an agent inside its lane, and those apply to keys, so this endpoint takes an API key or a token from the sign-in flow above and nothing else.

Everything attached to the key still applies: its scopes, its spend budget, its rate limit, and its domain allowlist. A key that runs out of budget gets 402; one over its rate limit gets 429.

What a connection needs

Two different gates decide whether a tool works, whether the connection came from signing in or from a key you made by hand:

• Resource scopes such as contacts:read or whatsapp:send. Most tools use these, and the table below names the one each tool needs. A tool whose scope is missing returns a readable refusal naming the scope to add, so the agent can tell you what to fix.
• Service permissions on the key. The three voice-session tools need a key with the stt, tts and llm permissions; the two image tools need the image permission. get_credit_balance needs nothing beyond a valid key.

Give each key only what its agent needs. A read-only key is a perfectly good way to let an agent look at the account without letting it spend anything or reach a real person.

Tools

331 tools in sixteen groups. Access is the tool's own readOnlyHint. Credits marks the tools that draw down your balance. Every tool's full JSON Schema, including argument names, types and bounds, comes back from tools/list.

Voice and calls

Call handling

How an inbound call is answered: the flow it walks, the menu it hears, the queue it waits in, the message left on a machine, and whether the number has been flagged as spam. This is the whole console setup journey, available to an agent.

Deleting a flow, menu, queue or voicemail message is not an MCP tool: an assistant should not be able to remove a routing object that live numbers still point at. Take one out of service reversibly instead — enabled: false on a menu or queue, or detach the number. Clearing a spam complaint needs a proof document and stays in the dashboard.

More voice and calls tools

Calling campaigns

An outbound campaign is a list of people, a voice agent and the rules for when and how fast to dial. Build it as a draft, load the list, then start it. The account-wide do-not-call list lives here too.

Taking a number back off the do-not-call list is deliberately not a tool. Adding one is safe in the direction that matters — the worst case is a call that does not happen — but removing one un-does somebody's opt-out, and the next thing that happens is a call to a person who asked not to be called. That stays with a person in the console. The DELETE /dnc/{entry_id} endpoint is still there for your own code; see the Campaigns API.

Uploading a CSV to a campaign is not a tool either: it is a file upload, and MCP arguments are JSON. Use add_campaign_contacts for a list the agent already holds, or the Campaigns API for a file.

Conversations

More conversations tools

CRM

Pipelines and stages

The board a deal moves across. Pipelines and stages share the deal scopes, because a stage is only meaningful as part of the pipeline it belongs to.

Custom fields

Deleting a custom field definition is not on this surface: the delete cascades to every value stored against it, on every record. Do that in the console.

Saved views

Lead scoring

A new or changed rule does not move any score until recompute_lead_scores runs. The signals a rule may test are a closed list, documented on Lead scoring.

More cRM tools

Support desk

Deleting a ticket is not on this surface — it would destroy the record of a customer interaction and every SLA number computed from it. Close it instead.

SLA

Macros, tags and routing

Macros and rules are retired with is_active: false rather than deleted, so nothing that a past ticket refers to disappears.

Satisfaction

create_csat_survey returns a token; the link you send is that token on the public response page. Delivering it over WhatsApp or email is a separate call, and that send is what costs credits.

More support desk tools

Call intelligence

Messaging

More messaging tools

Images

Agents and knowledge

Building an agent with these tools

create_agent is not the first call. An agent's config is a free-form object whose keys are mostly not checked when written — a wrong value is stored and then fails on the call, usually without an error. So the order is:

1. get_agent_config_schema — the keys this agent type accepts, and a minimal_example that works. draft_agent_from_description is the shortcut past the blank page: describe the agent and review what comes back. It creates nothing, so whatever it proposes still goes through the steps below.
2. validate_agent_config — fix every error finding before writing anything.
3. create_agent, then add_agent_knowledge.
4. For a voice agent: search_available_numbers → provision_phone_number → attach_number_to_agent, then place_call and get_voice_session_transcript to hear the result.
5. update_agent_config to change one key later; it merges, so it cannot wipe the rest of the configuration.
6. craft_agent_prompt → update_agent_prompt to write or improve the instructions. craft_agent_prompt returns the structure, the phone-call rules and the agent's real tools and variables; write the four sections, pass them back as draft until the review has no error findings, then save. An agent's prompt is edited in four boxes — objective, response guidelines, conversation script and first message — and update_agent's flat system_prompt collapses them into one, silently. The pair above is what keeps them.

The same flow over plain HTTP, with curl for every step and the five ways a config silently misbehaves, is on Build an Agent.

More agents and knowledge tools

Usage and credits

Platform configuration

Webhooks, integrations, managed prompts and agent versions. Every webhook tool — including the two that only read — needs webhooks:write, because a delivery row carries customer conversation data and there is no webhooks:read scope to grant.

test_webhook and replay_webhook_delivery both make a real outbound HTTP request to your own endpoint, so whatever your server does on that event happens for real — and a replay makes it happen a second time. Neither takes a URL: they use the one already stored on the subscription, which is re-checked against private and internal address ranges on every attempt.

start_integration_oauth hands back a console link for the account owner to open. They sign in to CallMissed and approve access there, and the account is connected to their own workspace; nothing is connected until they do. Confirm it with get_integration_status, and disconnect with disconnect_integration (see Connected platforms). There is no tool that writes a provider credential.

More platform configuration tools

Testing and quality

run_eval_suite is the one tool here that spends: each case is a real model conversation of up to its turn budget, and a suite with a scorecard adds a grading call per case. No real caller is ever contacted — the caller is synthetic. The balance is checked before anything runs, so a refusal costs nothing.

Metric alerts use webhooks:write rather than a scope of their own. An alert is a notification subscription that sends mail and fires webhooks, which is exactly what that scope already governs.

More testing and quality tools

Connected platforms

Check, connect and disconnect the channels and services the account runs on, without opening the console. Listing and re-pointing WhatsApp numbers, Facebook Pages and Instagram accounts is in the Messaging and Facebook and Instagram groups; adding knowledge is in Agents and knowledge.

Two steps cannot happen inside a chat: Meta's own sign-in window for WhatsApp Business, Facebook and Instagram, and the QR scan that links a personal WhatsApp number. start_channel_connection returns the one page that runs that step, and list_whatsapp_numbers, list_facebook_pages or list_instagram_accounts confirms it worked. No tool accepts an access token or provider key.

The disconnect and remove tools are marked destructive, so your client asks before running them. None of them deletes conversation history.

Facebook and Instagram

Facebook Pages and Instagram accounts: publish and schedule posts, answer comments and DMs, read analytics. Posting, comments and DMs are not billed.

Email

Domains, templates, suppressions, inbound addresses and send history for the Email API. Every tool needs a key with the email permission.

Guides and playbooks

Step-by-step playbooks an assistant follows before it builds anything: it interviews you about the use case first. The same playbooks are served as MCP prompts (build_voice_agent, build_whatsapp_agent, launch_campaign, setup_support_desk, setup_crm).

Calling tools are deployment-gated

33 of the 331 tools are gated on whether calling is switched on for your account, in two independent groups.

20 telephony tools: place_call, list_calls, get_call, end_call, get_call_recording, click_to_call, list_phone_numbers, search_available_numbers, provision_phone_number, attach_number_to_agent, the four voicemail-message tools, set_agent_voicemail_drop, get_number_reputation, update_number_call_settings, declare_number_for_ai_calls, list_telephony_compliance and callback_handoff. With telephony off, tools/list returns the other 311.

13 campaign tools: the whole Calling campaigns table above. With campaigns off, tools/list returns the other 318.

The flow, menu and queue tools are not in either group. Call routing is authored before calling is switched on, so those routes are always mounted and those tools are always served.

Each group appears only where that feature is switched on. Where neither is, tools/list returns the other 298 and those 33 are simply absent, because the REST routes behind them are not mounted there. Calling one by name anyway returns the same Unknown tool error as a typo.

If you do not see them and you expect to, talk to us and we will get calling turned on for you.

Public catalog

GET https://api.callmissed.com/api/v1/mcp/catalog

Unauthenticated, no key needed. It returns the live tool list this deployment serves, which is what the tables above are built from, so you can check what is available before you wire anything up.

curl https://api.callmissed.com/api/v1/mcp/catalog

{
  "serverUrl": "https://api.callmissed.com/api/v1/mcp",
  "protocolVersion": "2025-06-18",
  "count": 331,
  "categories": { "voice": "Voice and calls", "crm": "CRM" },
  "tools": [
    {
      "name": "list_contacts",
      "title": "List contacts",
      "description": "List contacts in your address book, newest first...",
      "category": "crm",
      "categoryLabel": "CRM",
      "readOnly": true,
      "destructive": false,
      "costsCredits": false,
      "scope": "contacts:read"
    }
  ]
}

It carries declarations only: no argument schemas, nothing about the caller, nothing about tools this deployment has gated off. For the JSON Schema of a tool's arguments, call tools/list with your key.

Interactive views

Some results render as an interactive view instead of a wall of JSON, using the official MCP Apps extension (io.modelcontextprotocol/ui). Each view is one self-contained HTML document served over resources/read; a tool points at it through _meta.ui.resourceUri in its declaration.

So five views across seven tools, or six tools where telephony is off.

Where they render. claude.ai, Claude Desktop, Claude mobile and Claude Cowork render MCP Apps, as do ChatGPT, VS Code Copilot and Cursor. The Claude Code terminal does not: it shows the text result instead. That is not a degraded mode. Every tool returns its full data as text and as structuredContent whether or not a view exists, so a client that ignores the extension loses nothing but the pictures.

Connect a client

If your client supports signing in, add the server by URL alone and click Connect: no header, no key. See option 1 above.

Otherwise, most MCP clients accept a remote server as a URL plus a header. In Claude Code:

claude mcp add --transport http callmissed \
  https://api.callmissed.com/api/v1/mcp \
  --header "Authorization: Bearer cm_your_api_key"

For clients configured by file, the shape is usually:

{
  "mcpServers": {
    "callmissed": {
      "type": "http",
      "url": "https://api.callmissed.com/api/v1/mcp",
      "headers": {
        "Authorization": "Bearer cm_your_api_key"
      }
    }
  }
}

Keep the key out of version control. Reference an environment variable if your client supports it.

Call it directly

The endpoint is plain JSON-RPC, so you can drive it with curl. List the tools your key can reach:

curl https://api.callmissed.com/api/v1/mcp \
  -H "Authorization: Bearer cm_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list"
  }'

Call one:

curl https://api.callmissed.com/api/v1/mcp \
  -H "Authorization: Bearer cm_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "list_contacts",
      "arguments": { "q": "jane", "limit": 10 }
    }
  }'

A successful call returns the data twice, once as structuredContent and once serialized into a text block, so clients that only read one shape still work:

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "content": [{ "type": "text", "text": "[{\"id\":\"...\",\"name\":\"Jane\"}]" }],
    "structuredContent": { "result": [{ "id": "...", "name": "Jane" }] },
    "isError": false
  }
}

Errors

Two different shapes, matching the protocol.

A malformed request, meaning an unknown tool, a missing argument, or a bad method, comes back as a JSON-RPC error:

{
  "jsonrpc": "2.0",
  "id": 3,
  "error": { "code": -32602, "message": "Unknown tool: send_sms" }
}

A refused action, meaning a missing scope, no credits, or a closed messaging window, is a successful result carrying isError, so the agent can read the reason and adapt instead of treating it as a crash:

{
  "jsonrpc": "2.0",
  "id": 4,
  "result": {
    "content": [{ "type": "text", "text": "API key missing required scope: whatsapp:send." }],
    "isError": true
  }
}

Authentication failures happen before any tool runs and use normal HTTP status codes: 401 for a missing or malformed credential, a dashboard login token, or a connection that has been revoked; 402 when the key is out of budget; 429 when it is over its rate limit.

Every 401 from this endpoint carries a WWW-Authenticate header pointing at the protected-resource document, including the very first call a client makes with no credential at all. That is what lets a client offer "Connect and sign in" instead of asking you to paste a key.

Protocol version

The server implements MCP revision 2025-11-25 and also accepts 2025-06-18 and 2025-03-26. Send the version you speak on every call after initializing:

MCP-Protocol-Version: 2025-06-18

Omit the header and the server assumes 2025-03-26, per the specification. Send a version it does not support and the call returns 400. Batched requests are not accepted, because the 2025-06-18 revision removed them, so send one request object per POST.