Documentation / Open the instrument case
Evidence, wherever
you work.
Read a report. Inspect its boundaries. Bring the same evidence into your terminal, CI workflow, or MCP client.
Every assessment leads with a coverage-aware verdict and shows what actually ran. Failed execution and missing inputs cannot stand in for a clean result.
Start with the question
Find your way through the evidence.
Read the registry
Browse server findings, assessment history, evidence, and coverage. Begin with what is already on file before requesting a new assessment.
A verdict belongs to its recorded assessment scope.
Explore server reportsExplore the method
See what each rule looks for and which inputs it requires. Research surfaces label inferred connections separately from sandbox observations.
Rule availability and completed execution are different things.
Inspect the rulesWork with agent tools
Use the site's WebMCP tools from a supporting agent, or examine the declared surface of your own WebMCP page.
Declared tool surfaces have explicit assessment limits.
Explore agent toolsThe integration shelf
Ways to scan
Bring an MCP server to the 184 detection rules from a browser, terminal, CI job, MCP client, or agent. The reachable checks depend on the inputs and execution capabilities; the result records which ones ran.
Scan any server
Paste a live URL, an npx/uvx launch command, an MCP client config, or a GitHub, npm or PyPI reference. A URL gets read-only enumeration; a repository gets a static scan; a published package or a config is launched in the sandbox by default where this host can build a confining sandbox, and scanned statically where it cannot - never a live URL. The form states a ceiling of how many rules the input can reach; the report shows what ran and how.
CLI - npx mcp-sentinel
A standalone static-analysis tool for the machine you are on. check scans the servers in your local MCP client config (Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, Gemini CLI, Kiro and project-local mcp.json files are auto-discovered); scan <url> connects to a live server with read-only enumeration and runs the rules; discover lists every MCP config found across your tools; verify <path> checks a signed compliance report offline. --json is a stable contract, and --ci /--fail-on <severity> turn findings into an exit code.
npx mcp-sentinel check --ci npx mcp-sentinel scan https://example.com/mcp --json npx mcp-sentinel discover npx mcp-sentinel verify ./report.json
REST API
The public API is anonymous and read-only, apart from the three POSTs below that submit a scan, a sandbox run, or a cross-server analysis. Base URL: https://mcp-sentinelapi-production.up.railway.app. Responses carry the same verdict the registry shows.
- GET /api/v1/servers - paginated, filterable list
- GET /api/v1/servers/:slug
- GET /api/v1/servers/:slug/findings
- GET /api/v1/servers/:slug/history - verdict and findings over time
- GET /api/v1/servers/:slug/badge.svg - verdict badge
- GET /api/v1/servers/:slug/flow - sandbox-observed behavior; data: null when none on file
- GET /api/v1/servers/:slug/compliance/:framework.{json,html,pdf} - signed report
- GET /api/v1/servers/:slug/compliance/:framework/badge.svg
- GET /api/v1/ecosystem/stats
- GET /api/v1/scan/capabilities - the live rule ceilings per input kind
- GET /api/v1/scan/:id - result of a submitted scan
- POST /api/v1/scan - starts a scan: by default a sandbox run of a config or a published package where a runner exists, else a static scan; a read-only enumeration for a URL
- POST /api/v1/scan/jailed - anonymous sandbox run of a config (a legacy alias - POST /api/v1/scan with depth:"sandbox" is the primary path)
- POST /api/v1/risk-matrix - cross-server analysis over listed servers; computes, stores nothing
- GET /health
Badge embed
The badge renders a server's coverage-aware verdict (Safe / Caution / Risk / Insufficient coverage) and links to its registry page. Replace YOUR-SERVER-SLUG with the slug from the server's URL.
[](https://mcpsentinel.dev/servers/YOUR-SERVER-SLUG)
MCP scanner server
npx mcp-sentinel-scanner is itself an MCP server. Add it to Claude, Cursor or any MCP client and ask in plain language: scan_server analyses tool metadata and source you pass in, scan_endpoint performs read-only enumeration of a live URL, and list_rules explains what is checked.
Agent tools / WebMCP
This site registers WebMCP tools on document.modelContext, so a WebMCP-capable agent can query the registry or scan an npm/PyPI package directly. If you ship a WebMCP product, scan the tool surface it declares to agents - the page is honest about what a declared surface can and cannot check.
GitHub Action
Runs mcp-sentinel check --ci against the MCP config in your repository on every push or pull request and fails the job on a high or critical finding (override with fail-on). Outputs worst-verdict, findings-count and scanned for later steps.
Words with a boundary
What the words mean
- Static scan
- The published artifact or repository is fetched and analyzed. Nothing is executed.
- Read-only enumeration
- Against a live endpoint we call initialize and the list methods (tools/list, resources/list, prompts/list) and never invoke a tool.
- Sandbox run
- Our own copy of the published package, run inside a sandbox this host must first prove can block network egress and confine the filesystem. When it cannot, the run is refused and reported as not observed - never quietly downgraded.
- Cross-server analysis
- How two or more servers in one client configuration combine - needs at least two servers.
- Cross-server flow
- A path from one server's reader to another's sink. Always labelled observed (witnessed in a sandbox run) or inferred (joined statically from what the servers declare).
- Kill-chain patterns
- Multi-step attack chains matched against documented templates. Always hypothetical: a pattern the configuration permits, not something we watched happen.
- Listed in the registry
- The result is added to the public registry under the server's identity.
- Not listed in the registry
- Findings are returned to you and withheld from the public registry.
- Rule-scoped run
- You chose a subset of the rules to evaluate. The result is not an assessment of the server and is never listed in the registry.
- Verdict
- Risk when a critical finding or a lethal-trifecta pattern was observed; Caution on a high finding; Safe only when nothing serious was found and coverage was sufficient to certify it; otherwise Insufficient coverage. A clean result under thin coverage is never called Safe.
About the project
About MCP Sentinel
How the rules are built, how the scan pipeline runs, how the verdict is derived, and which frameworks the findings map to.
Responsible disclosure
How we report vulnerabilities found in MCP servers through our scanning, and how to reach us about a finding on your own server.
02 / Choose your interface
Different instruments.
The same need for evidence.
Bring the documented API, CLI, GitHub Action, or MCP tools into the place you work. Read the assessment method, findings, and execution gaps alongside the verdict.
A live endpoint supplies its declared surface through read-only enumeration. Runtime evidence requires a fetched artifact running in a sandbox that proves filesystem confinement and blocks network egress.
An interface changes how you request an assessment; its inputs still determine what can be checked.
Explore the agent interfaceKeep the evidence in view
A useful answer includes its limits.
Static analysis reads an artifact. Read-only enumeration lists a live endpoint's declarations. A sandbox run executes a confined copy after the host verifies the execution boundary. The report tells you which method supplied its evidence.