Lenz MCP Server

Lenz is a fact-checking platform. It takes a factual claim, runs it through a multi-model pipeline (reading the claim → research → debate → panel review → conclusion) against independent sources, and returns a verdict with a confidence level. This is the official remote MCP server — a hosted Model Context Protocol endpoint that exposes Lenz's fact-checking as tools your AI assistant can call.

It verifies claims against the open web, independent of whatever context your model was given — so it complements retrieval/groundedness checkers rather than replacing them.

• Hosted, no install: point your client at https://lenz.io/mcp. Nothing to run locally.

• Auth: OAuth (no key — for clients that support it) or a free Lenz API key (Authorization: Bearer lenz_…).

• Transport: Streamable HTTP, stateless. Supports the 2025-11-25 and 2026-07-28 protocol revisions.

Tools

Prompts. Clients that surface MCP prompts (Claude shows them under +) get two: Check this text with Lenz and Check your last answer with Lenz. Each takes the text to check and starts a quick check. Lenz cannot see the conversation, so Check your last answer needs the answer pasted in.

Verdicts are directional, not absolute: confidence is returned as bucketed language with a caveat, not a calibrated probability. A quick verdict is a first read; when a deep check disagrees with it, the deep check is the one to rely on, because it shows its sources and its reasoning.

Related MCP server: Groundcheck

The result card

In Claude and the ChatGPT app, a check comes back as a card in the conversation as well as text. From the card you can run the deep check on a claim (Check against sources, a standard-depth verify_claim), open a source, or pick which claims in a draft to check in depth. When a deep check started from the card finishes, the assistant is told the result: silently in Claude, and by a short message in the chat in ChatGPT. Every other client gets the same results as text; nothing depends on the card.

Quickstart

Two ways to connect, depending on your client:

• OAuth — for clients that support it (e.g. Claude connectors). No key to paste; you sign in to Lenz and authorize the connection.

• API key — works with any MCP client via an Authorization header.

Connect with OAuth (no API key)

Claude (web, desktop and mobile): Lenz is an official Claude connector. Open the Lenz connector page and click Connect to Claude, or in the app: Settings → Extensions → Browse extensions, search for Lenz and click +. Either way it is a one-time OAuth sign-in with nothing to configure, and one account covers all three.

For any other client that supports OAuth for MCP, add the server with just its URL and no headers:

{
  "mcpServers": {
    "lenz": {
      "type": "http",
      "url": "https://lenz.io/mcp"
    }
  }
}

The first time you use it, your client walks you through a one-time sign-in: you authenticate on Lenz's own screen and authorize the connection — no key is stored in your config. Your assistant then fact-checks on your behalf against your Lenz account's credits. You can revoke the connection at any time; see the privacy policy.

Connect with an API key

1. Get a free API key at lenz.io/api-credentials (format lenz_…).

2. Add the server to your client (examples below). Authenticate with Authorization: Bearer <your-key>.

Claude Code

claude mcp add --transport http lenz https://lenz.io/mcp \
  --header "Authorization: Bearer ${LENZ_API_KEY}"

Claude Desktop / any client that reads .mcp.json

{
  "mcpServers": {
    "lenz": {
      "type": "http",
      "url": "https://lenz.io/mcp",
      "headers": {
        "Authorization": "Bearer ${LENZ_API_KEY}"
      }
    }
  }
}

Cursor

One click: use the Add Lenz to Cursor button above — it adds the server and signs you in via OAuth (no key to paste).

Manual: Settings → MCP → Add new MCP server → type HTTP, URL https://lenz.io/mcp, and add a header Authorization: Bearer <your-key>. (Or drop the JSON above into .cursor/mcp.json.)

VS Code

One click: use the Install in VS Code button above (OAuth, no key). Manual, with a key:

code --add-mcp '{"name":"lenz","type":"http","url":"https://lenz.io/mcp","headers":{"Authorization":"Bearer ${LENZ_API_KEY}"}}'

ChatGPT

At this time, ChatGPT connects to Lenz as a custom app through OpenAI's Developer mode — over OAuth, so there is no API key to paste. It is set up on chatgpt.com; the ChatGPT desktop and mobile apps cannot create one.

