> ## Documentation Index
> Fetch the complete documentation index at: https://docs.noxint.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP server

> If your agent speaks MCP, it is one config block away from the live tape

<Note>
  This is not vaporware documentation. The API and MCP server run in production
  today, serving the chat analyst every answer it gives. Public access opens in
  beta after launch: key minting and credit packs open with the beta. This page
  documents the live contract. [Launch status](/token/status) tracks what is on
  today.
</Note>

Noxint is a native Model Context Protocol server at
`https://noxint.ai/api/mcp`. Not a wrapper bolted on after the fact: the same
23 operations, the same parameters, the same data-credit billing, and the
same idempotency as the HTTP API, exposed as MCP tools. If you already run an
MCP client, this is the fastest way to hand an agent live market data. One
config block, done.

The transport is stateless streamable HTTP in JSON response mode. Every
request is a `POST` and must send `Content-Type: application/json` and an
`Accept` header that includes both `application/json` and
`text/event-stream`.

## Methods

The server supports `initialize`, `ping`, `tools/list`, `tools/call`,
`resources/list`, `resources/read`, and `resources/templates/list`. Discovery
methods (`initialize`, `tools/list`) are keyless. Documentation sections are
also exposed as resources under `noxint://docs/<section>`, so an agent can
read the manual over the same wire it trades data on.

The supported protocol versions are `2025-11-25` (latest), `2025-06-18`, and
`2025-03-26`. The server reports itself as `noxint-market-data`, version
`1.0.0`.

## Tools

Exactly 23 tools, one per operation, each named identically to its HTTP
operation (`read`, `funding`, `financials`, and so on). Each tool takes the
same parameters as the operation and is marked read-only and idempotent.
`tools/list` returns every tool with its input schema, so an agent discovers
the full surface without a key and without a human writing glue code.

Only `docs` and `schema` are fully keyless. `resolve`, `coverage`, and
`usage` authenticate but cost nothing. Every other tool spends data credits
exactly as the HTTP operation does.

## Authentication

Paid tool calls send the personal key as an `Authorization: Bearer` header on
the POST. Authentication happens inside `tools/call`. A paid tool called
without a key returns a tool result with an `unauthenticated` error and
`isError` set, rather than a transport-level failure, so agent loops degrade
cleanly instead of crashing.

## Client configuration

Point a streamable-HTTP MCP client at the endpoint and pass your key in the
`Authorization` header.

```json theme={null}
{
  "mcpServers": {
    "noxint": {
      "transport": "streamable-http",
      "url": "https://noxint.ai/api/mcp",
      "headers": {
        "Authorization": "Bearer nx_your_key"
      }
    }
  }
}
```

## Example tool call

A `tools/call` request names the tool and passes its arguments. String-list
arguments such as `ids` are joined with commas, matching the HTTP query.

```bash theme={null}
curl -X POST 'https://noxint.ai/api/mcp' \
  -H 'Authorization: Bearer nx_your_key' \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"read","arguments":{"id":"crypto:bitcoin"}}}'
```

The result carries the envelope in `structuredContent`, a text rendering in
`content`, and an `isError` flag.

```json theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [{ "type": "text", "text": "{\"data\":{...}}" }],
    "structuredContent": { "data": { "asset_id": "crypto:bitcoin" } },
    "isError": false
  }
}
```

## Billing and idempotency

MCP and HTTP share one idempotency namespace per personal key and normalized
operation, so an MCP retry can replay a result first produced over HTTP, and
it is charged once. Unlike HTTP, MCP has no conditional-header loop, so
re-polling the same tool always spends credits again. Check `usage` between
calls instead of re-polling.

<Note>
  MCP spends the same data credits as HTTP for the same work. Discovery,
  `docs`, and `schema` are free, so an agent can explore the entire tool
  surface before it spends anything.
</Note>