How do you read an MCP endpoint check result?
AdminKit's MCP endpoint check comes down to one question answered in two steps: did the server's initialize call succeed without credentials, and if so, did tools/list then reveal which tools it exposes? An MCP server that accepts both from anyone is callable by any AI agent or script that finds its URL, not just the one it was built for.
By AdminKit team, Netbase JSC · Updated
Key takeaways
- The check sends
initializewith no credentials. If that succeeds, it sendstools/list. It never calls a tool. - “OK” means
initializewas rejected and no other problem was found. “Issue found” means at least one high or critical finding, almost alwaysmcp.no_auth_required. - With an open result, read the tool names before anything else. Names that suggest shell, file or network access raise a critical finding.
- “Could not complete” is a connectivity or protocol answer, not a security verdict. “Skipped” means a safety guard refused the target before any request was sent.
What does the check do, in order?
AdminKit’s MCP endpoint check sends a real initialize request — the first call any MCP client makes — to the URL you enter, with no credentials attached. What happens next depends entirely on how the server responds:
- If
initializereturns an authentication error (401or403), the check reports that the endpoint requires auth and does not go further into the protocol — it never attempts to guess or brute-force credentials. - If
initializesucceeds with no credentials, the check continues totools/list, which asks the server to describe every tool it exposes. The check records the tool names. - The check never sends
tools/call. It reads what tools are called, but never invokes one, so it cannot trigger a file write, a database query, or a shell command on the server it’s checking.
Whenever the server answers initialize with 200, 401 or 403, the check also makes three read-only requests: it fetches the server’s OAuth protected-resource metadata from /.well-known/oauth-protected-resource, sends a CORS preflight (OPTIONS) with a made-up origin, and looks for the older HTTP+SSE transport at /sse. Their answers appear as evidence.
tools/list is also the only inventory this check reads: a server’s resources, including any
resource template exposing a whole parameterized family of them under one
RFC 6570 URI pattern, are a separate discovery call the check doesn’t make, so an open resource list isn’t covered by
this result.
A result is therefore one of three shapes: authenticated (initialize rejected the unauthenticated attempt), open (initialize succeeded, and tools/list shows what’s exposed), or could not complete (the endpoint didn’t answer like an MCP server at all — connection refused, a timeout, or an unexpected status code to initialize).
What does each status label mean?
The result opens with a status badge and a one-line summary. The badge follows the worst finding, and the summary counts the findings:
| Badge | Status | What produced it | Typical summary |
|---|---|---|---|
| OK | ok | No findings: initialize was rejected, and CORS is not wildcard-with-credentials | “no anonymous access found” |
| Warning | warn | Only medium or low findings, such as unsafe CORS on an otherwise locked server | “1 finding(s)” |
| Issue found | fail | At least one high or critical finding, such as mcp.no_auth_required | “2 finding(s)” or more |
| Could not complete | error | No connection, a timeout, or an unexpected initialize status | “could not reach MCP endpoint: …” |
| Skipped | skipped | A safety guard refused the target before sending anything | The reason for the refusal |
Behind the badge is a 0-100 score that starts at 100 and drops by 40 for each critical finding, 25 for each high and 15 for each medium. The connector and the GitHub Action return the score in their output; on the tool page, the badge and the findings carry the same meaning.
How do you read an “open” result?
The example below is illustrative: the server, its name and its tools are invented, and the URL uses the documentation domain example.com. It shows the parts of a result for a server that accepts anonymous clients and lists three tools, in the order the tool page shows them:
Issue found 3 finding(s)
tls true
initialize status 200
auth required false
server info {"name":"example-tools","version":"1.2.0"}
negotiated protocol version 2025-06-18
tools list status 200
tool names get_status, search_docs, run_shell
legacy sse supported false
high MCP server accepted `initialize` without authentication — POST https://mcp.example.com/mcp returned 200 for an unauthenticated initialize call.
medium MCP tool list readable without authentication — 3 tool(s) listed: get_status, search_docs, run_shell
critical A high-risk tool name is exposed anonymously — Tool name(s) suggest shell/file/network access: run_shell
If your result shows the server accepted initialize with no credentials, the next thing to read is the tool list tools/list returned. The Model Context Protocol specification describes tools as the mechanism by which a server lets an agent take real action — reading files, querying data, calling an internal API — so a tool list visible to anyone, authenticated or not, is effectively a map of what an unauthenticated caller could ask the server to do if it also allowed tools/call. A name like read_file, run_query or execute_command is a stronger signal to act on urgently than something read-only and narrowly scoped like get_status. The check flags names that match a fixed list of risky patterns (such as shell, exec, command, delete, write_file or fetch_url) as critical, but it does not grade the rest for you — reading the names in the context of what the server is meant to do is what turns “open” into an informed next step. The Model Context Protocol’s own tool annotations metadata — hints like destructiveHint and readOnlyHint — is meant to carry exactly this kind of severity signal, though the specification treats it as untrusted, so a declared hint is worth noting, not trusting outright; see
MCP tool annotations explained for what each hint actually promises and why none of them can be trusted from a server you haven’t vetted.
Which findings can appear, and how serious is each?
| Finding | Severity | What it tells you |
|---|---|---|
MCP server accepted initialize without authentication | high | Anyone who knows the URL can start a session |
| MCP tool list readable without authentication | medium | Anyone can enumerate the tools; the detail lists their names |
| A high-risk tool name is exposed anonymously | critical | At least one listed name suggests shell, file or network access |
| CORS allows any origin together with credentials | medium | Access-Control-Allow-Origin: * with Access-Control-Allow-Credentials: true |
The CORS finding can appear on an otherwise authenticated server. It means the server tells browsers that any website may make credentialed requests to it, which is a combination to remove whatever else the result says.
How do you read the evidence fields?
| Evidence field | What it records |
|---|---|
tls | Whether the URL uses HTTPS |
initialize status | The HTTP status the server returned to the anonymous initialize |
auth required | true for a 401 or 403, false for a 200 |
www authenticate | The challenge header sent with a 401, if any |
server info, negotiated protocol version | What the server said about itself when it accepted initialize |
tools list status, tool names | The answer to tools/list, when it was sent |
oauth metadata | The server’s published protected-resource metadata and, if named, its authorization server’s metadata |
cors, legacy sse supported | The CORS preflight headers, and whether /sse answered as an event stream |
On an authenticated server, www authenticate and oauth metadata are the fields to look at. The MCP Authorization specification says servers must send a WWW-Authenticate header with a 401 and must publish OAuth 2.0 Protected Resource Metadata as defined in RFC 9728, so a client can find the authorization server. If both are missing, compliant clients cannot discover how to sign in, even though the server correctly turns away anonymous callers.
What does a “skipped” result or a refused target mean?
AdminKit’s probes include guards against server-side request forgery. The adminkit-mcp connector and the GitHub Action resolve the hostname before sending anything and return skipped if every address it resolves to is private, loopback, link-local or reserved, unless the person running the probe has explicitly allowed private targets for a local test. AdminKit’s Agent Trust API, which scores MCP endpoints, rejects a private or reserved IP literal as invalid input. A refused or skipped target is a safety decision about the check, not a finding about the server you’re testing: the request never went anywhere.
The guards exist for the reason the MCP project’s security best practices give for SSRF defences in MCP clients: a service that fetches a URL on a caller’s behalf can be steered at internal addresses, cloud metadata endpoints or localhost services, so it has to validate where that URL actually points, not just that it’s syntactically a URL — the same reasoning behind server-side request forgery (SSRF) defences generally. To check a server on your own private network, run the connector’s one-shot probe from a machine on that network, as described in check if your MCP server is exposed with an AI agent.
What does “authenticated” not confirm?
A result showing initialize rejected without credentials is good news, but it only confirms that one call enforces authentication — not that the server’s broader authorization setup is sound. The MCP Authorization specification defines a full OAuth 2.1-based flow with requirements beyond a single rejected call: token audience validation (so a token issued for a different service can’t be replayed here), scope enforcement per tool, and correct metadata discovery. This check is a single external probe of the front door, not a substitute for reviewing that the rest of the authorization flow is implemented to spec.
What should you do next, depending on the result?
- Open, and not meant to be public — restrict network access or add authentication before anything else; this is the most urgent state, since any agent or script that finds the URL can currently read your tool list.
- Open, and intentionally public — confirm none of the exposed tools can take a consequential action without further confirmation, since an unauthenticated caller can see exactly what’s available.
- Authenticated — a good baseline; see how to secure an MCP server for the fuller checklist beyond authentication alone, including a tool allowlist and treating tool responses as untrusted input.
- Could not complete / unreachable — confirm the URL and that the service is actually running before assuming anything about its security posture.
- Skipped — use a public URL, or run the probe locally for a private server.
Exposure can change without anyone touching the server’s code — a redeploy, a network change, or a forgotten debug build can reopen a gap you already closed. Re-running this check periodically catches that; scan an MCP endpoint in CI covers running the same probe automatically on every push instead of relying on remembering to re-check by hand.
How do you check your own endpoint next?
Run AdminKit’s MCP endpoint check against a server you own or are authorized to test. Only test a server you control — reachability probing against one you don’t can violate its own terms of use even though this specific check never calls a tool. OWASP’s Top 10 for LLM Applications ranks prompt injection first among LLM risks, and an anonymous tool list makes a server easier to study for exactly that kind of attack. See our developers and SaaS teams page for the fuller picture of checking an exposed MCP server alongside TLS and headers.
This guide is general information, not a security audit of your specific network — see our disclaimer for what AdminKit's guidance does and does not commit to.
Frequently asked questions
The result says 'no auth required' — does that mean my server is definitely broken?
It means the specific endpoint checked accepted an initialize call with no credentials, which is spec-compliant but risky if the server was meant to be internal-only. The Model Context Protocol specification makes authorization optional for HTTP-based transports, recommending rather than requiring it, so 'no auth required' is a statement of fact about this endpoint's current configuration, not a bug report — whether it's a problem depends on what the server is meant to expose and to whom.
What does it mean if tools/list succeeds after initialize?
It means the check could read your server's tool list without ever proving who was asking. The check records the tool names, stops there and never calls tools/call, so it can't tell you what those tools would actually do if invoked, but tool names alone are often informative: a name like run_shell_command or query_database visible to an unauthenticated caller is a stronger signal of risk than one like get_weather.
Why does a result sometimes say skipped, or refuse a private address?
That comes from AdminKit's SSRF guards, which stop a check from being used to reach into private networks. The adminkit-mcp connector and the GitHub Action resolve the hostname first and return skipped, without sending anything, if every address is private, loopback, link-local or reserved. AdminKit's Agent Trust API rejects a private or reserved IP literal as invalid input. Either way it is a check-safety decision, not a finding about the server: the request never went anywhere.
What if the endpoint doesn't behave like an MCP server at all?
The check reports that plainly — a connection that fails, times out, or an initialize call answered with an unexpected HTTP status comes back as 'Could not complete' (status error) rather than a false pass or fail. This matters because a server that's simply unreachable (wrong URL, service down, firewall blocking it) looks very different from one that's reachable and happily returns tool data with no auth — conflating the two would hide a real exposure behind what looks like a connectivity problem.
I expected authentication to be required and the result confirms it is — am I done?
This check confirms the one thing it tests: that initialize rejects an unauthenticated call. It doesn't verify your authorization flow is implemented correctly end-to-end (token audience validation, scope enforcement per tool, or resistance to a stolen token being replayed from a different service) — those require a deeper review of the server's own OAuth implementation, not a single external probe.
Want AdminKit to watch this for you?
Free checks tell you the state today. Protective DNS and monitoring tell you when it changes.
Talk to an expert
Huy Nguyen (David), Founder & CEO, Netbase JSC
Ask whether this fix applies to your setup, or get a second pair of eyes on your DNS and mail records.