MCP server

Faro ships a Model Context Protocol server so an agent can verify links, payees, and messages mid-task. It exposes the same engine as the REST API through four tools:

Tool	When the agent should call it
`verify_url`	Before navigating to or trusting any third-party link.
`verify_payee`	Before initiating any payment.
`verify_message`	Before acting on inbound content.
`verify_before_pay`	Preferred for agent payments — pass the raw x402/AP2/ACP payload before settlement. On 🟡/🔴, pause-and-ask via MCP elicitation (advisory).
`verify_payment_intent`	Legacy flattened descriptor (merchant/payee/recipient) — use `verify_before_pay` for new integrations.
`watch_artifact`	After before-pay, register ongoing alerts when the entity turns bad (`artifact.flagged` webhooks). Hosted MCP only.
`report_verdict`	Flag a wrong verdict from the MCP Apps verdict card.

Each returns the full VerdictResult. As of v1.2, every tool advertises a typed outputSchema and emits structuredContent so agents can branch on recommended_action without parsing prose. Clients that do not negotiate structured output still receive a JSON-in-text fallback — the call never fails for lack of schema support.

Choose a transport

Faro now supports two deployment modes:

Local stdio for local development/private use.
Hosted streamable-HTTP for cloud agents and MCP marketplaces.

Local stdio (quickest)

The MCP server is a local stdio process, launched by your MCP client:

faro-mcp

Connect to Claude (local)

Add it to your Claude Desktop / Claude Code MCP config:

{
  "mcpServers": {
    "faro": {
      "command": "faro-mcp",
      "env": { "FARO_API_KEY": "<your-key>" }
    }
  }
}

Then ask Claude to "verify this link" and watch it call the tool.

Hosted streamable-HTTP (v1.1)

If you deploy Faro MCP as an HTTPS service, point your MCP client at:

https://<your-mcp-host>/mcp

Hosted mode requires a valid Bearer API key and applies server-side protections:

per-key rate limits
request body-size cap
per-call timeout
authenticated access only (401 without a valid key)

Example hosted server config

{
  "mcpServers": {
    "faro": {
      "transport": "streamable-http",
      "url": "https://mcp.farofinance.app/mcp",
      "headers": {
        "Authorization": "Bearer <your-key>"
      }
    }
  }
}

Typed output (v1.2)

When your MCP client negotiates structured tool output, Faro returns:

outputSchema on each tool — JSON Schema for the full VerdictResult (verdict, confidence, reason, recommended_action, signals, artifact, cache metadata).
structuredContent in the tool result — the same object as REST, ready to branch on recommended_action (allow, warn, block, review).

If the client does not support structured output, you still get a usable JSON payload in the text content block. The engine and verdict contract are unchanged.

Verify before pay (v1.2)

The verify_payment_intent tool accepts payment-protocol context (protocol: ap2 | x402 | acp, plus optional merchant, payee, recipient, resource_url, resource_domain) and runs the same mapping as POST /v1/verify/payment-intent. Faro returns the standard verdict; your agent runtime decides whether to settle.

{
  "protocol": "x402",
  "recipient": "Vladimir Putin",
  "resource_domain": "wallet.example"
}

Advisory only — Faro never moves money. See the verify-before-pay guide.

MCP Apps verdict card (v1.2)

Faro ships an MCP App UI so supported hosts can render a rich verdict card instead of raw JSON.

UI resource

Item	Value
Resource URI	`ui://faro/verdict-card`
MIME type	`text/html+mcp`
Bundled at	`src/faro/mcp_server/verdict-card/dist/verdict_card.html`

Each verify tool (verify_url, verify_payee, verify_message, verify_payment_intent) advertises the template in tool metadata:

{ "ui": { "resourceUri": "ui://faro/verdict-card" } }

When the host supports MCP Apps, it fetches the resource and renders the card in an iframe, passing the tool's structuredContent (the full VerdictResult) into the UI. The card shows verdict color, reason, recommended action, and key signals.

Progressive enhancement

Clients that do not support MCP Apps ignore the ui meta and behave exactly as before: typed structuredContent when negotiated, otherwise a JSON-in-text fallback. The engine and verdict contract are unchanged — the card is additive UX.

Report from the card

The card includes a Report wrong verdict action. It calls the MCP tool report_verdict, which maps to the same reputation path as POST /v1/reports:

Argument	Description
`artifact`	`{ "type": "url" \| "payee" \| "message", "value": "..." }`
`observed_verdict`	What Faro returned (`green`, `yellow`, `red`)
`reported_verdict`	What the user thinks it should be
`note`	Optional free-text context

Faro derives the report kind from the verdict delta (false_positive when the user thinks Faro was too harsh, scam when too lenient) and records it with reporter mcp_app. Cache invalidation and tier-2 reputation behave the same as a REST report.

Registry listing

Faro publishes a server.json manifest for the MCP Registry — the hosted streamable-HTTP endpoint at https://mcp.farofinance.app/mcp.