Compuute MCP Security Scanner

io.github.CompuutePublished by GitHub account Compuutev0.3.0Updated Oct 24, 2026

Scan any public GitHub MCP-server repo for security issues. 37 MCP-specific L1 rules, 8 languages.

The publisher's own server: scan.mx Email Diagnostics

VerifiedStreamable HTTPWeb executableDeveloper Tools Security & Monitoring

Server details

Identifier: io.github.Compuute/compuute-scan-api
Transport: Streamable HTTP
Runtime: Web executable
Trust: Verified
Published: Sep 16, 2026

Security note

MCP servers receive tool arguments from a conversation and may perform external actions. Review what a server can do before you enable it, and give it only the access it needs.

The registry verified the GitHub account Compuute for this listing. That does not show the account is the product's maker.

SourceWeft's checks cover whether the listing is complete and the endpoint answered; they do not review the server's code or what its tools do.

Add a badge to your README

Show readers this MCP server is listed on SourceWeft. The badge links to this page.

[![Listed on SourceWeft](https://sourceweft.com/badge/mcp/io.github.Compuute%2Fcompuute-scan-api.svg)](https://sourceweft.com/mcp/io.github.Compuute%2Fcompuute-scan-api?utm_source=readme&utm_medium=badge)

Overview

AI-generated overview

A remote MCP server that scans a public GitHub MCP-server repository for security issues and returns a scored, severity-ranked static-analysis report.

What you can do: Scan a public GitHub MCP-server repository: clone it shallowly, run the compuute-scan static analyzer, and return severity counts, a 0-100 score, a recommendation and the ten most severe findings, with a disclaimer attached to every response.
When to use it: Useful when you want a quick, agent-callable first pass over an MCP server's source before adopting or reviewing it, and you treat the output as a triage queue rather than confirmed vulnerabilities.
Requirements: A remote streamable HTTP endpoint; no authentication, API key or local runtime is declared. The target must be a public GitHub repository, and the service is rate-limited on the free tier.

Before you install

The README states the scanner is a pattern-breadth detector, not an exploitability oracle, with roughly 90% false positives on raw output, so findings need manual validation. The repository URL is sent to a third-party service. A paid scan path exists (micropayment in USDC on Base), but the exposed tool is the free scan.

Installation

In SourceWeft

Open Compuute MCP Security Scanner in the dashboard and add it to a workspace.
Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.Compuute%2Fcompuute-scan-api/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "compuute-security-scanner": {
      "type": "http",
      "url": "https://scan.compuute.se/mcp/"
    }
  }
}

README

compuute-scan-api

Scan-as-a-Service for MCP servers. HTTP + MCP wrapper around compuute-scan — the MCP-specific static security scanner. Designed for agent-callable consumption.