On a personal account (Plus or Pro). Settings → Plugins → turn on Developer mode at the bottom → Plugins → Browse plugins → + next to Search → name it Lenz, URL https://lenz.io/mcp, Authentication OAuth → tick I understand and want to continue → Create → Sign in with Lenz → Try in Chat.

In a Business, Enterprise or Edu workspace. An owner or admin publishes it once: Workspace settings → Apps → + Create, confirm Enable developer mode, fill in the same form with OAuth, then Drafts → Publish, set who can use it, and Publish again. Each member then goes to Settings → Plugins → Lenz → Connect and signs in.

A custom app is off by default in every new chat: + and tick Lenz. Naming Lenz in the question is what makes ChatGPT reach for it rather than answer from memory.

MCP Inspector (try the tools by hand)

npx @modelcontextprotocol/inspector
# Transport: Streamable HTTP · URL: https://lenz.io/mcp
# Header: Authorization: Bearer <your-key>

Example

You: Check with Lenz whether indeed 90% of startups fail within their first year.

The assistant calls assess_claim and gets back False, high confidence, with the reviewers' reasoning: most new businesses survive their first year, and official figures put first-year closures at about one in five. It presents that as a first read and offers a deep check. On your yes it calls verify_claim (and, in clients with a short tool-call limit, get_verification to collect the result) and returns the verdict with its score, the key finding, the warnings and the sources behind it.

Credits

Every tool call draws on one pool of credits on your Lenz account. There is no separate budget per tool: spending on assess_claim reduces what is left for verify_claim, and vice versa. check_usage returns the balance (credits_remaining) alongside costs, the live price list — read the weight from there rather than assuming one.

verify_claim is the expensive path by an order of magnitude; assess_claim and ask_followup are the cheap ones. verify_claim also takes an optional depth: "low" runs a shallower research pass (fewer sources, the same models, only slightly quicker) for half the credits of the default "standard". That price sits under cost_options.verify.depth.low on check_usage. You are charged for the depth you request; the depth on the completed result is the depth the verdict was produced at, so a "low" request answered from an existing deeper check reads "standard" — the echo describes the evidence, the charge follows the request.

check_usage also reports assess_remaining and verify_remaining, which are the SAME balance projected into each tool's own unit — "how many of these could I still make" — not separate allowances.

Free keys include a monthly allowance that resets each period; grants and top-ups add non-expiring extra credits on top, spent only once the allowance is gone. See plans at lenz.io/plans.

When you run out, tools return status: "quota_exhausted" with a message and, except in ChatGPT, a manage_url pointing at the plans page. It is not retryable — the balance is spent until you top up or the monthly allowance resets. An agent should say so plainly rather than retrying or quietly skipping the check.

status: "rate_limited" is a different thing: a rate limit, not a spent balance. That one does clear on its own, and the result carries retry_after_seconds telling you when.

Skills

Prefer a guided workflow to calling the tools yourself? The lenz-fact-check skill turns "is this true?" into a structured pass: it runs a quick check on the text, recommends a deep verify_claim for the claims that matter, and reports verdicts with their confidence, and sources where a deep check ran (with the directional-not-absolute caveat built in). Point your agent at skills/lenz-fact-check/SKILL.md.

Running the server yourself

The hosted endpoint is all most clients need. The server's source is in this repository if you want to run your own copy or contribute.

Requirements: Python 3.11 or 3.12, and uv. Python 3.13 is not supported yet: it changes how the tool descriptions the models read are formatted, so it waits for a release that checks the wording on it.

uv sync --group dev
uv run pytest
docker build --build-arg LENZ_MCP_VERSION=dev -t lenz-mcp .

A copy you run yourself authenticates with your own Lenz API key, sent as Authorization: Bearer lenz_…. OAuth sign-in works only on the hosted endpoint, https://lenz.io/mcp.

CONTRIBUTING.md covers the tests, the result card and the pull-request rules.

Links

• Website: lenz.io

• Get a key: lenz.io/api-credentials

• Developer docs: lenz.io/developers

• SDKs: Python · Node

Support

Questions or issues? Open an issue or get in touch.

License

Apache-2.0 © lenzhq. The Lenz name and logos (assets/) are trademarks of lenzhq and are not granted by the license — see NOTICE.

Maintainer

@paveljor