Passport OCR MCP server for agents

What your agent gets back

This is the difference that matters. An OCR tool that returns a page of text hands the model something to re-parse, and a model asked to re-parse a date will eventually invent one. This tool returns the fields already separated:

• The holder – given names, surname, birth date, sex, nationality.
• The document – kind, country, issuing state, number, series, date of issue, date of expiry, whether it has expired, and how many days remain.
• Every field found, each with its own confidence, read from the machine-readable zone and from the printed visual zone separately – so the model can see that the two readings agree, instead of assuming it.
• The machine-readable zone with a verdict: passed, failed or absent, with the reason, and the lines themselves.
• A one-line summary the assistant can show you as it works.

Failures come back as one readable line in an error block, never as a silent empty result: the assistant can act on it and can show it to you. A refusal from the API keeps the API's own wording, its error code, and the link to the page that explains it.

Install it in your client

Add the block to your client's MCP configuration and restart it. Set DOC_CHEAP_API_KEY to your own key, or leave it out and the public sandbox key is used instead.

{
  "mcpServers": {
    "doc-cheap": {
      "command": "npx",
      "args": [
        "-y",
        "@doc-cheap/mcp"
      ],
      "env": {
        "DOC_CHEAP_API_KEY": "sk_live_your_key"
      }
    }
  }
}

claude mcp add-json doc-cheap '{"command":"npx","args":["-y","@doc-cheap/mcp"],"env":{"DOC_CHEAP_API_KEY":"sk_live_your_key"}}'

{
  "mcpServers": {
    "doc-cheap": {
      "command": "npx",
      "args": [
        "-y",
        "@doc-cheap/mcp"
      ],
      "env": {
        "DOC_CHEAP_API_KEY": "sk_live_your_key"
      }
    }
  }
}

{
  "servers": {
    "doc-cheap": {
      "command": "npx",
      "args": [
        "-y",
        "@doc-cheap/mcp"
      ],
      "type": "stdio",
      "env": {
        "DOC_CHEAP_API_KEY": "sk_live_your_key"
      }
    }
  }
}

{
  "mcpServers": {
    "doc-cheap": {
      "command": "npx",
      "args": [
        "-y",
        "@doc-cheap/mcp"
      ],
      "env": {
        "DOC_CHEAP_API_KEY": "sk_live_your_key"
      }
    }
  }
}

{
  "mcpServers": {
    "doc-cheap": {
      "command": "npx",
      "args": [
        "-y",
        "@doc-cheap/mcp"
      ],
      "env": {
        "DOC_CHEAP_API_KEY": "sk_live_your_key"
      }
    }
  }
}

{
  "mcpServers": {
    "doc-cheap": {
      "command": "npx",
      "args": [
        "-y",
        "@doc-cheap/mcp"
      ],
      "disabled": false,
      "autoApprove": [
        "check_balance",
        "search_docs"
      ],
      "env": {
        "DOC_CHEAP_API_KEY": "sk_live_your_key"
      }
    }
  }
}

• Restart the client after adding the block. The server is launched by the client, so it only picks up a changed configuration and a changed environment on a fresh start.
• Without DOC_CHEAP_API_KEY the server falls back to the public sandbox key: scans then run inside its free allowance and there is no balance to report. That is the fastest way to see it work.
• Optional settings: DOC_CHEAP_DOCS_BASE (where search results link to), DOC_CHEAP_DOCS_DIR (which copy of the documentation to search), and DOC_CHEAP_IMAGE_ROOT (see the guards below).

Or connect to the hosted server

The same six tools are hosted at https://mcp.doc.cheap/mcp over Streamable HTTP, so a client that connects to a URL needs nothing installed. No login: send your key as X-Doc-Cheap-Api-Key or as Authorization: Bearer – the named header wins when both are sent – or send none and the public sandbox key is used. The hosted server cannot read files on your machine, so it takes the image as base64 or as an https URL.

https://mcp.doc.cheap/mcp

claude mcp add --transport http doc-cheap https://mcp.doc.cheap/mcp --header "Authorization: Bearer sk_live_your_key"

{
  "mcpServers": {
    "doc-cheap": {
      "url": "https://mcp.doc.cheap/mcp",
      "headers": {
        "Authorization": "Bearer sk_live_your_key"
      }
    }
  }
}

{
  "servers": {
    "doc-cheap": {
      "type": "http",
      "url": "https://mcp.doc.cheap/mcp",
      "headers": {
        "Authorization": "Bearer sk_live_your_key"
      }
    }
  }
}

In Claude Desktop and claude.ai, add it under Settings, Connectors, as a custom connector with the URL https://mcp.doc.cheap/mcp; without a key it runs on the sandbox key.

The six tools

• scan_document takes the image as image_base64, image_path or image_url, and the same options a direct call takes, among them expect_country, return_portrait, reference and idempotency_key.
• search_docs reads a copy of the documentation shipped beside the server, so it answers with no network at all – which means the agent can look up the field vocabulary or an error code without spending a call.
• check_balance needs a key with an account behind it. Under the public sandbox key it says plainly that there is no balance, rather than answering with zeros that look like a reading.
• Every tool declares an output schema and returns structured content that matches it, so an agent can use the fields without parsing text.
• Every page of the documentation is also a resource the agent can read, and four prompts – read a document into JSON, check an expiry date, scan a batch, explain an error code – start the common jobs in one step.

What it costs

$0.01 per recognised document. Flat, every account, at any volume – one number, and nothing to negotiate. A document is charged only when it was recognised: a scan that finds nothing, cannot read the image, or cannot identify the type answers with its verdict and costs nothing. Every result says which it was, so the agent – and you – always know whether that call spent anything.

Before you have an account: the public sandbox key runs 10 free recognised documents per IP address in all, at most 10 requests an hour whatever their answer. An account gets 100 free documents every month, used before paid credits. One credit is one cent is one document.

Recognition takes about 275 ms at the median in production, and each result carries its own timing, so an agent loop can budget against a real number.

The same price, the same key and the same response shape as a direct call: how billing works, and how it compares.

What the server reports

The server reports nothing anywhere by default: failure reporting is off unless you set a reporting endpoint yourself, and without one the tracker library is never even loaded.

Two guards worth knowing about

The server runs on your machine with your privileges, and its arguments are chosen by a model. Two of them are therefore fenced:

image_base64 carries none of these constraints, because the caller already holds the bytes – which is why every refusal above points at it.