# Verify MCP

Verify MCP is a public MCP server with one tool. Give it a product page URL and
it tells you whether the page carries an authentic Mintall certificate.

A language model cannot check an RS256 signature inside its context window.
Asked to verify a proof, it guesses. This server is the answer to that: the
agent sends a URL, Mintall fetches the page, verifies the certificate against
the registry, and returns a plain verdict. The agent never handles the JWT.

```
https://verify-mcp.mintall.ai/mcp
```

## Connect

### Claude Code

```bash
claude mcp add --transport http verify-mintall https://verify-mcp.mintall.ai/mcp
```

Add `--scope user` to install it once and reuse it in every project, or
`--scope project` to write a committed `.mcp.json` your team shares.

### Claude Desktop

**Settings → Connectors → Add custom connector**, then save and toggle it on:

```
https://verify-mcp.mintall.ai/mcp
```

Leave the authentication fields empty. There is no sign-in prompt.

### ChatGPT

Create a custom connector pointing at the same URL, with no authentication.

### Codex

```bash
codex mcp add verify-mintall --url https://verify-mcp.mintall.ai/mcp
```

Or add it to `~/.codex/config.toml` by hand:

```toml
[mcp_servers.verify-mintall]
url = "https://verify-mcp.mintall.ai/mcp"
```

### Cursor

[Install in Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=verify-mintall&config=eyJ1cmwiOiJodHRwczovL3ZlcmlmeS1tY3AubWludGFsbC5haS9tY3AifQ==)

Or add it to `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "verify-mintall": {
      "url": "https://verify-mcp.mintall.ai/mcp"
    }
  }
}
```

### VS Code

[Install in VS Code](https://vscode.dev/redirect/mcp/install?name=verify-mintall&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fverify-mcp.mintall.ai%2Fmcp%22%7D)

Or add it to `.vscode/mcp.json` in your workspace:

```json
{
  "servers": {
    "verify-mintall": {
      "type": "http",
      "url": "https://verify-mcp.mintall.ai/mcp"
    }
  }
}
```

### Any other MCP client

MCP is an open protocol. Follow your client's setup steps and give it the
server URL with the streamable HTTP transport. Leave every authentication
field empty.

## Check it worked

1. Confirm the server connected. In Claude Code, run `/mcp` or
   `claude mcp list`. Other clients list their servers in settings.

2. Confirm the tool is there. You should see one:
   `verify_mintall_certificate`.

3. Ask the agent to use it, with any product page URL:

   ```
   Verify the Mintall certificate on https://store.example/products/everyday-tote
   ```

You get back a verdict, the domain the certificate was issued to, and the
individual checks behind it. See [the verify tool](/mcp/tool) for the full
result shape.

**A URL that is not certified is not a failure:** Most product pages carry no Mintall certificate at all. That comes back as
  `no_certificate` or `unverified`, which means the page carries no signed
  claim. It is not evidence of a problem with the merchant.

## Call it from your own agent

If you are building an agent rather than configuring a client, connect with an
MCP SDK.

```python
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

url = "https://verify-mcp.mintall.ai/mcp"

async with streamablehttp_client(url) as (read, write, _):
    async with ClientSession(read, write) as session:
        await session.initialize()
        result = await session.call_tool(
            "verify_mintall_certificate",
            {"page_url": "https://store.example/products/everyday-tote"},
        )
```

  ```ts
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const client = new Client({ name: "my-agent", version: "1.0.0" });

await client.connect(
  new StreamableHTTPClientTransport(
    new URL("https://verify-mcp.mintall.ai/mcp"),
  ),
);

const result = await client.callTool({
  name: "verify_mintall_certificate",
  arguments: { page_url: "https://store.example/products/everyday-tote" },
});
```

  Prefer plain HTTP? The same verification is a single POST to the
[page checks](/api/page-checks) endpoint, with no MCP client involved.