Introducing the MCP Trust Checker API: Scan Any MCP Server Over HTTP

The MCP Trust Checker command-line tool has always run on your own machine. Today we are adding a second way to use the exact same security engine: a free hosted API. You send it an MCP server — as a published package name or a tools.json manifest — and it sends back a plain-English safety verdict as JSON, over a single HTTPS request. No install, no account, no credit card.

This post explains, from scratch, what the API does, why you might want it, and exactly how to call it — with copy-paste examples you can run in your terminal in the next two minutes.

First, a 30-second refresher: what is MCP, and why scan it?

MCP (the Model Context Protocol) is an open standard that lets an AI assistant use external tools — reading files, querying a database, calling an API, browsing the web. An MCP server is a small program that exposes those tools. When you connect one to your assistant, its tools become part of what the AI can do on your behalf.

That power cuts both ways. A server that can read a file and make a web request is, in principle, a data-exfiltration path: a malicious or poisoned server could read your secrets and send them somewhere. And the tool descriptions a server ships are read by the model, not by you — a perfect place to hide instructions. So before you trust a server with your files and tokens, it is worth asking one simple question: is this thing safe?

MCP Trust Checker answers that question deterministically — the same input always produces the same result, with no AI in the loop and no guessing. The API gives you that answer without installing anything.

What the API gives you

Point the API at an MCP server and you get back three honest measures, plus the evidence behind them:

• Trust — an A–F letter grade (and a 0–100 score). How safe the server looks.
• Capability — how much damage the server could do if it went rogue (its "blast radius"), from minimal to critical.
• Coverage — how much the scan could actually see (a full live scan versus just metadata), so a shallow look is never mistaken for a clean bill of health.

Every finding comes with its evidence — what the problem is, where it is, and why it matters — so the grade is something you can act on, not just a number to glance at.

What you can scan

The API accepts three kinds of input:

• A published npm package, by name (for example @modelcontextprotocol/server-filesystem).
• A published PyPI package, by name (for example mcp-server-fetch).
• Your own manifest — a tools.json file, or an MCP client config, that you POST in the request body.

That is the whole surface, on purpose. The API never runs the server and never fetches a URL you hand it, so there is nothing dangerous for it to be tricked into doing.

Step 1 — get your free API key

Open the API page and click Request API access. Enter your email and a sentence about what you are building, and your key appears immediately — it looks like mtc_1a2b3c.... Copy it somewhere safe; it is shown only once. There is nothing to pay and no waiting for approval.

You send the key with every request, in a header. Two forms work — pick either one:

Authorization: Bearer YOUR_API_KEY
X-API-Key: YOUR_API_KEY

Step 2 — your first scan

The quickest way to see it work is to scan a real, published package. Paste this into your terminal (swap in your own key):

Scan an npm package

curl https://mcptrustchecker.com/api/v1/scan/npm/@modelcontextprotocol/server-filesystem \
  -H "Authorization: Bearer YOUR_API_KEY"

The API fetches that package's real published source, analyses it, and returns a JSON report. Nothing is installed or executed — it reads the exact bytes npx would download, in memory.

Scan a PyPI package

curl https://mcptrustchecker.com/api/v1/scan/pypi/mcp-server-fetch \
  -H "Authorization: Bearer YOUR_API_KEY"

Scan your own manifest

If you have a server's tools.json (or you are building one), POST the file directly:

curl -X POST https://mcptrustchecker.com/api/v1/scan/manifest \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @tools.json

Or inline a tiny example without a file:

curl -X POST https://mcptrustchecker.com/api/v1/scan/manifest \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"notes","tools":[{"name":"read_file","description":"Read a file and return its contents."}]}'

Step 3 — read the result

Every response is JSON. Here is a trimmed example so you can see the shape:

{
  "grade": "A",
  "score": { "score": 98, "grade": "A" },
  "capability": { "level": "minimal" },
  "coverage": { "level": "source" },
  "findings": []
}

How to read it, in plain terms:

• grade / score — the headline verdict. A is clean; F means real malice signals were found. Anything in between tells you how much to worry.
• capability — what the server can do. High capability is not automatically bad — a database tool is powerful by nature — but you should grant it deliberately.
• coverage — how deep the scan went. source or live means it saw the real code or the real running tools; metadata means it only saw names, so treat even an A with a little caution.
• findings — the specific issues, each with a severity, a location, and a fix. An empty array means nothing was flagged.

Want a readable view? Pipe the response through jq by adding | jq . to the end of any command.

A real use case: gate your CI

The most common way teams use the API is to block a build when an MCP server drops below a grade. Because the score is deterministic, the same server always gets the same grade, so this check never flakes. A minimal shell version:

grade=$(curl -s https://mcptrustchecker.com/api/v1/scan/npm/some-mcp-server \
  -H "Authorization: Bearer YOUR_API_KEY" | jq -r '.grade')

case "$grade" in
  A|B) echo "OK ($grade)" ;;
  *)   echo "Blocked: grade $grade" ; exit 1 ;;
esac

Other common uses: showing a trust badge on an MCP marketplace listing, checking a server before you add it to your assistant, or auditing a whole list of servers in a nightly job.

Good to know

• It is completely free. No card, no account, no per-scan billing.
• Same engine as the open-source CLI. The API runs the identical deterministic scanner — no LLM, no telemetry.
• Your data stays minimal. The API only ever sees the manifest you POST or the public package name you name. It does not run your server and does not scan URLs you supply.
• Rate limits apply to keep it fair; responses include headers that tell you where you stand. Add -i to a curl command to see them.
• Prefer to stay fully offline? The CLI still runs entirely on your machine — npx mcptrustchecker — and the API is just an optional convenience.

That is the whole thing. Grab a key on the API page, scan your first server, and you will have an auditable safety verdict for any MCP server in seconds. The full endpoint reference and every response field are documented on the API docs page.

npx mcptrustchecker