# Verify MCP

Verify MCP is a public MCP server with two tools. Give it a product page URL and
it tells you whether the page carries an authentic Mintall certificate. Give it
an image URL and it reads the C2PA credential embedded in the image.

The agent sends a URL. Mintall fetches the page and checks the certificate's
RS256 signature and its domain, product, and URL binding against the registry.
It returns a verdict and the checks behind it. 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 tools are there. You should see two:
   `verify_mintall_certificate` and `inspect_image_credentials`.

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, and [the image tool](/mcp/image-tool) for images.

**A URL that is not certified is not a failure:** A page without a Mintall certificate 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 `"freshness": "fresh"`, with no
MCP client involved.