MCP Server

Connect your own AI assistant or agent to your CallMeter account data using the Model Context Protocol, authenticated with your existing API key and limited to what that key can already read.

CallMeter exposes a Model Context Protocol (MCP) server, so you can point your own AI assistant or agent harness at your account and ask questions about your tests, runs and probes in plain language.

It is your assistant, your infrastructure, and your data. CallMeter does not run the model and never sees your prompts.

What it can and cannot do

The server is read-only. Every tool is a query. Nothing exposed here can start a test, change a probe, edit configuration, or spend anything.

It also cannot reach further than the key you give it. Each tool answers by going through exactly the same code path as the corresponding REST endpoint, authenticated with the same API key, so a tool sees precisely what that key would see through GET /api/v1/... — the same organization scoping, the same project permissions, the same role limits.

There are deliberately no tools for managing API keys. Keys are created and revoked in the dashboard only.

Endpoint

POST https://callmeter.io/api/mcp

The transport is Streamable HTTP. The server is stateless: it issues no session id, so there is nothing to keep alive between calls and no sticky routing to arrange.

Every message is a POST. The endpoint answers GET with 405, which the protocol provides for exactly this case: the GET stream exists so a server can push messages to a client unprompted, and a stateless server holds no client to push to. A well-behaved client takes the 405 and stops asking.

Authentication

Use the same API key you use for the REST API, as a bearer token.

Authorization: Bearer cmk_your_api_key_here

See Authentication for how to create one. API access is included with Pro plans and above; a key on a plan without it receives a 403 naming the plan and the upgrade path, rather than a generic authentication failure.

Connecting a client

Most MCP clients take a URL and a header. For a client configured by JSON file, the shape is usually:

{
  "mcpServers": {
    "callmeter": {
      "url": "https://callmeter.io/api/mcp",
      "headers": {
        "Authorization": "Bearer cmk_your_api_key_here"
      }
    }
  }
}

Consult your client's own documentation for the exact key names — they differ between clients, and this file is not one of them.

Available tools

Tool	Answers
`list_projects`	Which projects can this key see? Start here — everything else needs a project id.
`get_project`	Full detail for one project.
`list_tests`	What load tests are configured, and how big are they?
`get_test`	One test's full configuration, including sub-populations and media tracks.
`list_test_runs`	What has been executed, when, and with what outcome?
`get_test_run`	How did one run go — status, quality summary, ASR/NER, SIP response codes.
`get_test_run_metrics`	Full quality metrics for a run, including a time series.
`list_test_run_endpoints`	Which individual endpoints in a run failed, and how?
`list_probes`	What is being monitored continuously, and is any of it blocked or paused?
`get_probe`	One probe's schedule, thresholds and recent runs.
`list_probe_incidents`	When was this probe failing, for how long, and from which region?
`list_probe_runs`	Why is this probe degraded — the per-metric verdict for each run.
`list_registrars`	Which SIP registrars are configured?

Things worth knowing before you point an agent at it

Every tool call spends one API request from your key's rate-limit budget, shared with the REST API. An agent loop can issue a great many calls without anyone watching, so it is worth telling your assistant to filter rather than enumerate. If the budget is exhausted, tools return a rate-limit error the model can back off on.

Every list is paginated, defaulting to 25 rows and capped at 100. Ask for a filtered slice rather than a whole history.

get_test_run_metrics can return a lot of data. It carries a time series, so narrow it with resolution, or with endpoint_id when you already know which endpoint you care about.

A tool refusal is information, not a crash. Permission errors, rate limits and not-found results come back as readable errors so the assistant can explain them or act on them, rather than failing opaquely.

Authentication — creating and scoping an API key
API Reference — the REST endpoints these tools read through
CI/CD Integration — gating a pipeline on test results