POST a public GitHub repo URL → get a structured security report scored against 38 MCP-specific rules across 8 languages (TS/JS, Python, Go, Rust, C#, Java, Kotlin).

Honesty note (read first): compuute-scan is a pattern-breadth detector, not an exploitability oracle. Historic false-positive rate after manual validation is ~90% on raw output (verified against modelcontextprotocol/servers: 138 raw findings → 13 confirmed). Every response carries a _disclaimer field stating this explicitly. Use findings as a triage queue, not as a list of confirmed vulnerabilities. See docs/FP-RATES.md for per-rule transparency.

Live at https://scan.compuute.se. Service version reported by /v1/health.

Endpoints

Core scan

POST /v1/scan/pay with no body to read the payment requirements without paying — the request body is optional precisely so discovery probes reach the 402 instead of body validation. Verify with the Coinbase Agentic Wallet CLI:

Machine-readable contracts

MCP server (live)

Install in Claude Code: claude mcp add compuute-scan --transport http --url https://scan.compuute.se/mcp/

Discovery (`/.well-known/`)

Path	Format	Consumer
`/.well-known/agent-card.json`	A2A v1.0 Agent Card (canonical)	A2A protocol clients
`/.well-known/agent.json`	A2A Agent Card (alias)	pre-1.0 A2A clients/crawlers
`/.well-known/ai-plugin.json`	OpenAI plugin manifest	ChatGPT / OpenAI tools
`/.well-known/x402.json`	x402 payment manifest	Coinbase Agent.market crawlers, x402 aggregators
`/.well-known/x402`	Alias of `x402.json`	x402 probes without `.json` suffix
`/llms.txt`	markdown summary	LLM-driven agent-search crawlers (Exa, Perplexity-style) per llmstxt.org
`/robots.txt`	crawler policy	search engines
`/sitemap.xml`	URL index	search engines

Example

bash

curl -X POST https://scan.compuute.se/v1/scan \  -H 'Content-Type: application/json' \  -H 'Idempotency-Key: 00000000-0000-0000-0000-000000000001' \  -d '{"repo_url": "https://github.com/modelcontextprotocol/servers"}'

curl -X POST https://scan.compuute.se/v1/scan \  -H 'Content-Type: application/json' \  -H 'Idempotency-Key: 00000000-0000-0000-0000-000000000001' \  -d '{"repo_url": "https://github.com/modelcontextprotocol/servers"}'

Response (truncated):

json

{  "repo_url": "https://github.com/modelcontextprotocol/servers",  "scanner": {"name": "compuute-scan", "version": "0.6.2", "layers_covered": ["L0", "L1"]},  "summary": {"critical": 1, "high": 94, "medium": 22, "low": 0, "files_scanned": 77},  "score": 0,  "recommendation": "AVOID — 1 critical and 94 high finding(s)...",  "top_findings": [...],  "performance": {"clone_seconds": 1.2, "scan_seconds": 0.5, "repo_size_bytes": 41234},  "_disclaimer": "PATTERN MATCH — compuute-scan is a static analyzer..."}

{  "repo_url": "https://github.com/modelcontextprotocol/servers",  "scanner": {"name": "compuute-scan", "version": "0.6.2", "layers_covered": ["L0", "L1"]},  "summary": {"critical": 1, "high": 94, "medium": 22, "low": 0, "files_scanned": 77},  "score": 0,  "recommendation": "AVOID — 1 critical and 94 high finding(s)...",  "top_findings": [...],  "performance": {"clone_seconds": 1.2, "scan_seconds": 0.5, "repo_size_bytes": 41234},  "_disclaimer": "PATTERN MATCH — compuute-scan is a static analyzer..."}

Agent-shaped API features

Feature	How
Idempotent retries (24h cache)	`Idempotency-Key` header
HTTP cache	`ETag` + `Cache-Control: public, max-age=1800`
Conditional GET	`If-None-Match` → 304 Not Modified
Rate-limit headers	`X-RateLimit-Limit/Remaining/Reset`
Strict input validation	Pydantic `extra="forbid"`, GitHub-HTTPS-only
OWASP security headers	HSTS / X-Frame-Options / X-Content-Type-Options / CSP / Referrer-Policy / Permissions-Policy
OpenAPI for discovery	`GET /openapi.json` with descriptions on every field
MCP for agent discovery	`/mcp/` exposes `scan_mcp_server` tool
x402 for autonomous purchase	`/v1/scan/pay` returns 402 with USDC/Base payment requirements
Honest framing	Every response carries `_disclaimer` — pattern match, not exploitability claim

Pricing

Tier	Audience	Price
Open Source CLI	Indie devs, agent builders	$0 — `npx compuute-scan ./repo`
Hosted API (free)	Agent operators evaluating MCP servers	$0 — `POST /v1/scan`, rate-limited
Hosted API (x402)	Autonomous agents in Agent.market ecosystem	$0.10 USDC/scan — `POST /v1/scan/pay`
MCP Security Audit	Enterprises shipping MCP to production	$5K–$30K SoW
AI Procurement Risk Audit	CFO/CTO/CISO buying enterprise AI capacity	$5K–$15K SoW

Full breakdown with JSON-LD: https://compuute.se/pricing.

Local development

bash

python3 -m venv venv && source venv/bin/activatepip install -r requirements.txtexport COMPUUTE_SCAN_PATH=$HOME/compuute-scan/compuute-scan.jsuvicorn main:app --reload

python3 -m venv venv && source venv/bin/activatepip install -r requirements.txtexport COMPUUTE_SCAN_PATH=$HOME/compuute-scan/compuute-scan.jsuvicorn main:app --reload

x402 payment env vars (all optional locally; /v1/scan/pay returns 503 until the wallet is set):

Var	Purpose	Default
`X402_WALLET_ADDRESS`	Base L2 address receiving USDC	unset (x402 disabled)
`X402_NETWORK`	CAIP-2 network id — `eip155:8453` (Base mainnet) or `eip155:84532` (Base Sepolia)	`eip155:8453`
`X402_PRICE_USD`	Price per scan	`0.10`
`X402_FACILITATOR_URL`	Facilitator base URL	CDP facilitator (serves both networks)
`CDP_API_KEY_ID` / `CDP_API_KEY_SECRET`	CDP API key for facilitator verify/settle auth	unset (verify will be rejected)

Rehearsing payments on testnet

Set X402_NETWORK=eip155:84532 to quote prices in Base Sepolia USDC, which is free from a faucet. The CDP facilitator serves Sepolia too, so a testnet payment exercises the real verify/settle path and your real CDP API keys — without moving real money.

Asset address and EIP-712 domain are selected together per network: Base mainnet USDC signs as "USD Coin", Base Sepolia as "USDC". Mixing them fails every signature with an error that looks like a bad API key, which is why they live in one NETWORKS table rather than separate env vars.

Mainnet is the default and an unknown value falls back to it, so a typo can never silently ask real agents to pay in worthless testnet USDC. Check which mode is live with curl -s https://scan.compuute.se/v1/health — the x402 block reports network and testnet.

Tests

Scripts

Script	What it does
`scripts/precheck.sh`	Start-of-session check: branch, working tree, tests, live state, next backlog item
`scripts/postcheck.sh`	End-of-session check: committer hygiene, tests, append to `docs/PROGRESS.md`
`scripts/status.sh`	30-second live-state check against scan.compuute.se (4 probes)
`scripts/sbom.sh`	Generate CycloneDX SBOM, optionally upload to a GitHub Release
`scripts/prospect-research.sh`	Pull qualified prospects from GitHub + Anthropic Registry, draft DM angles
`scripts/measure-tiers.sh`	T0/T1/T2 distribution snapshot per docs/agent-economy-strategy.md §5 — reach, engagement, conversion measured against Railway logs + Base RPC + GitHub stars

Architecture

api/services/scan.py — clone + sandbox + scan + parse. Pure functions.
api/services/x402_service.py — x402 v2 verify / settle on the official x402 SDK; CDP facilitator (Base mainnet) by default; Bazaar discovery extension in 402 bodies.
api/services/cdp_auth.py — minimal CDP API-key JWT auth for the facilitator (PyJWT + cryptography; avoids the full cdp-sdk).
api/serializers/scan_serializer.py — Pydantic models, strict validation.
api/routes/scan.py — HTTP layer for /v1/scan: idempotency, cache, ETag.
api/routes/scan_x402.py — HTTP layer for /v1/scan/pay.
api/routes/discovery.py — /.well-known/*, /robots.txt, /sitemap.xml.
api/mcp_server.py — FastMCP server exposing scan_mcp_server.
main.py — FastAPI wiring + middleware (security headers, CORS).

Bundled compuute-scan version is pinned in the Dockerfile (ARG COMPUUTE_SCAN_REF=v0.6.2).

Documentation

Doc	For
docs/agent-economy-strategy.md	The strategic doc — a16z-verified data, the 11-signal buyer-agent model, two-track strategy, 30-day pivot trigger. Read first if you're trying to understand the company.
docs/STRATEGY.md	Position, pricing tiers, roadmap, decision log
docs/ARCHITECTURE.md	Component diagram, request flow, threat model, deployment topology
docs/DEVELOPMENT.md	Local setup, layout, code style, common pitfalls — onboard a new dev in 30 min
docs/MONITORING.md	Endpoints to watch, automated checks, runbook for failures
docs/FP-RATES.md	Per-rule false-positive transparency
docs/scan-self-triage.md	What this scanner reports when run against its own code
docs/whitepaper/	MCP Security Methodology v1.0 (Markdown + PDF)
docs/case-studies/	Three anonymized engagement reports from the May 2026 batch
docs/advisories/	Public advisories under the `COMPUUTE-YYYY-NNN` numbering
docs/security/	Self-pentest reports (90-day cadence)
docs/audits/	The AI Procurement Risk Audit checklist (lead magnet)
docs/compliance/	SOC 2 Type I readiness statement, TSC control mapping
docs/submissions/	LangChain + CrewAI tool wrappers ready for PR/marketplace
skills/compuute-scan/	Claude Skill package (SKILL.md + scan.sh) — submitted to anthropics/skills#1346
CODE_OF_CONDUCT.md	Contributor Covenant 2.1
docs/launches/	Show HN draft + posting checklist
docs/setup/	Status page (BetterStack) + analytics (PostHog) setup guides
docs/agentic-market-submission.md	Three paths to Coinbase Agent.market listing
BACKLOG.md	GitHub Issues + Project board roadmap
IDEAS.md	Composted product hypotheses with gating rules
CONTRIBUTING.md	How to contribute
SECURITY.md	Vulnerability disclosure policy (90-day window)

Security

Found a vulnerability? See SECURITY.md — email [email protected]. We follow a 90-day coordinated disclosure window.

License

MIT (matches compuute-scan).

Author

Compuute AB — [email protected]

Source: README.md at commit 5089307

Tools

scan_mcp_server

Scan a public GitHub MCP-server repository for security issues. Clones the repo (shallow, <60s, <200 MB), runs compuute-scan v0.6.2 in static analysis mode (no code execution from the target), and returns a structured report with severity counts, a 0-100 score, and the 10 most severe findings. WHEN TO USE: - Before connecting to an unknown MCP server discovered via Anthropic Registry, Smithery, mcp.so, or a Discord recommendation. - Before installing a third-party MCP-server package into a production pipeline. - As part of an agent's pre-commit / pre-deploy due-diligence step when adding new dependencies. - As one input to a multi-source trust evaluation (combine with publisher reputation, package install count, last-update recency). WHEN NOT TO USE: - For private repos. Use the on-prem CLI instead: `npx compuute-scan ./path-to-private-repo` - For deep exploitability assessment of a specific code path. This is pattern matching, not dataflow analysis. Book a manual L2-L4 audit at https://compuute.se/audit for that depth. - For non-GitHub hosts (GitLab, Bitbucket, self-hosted). v1 supports github.com only. - For repos > 200 MB or clone time > 60s. The endpoint returns a 413 or 504 in those cases — fall back to local CLI. EXPECTED RESPONSE TIME: - Median: ~1-2 seconds for small repos (<100 files). - p99: ~10 seconds for medium repos. - Hard timeout at clone=60s, scan=120s combined. EXPECTED COST: - Free tier in MVP. Future Pro tier may charge per-scan or per-month. DATA FRESHNESS: - Scanner version is reported in response.scanner.version. - L1 rule set freshness reflects compuute-scan releases — see github.com/Compuute/compuute-scan/CHANGELOG.md for the latest CVE and threat-intel response timeline. EXAMPLES: Example 1 — scan an MCP server you'r

Parametersgithub_urlrequired

Version history

v0.3.0LatestSep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

Reached in the last 30 daysRequired25 pts
Auth declaredRequired10 pts
Tools listedRequired15 pts
DescriptionRequired15 pts
Logo10 pts
Documentation15 pts
License10 pts

Other Scan integrations

scan.mx Email Diagnostics

mx.scanOfficial publisher

Remote MCP server that lets an assistant run graded email deliverability and DNS checks on a domain, covering MX, SPF, DKIM, DMARC, blacklists and more.

Streamable HTTPWeb executable

Developer Tools9 toolsOct 25, 2026