A ready-to-paste configuration for every AI agent.

MCP serverClaude DesktopEvery parameter in the MCP documentation

api.bytnode.com/mcpinitializeconnectedtools/list11 toolsX-API-KEY

Your API key

It stays in this page: it fills the blocks below and is never sent or saved. Get a free key

Claude Desktop

API key or OAuth sign-in

Without a key (recommended): in Claude Desktop, open Customize → Connectors → Add custom connector, paste this URL and sign in to your BytNode account.
MCP server URL
```
https://api.bytnode.com/mcp
```

With your API key: open Settings → Developer → Edit config, paste this into claude_desktop_config.json and restart Claude Desktop. It runs the mcp-remote bridge, so Node.js 18+ must be installed: this file only starts local servers.

claude_desktop_config.json

{
  "mcpServers": {
    "bytnode": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote@latest", "https://api.bytnode.com/mcp",
        "--header", "X-API-KEY:${BYTNODE_API_KEY}",
        "--transport", "http-only"
      ],
      "env": { "BYTNODE_API_KEY": "YOUR_API_KEY" }
    }
  }
}

claude.ai

No key: OAuth sign-in

On claude.ai, open Customize → Connectors → Add custom connector, name it BytNode, paste this URL, then sign in to your BytNode account. No key to paste: the connector also works in Claude Desktop and on mobile.
MCP server URL
```
https://api.bytnode.com/mcp
```
On a Team or Enterprise plan, an owner adds it once for everyone under Organization settings → Connectors.

ChatGPT

No key: OAuth sign-in

ChatGPT can’t send an API key, so it connects with OAuth. In ChatGPT’s apps settings, turn on developer mode, then add a custom MCP server with this URL and choose OAuth.
MCP server URL
```
https://api.bytnode.com/mcp
```
ChatGPT opens the BytNode sign-in page: approve access, and the eleven tools appear in your chats. Developer mode depends on your ChatGPT plan.

Claude Code

API key or OAuth sign-in

Run this in a terminal. --scope user makes BytNode available in every project:

Terminal

claude mcp add --transport http --scope user bytnode https://api.bytnode.com/mcp --header "X-API-KEY: YOUR_API_KEY"

Without a key: add the server alone, then type /mcp in Claude Code to sign in to BytNode.
Terminal
```
claude mcp add --transport http --scope user bytnode https://api.bytnode.com/mcp
```

For a shared repository: commit this .mcp.json at the project root. Each developer keeps the key in the BYTNODE_API_KEY environment variable, never in the file.

.mcp.json

{
  "mcpServers": {
    "bytnode": {
      "type": "http",
      "url": "https://api.bytnode.com/mcp",
      "headers": { "X-API-KEY": "${BYTNODE_API_KEY}" }
    }
  }
}

Cursor

API key

Edit ~/.cursor/mcp.json for all your projects, or .cursor/mcp.json for this one:

~/.cursor/mcp.json

{
  "mcpServers": {
    "bytnode": {
      "url": "https://api.bytnode.com/mcp",
      "headers": { "X-API-KEY": "YOUR_API_KEY" }
    }
  }
}

BytNode shows up in the MCP list with its eleven tools. Keep the file out of git: it holds your key.

Codex

API key or OAuth sign-in

Add this table to ~/.codex/config.toml, or to .codex/config.toml in a trusted project. The CLI, the IDE extension and the app share it:
~/.codex/config.toml
```
[mcp_servers.bytnode]
url = "https://api.bytnode.com/mcp"
http_headers = { "X-API-KEY" = "YOUR_API_KEY" }
```
Without a key: register the URL, then sign in to BytNode in the browser that opens:
Terminal
```
codex mcp add bytnode --url https://api.bytnode.com/mcp
```
Terminal
```
codex mcp login bytnode
```

VS Code (GitHub Copilot)

API key

For GitHub Copilot’s agent mode, one command adds the server to your VS Code profile:

Terminal

code --add-mcp '{"name":"bytnode","type":"http","url":"https://api.bytnode.com/mcp","headers":{"X-API-KEY":"YOUR_API_KEY"}}'

For a workspace: commit .vscode/mcp.json. VS Code asks each developer for the key the first time, so it never lands in the repository:

.vscode/mcp.json

{
  "inputs": [
    { "type": "promptString", "id": "bytnode-key", "description": "BytNode API key", "password": true }
  ],
  "servers": {
    "bytnode": {
      "type": "http",
      "url": "https://api.bytnode.com/mcp",
      "headers": { "X-API-KEY": "${input:bytnode-key}" }
    }
  }
}

Windsurf (Devin)

API key

Windsurf is now Devin Desktop. Open ~/.config/devin/mcp_config.json (on Windows, %AppData%\devin\mcp_config.json) and add BytNode:
~/.config/devin/mcp_config.json
```
{
  "mcpServers": {
    "bytnode": {
      "url": "https://api.bytnode.com/mcp",
      "headers": { "X-API-KEY": "YOUR_API_KEY" }
    }
  }
}
```

Gemini CLI

API key

Run this in a terminal. -s user adds BytNode to every project:

Terminal

gemini mcp add -s user --transport http -H "X-API-KEY: YOUR_API_KEY" bytnode https://api.bytnode.com/mcp

Or edit ~/.gemini/settings.json. For Streamable HTTP the key is httpUrl, not url:

~/.gemini/settings.json

{
  "mcpServers": {
    "bytnode": {
      "httpUrl": "https://api.bytnode.com/mcp",
      "headers": { "X-API-KEY": "YOUR_API_KEY" }
    }
  }
}

n8n

API key

In your workflow, open the AI Agent node and add a tool: MCP Client Tool (n8n 1.104 or later).
Endpoint:
MCP server URL
```
https://api.bytnode.com/mcp
```
Server Transport: HTTP Streamable. Authentication: Header Auth, with a new credential: Name then Value:
Name
```
X-API-KEY
```
Value
```
YOUR_API_KEY
```
Tools to Include: All. Your AI agent can now call BytNode on every run.

LangChain

API key

Install LangChain and its MCP adapters, then put your key in the environment:
Terminal
```
pip install langchain langchain-anthropic langchain-mcp-adapters
```
Terminal
```
export BYTNODE_API_KEY=YOUR_API_KEY
```

Load the eleven tools and give them to a LangChain agent. Any chat model works; this one uses Claude:

Python

import asyncio, os
from langchain.agents import create_agent
from langchain_mcp_adapters.client import MultiServerMCPClient

async def main():
    client = MultiServerMCPClient({
        "bytnode": {
            "transport": "streamable_http",
            "url": "https://api.bytnode.com/mcp",
            "headers": {"X-API-KEY": os.environ["BYTNODE_API_KEY"]},
        }
    })
    tools = await client.get_tools()
    agent = create_agent("anthropic:claude-opus-5-5", tools)
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "Top 5 pairs by open interest?"}]}
    )
    print(result["messages"][-1].content)

asyncio.run(main())

OpenAI Agents SDK

API key

Install the OpenAI Agents SDK, then put your key in the environment:
Terminal
```
pip install openai-agents
```
Terminal
```
export BYTNODE_API_KEY=YOUR_API_KEY
```

Attach BytNode to an agent as a Streamable HTTP MCP server:

Python

import asyncio, os
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async def main():
    async with MCPServerStreamableHttp(
        name="bytnode",
        params={
            "url": "https://api.bytnode.com/mcp",
            "headers": {"X-API-KEY": os.environ["BYTNODE_API_KEY"]},
        },
        cache_tools_list=True,
    ) as bytnode:
        agent = Agent(
            name="Crypto analyst",
            instructions="Answer with BytNode live crypto market data.",
            mcp_servers=[bytnode],
        )
        result = await Runner.run(agent, "What is the BTC funding rate now?")
        print(result.final_output)

asyncio.run(main())

Claude API

API key

Install the Anthropic SDK, then put your BytNode key in the environment:
Terminal
```
pip install anthropic
```
Terminal
```
export BYTNODE_API_KEY=YOUR_API_KEY
```

The Messages API connects to the MCP server itself, with no client code: declare the server and its toolset. The key travels as a bearer token, which BytNode accepts:

Python

import os
import anthropic

client = anthropic.Anthropic()
response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    betas=["mcp-client-2025-11-20"],
    mcp_servers=[{
        "type": "url",
        "url": "https://api.bytnode.com/mcp",
        "name": "bytnode",
        "authorization_token": os.environ["BYTNODE_API_KEY"],
    }],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "bytnode"}],
    messages=[{"role": "user", "content": "Which pairs have the highest funding?"}],
)
for block in response.content:
    if block.type == "text":
        print(block.text)

OpenAI API

API key

Install the OpenAI SDK, then put your BytNode key in the environment:
Terminal
```
pip install openai
```
Terminal
```
export BYTNODE_API_KEY=YOUR_API_KEY
```

The Responses API calls remote MCP servers for you: declare BytNode as an mcp tool:

Python

import os
from openai import OpenAI

client = OpenAI()
response = client.responses.create(
    model="gpt-5",
    tools=[{
        "type": "mcp",
        "server_label": "bytnode",
        "server_url": "https://api.bytnode.com/mcp",
        "headers": {"X-API-KEY": os.environ["BYTNODE_API_KEY"]},
        "require_approval": "never",
    }],
    input="Which pairs have the highest funding right now?",
)
print(response.output_text)

Any other MCP client

API key or OAuth sign-in

Most MCP clients read this mcpServers object. Some leave out type, or call it streamableHttp: check your client’s documentation.

mcp.json

{
  "mcpServers": {
    "bytnode": {
      "type": "http",
      "url": "https://api.bytnode.com/mcp",
      "headers": { "X-API-KEY": "YOUR_API_KEY" }
    }
  }
}

If your client can only send a bearer token, BytNode reads the key from it:
HTTP header
```
Authorization: Bearer YOUR_API_KEY
```
If your client supports OAuth, paste the URL alone and sign in to BytNode: the server announces its authorization server itself.
MCP server URL
```
https://api.bytnode.com/mcp
```

One command in your terminal, or a configuration file.

Terminal

$ claude mcp add --transport http --scope user bytnode https://api.bytnode.com/mcp --header "X-API-KEY: YOUR_API_KEY"

$ claude mcp add --transport http --scope user bytnode https://api.bytnode.com/mcp

$ claude mcp list

.mcp.json

1{
2  "mcpServers": {
3    "bytnode": {
4      "type": "http",
5      "url": "https://api.bytnode.com/mcp",
6      "headers": { "X-API-KEY": "${BYTNODE_API_KEY}" }
7    }
8  }
9}

Coding agents add BytNode in one command. The configuration file does the same by hand, pasted as is.

Your coding agent

One command adds BytNode to every project. Without a key, type /mcp in Claude Code to sign in.

Read the MCP documentation Get a free API key

Without a key, an OAuth sign-in.

ChatGPT, claude.ai and Claude Desktop connect with the address alone. You sign in to BytNode: no key ever leaves your account.

Your AI app

In the apps settings, turn on developer mode, add an MCP server with this address and choose OAuth.

https://api.bytnode.com/mcp

Read the MCP documentation Get a free API key

ChatGPT

Add custom connectorNameBytNodeRemote MCP server URLhttps://api.bytnode.com/mcpAdd

In your agent’s code, a few lines are enough.

agent.py

1import asyncio, os
2from langchain.agents import create_agent
3from langchain_mcp_adapters.client import MultiServerMCPClient
4
5async def main():
6    client = MultiServerMCPClient({
7        "bytnode": {
8            "transport": "streamable_http",
9            "url": "https://api.bytnode.com/mcp",
10            "headers": {"X-API-KEY": os.environ["BYTNODE_API_KEY"]},
11        }
12    })
13    tools = await client.get_tools()
14    agent = create_agent("anthropic:claude-opus-5-5", tools)
15    result = await agent.ainvoke(
16        {"messages": [{"role": "user", "content": "Top 5 pairs by open interest?"}]}
17    )
18    print(result["messages"][-1].content)
19
20asyncio.run(main())

Terminal

$ pip install langchain langchain-anthropic langchain-mcp-adapters

$ export BYTNODE_API_KEY=YOUR_API_KEY

Agent frameworks and LLM APIs load the eleven tools from the address. The key stays in BYTNODE_API_KEY, never in the code.

Your framework or API

MultiServerMCPClient loads the eleven tools and hands them to any LangChain agent.

Read the MCP documentation Get a free API key

Eleven tools, inspect them before your agent does.

What your AI agent gets from tools/list. All read-only and idempotent: one target per tool, the same parameters everywhere, simple tool calling for the LLM.

tools/listget_pair_brief

Pair brief

read-only

The state of a pair in one call, always the same shape: price and changes, next funding, basis, open interest, CVD and the last 24 hours of liquidations. Each value comes with its context: where it sits in its own recent history.

Example call

tools/call

get_pair_brief(symbol="BTCUSDT")

Every parameter, field and response of the eleven tools, with a complete Python client. MCP reference

Pair data

read-only

Candles, trades, order book, order flow, open interest, funding, basis and liquidations for one pair or up to ten, now or over a dated window.

Example call

tools/call

get_pair_data(symbol="ETHUSDT", fields=["basis", "cvd"], last="12h")

Every parameter, field and response of the eleven tools, with a complete Python client. MCP reference

Rank pairs

read-only

Every served pair ranked on one metric, such as open interest, volume or funding, for a single quota request.

Example call

tools/call

rank_pairs(metric="oi_usd", limit=5)

Every parameter, field and response of the eleven tools, with a complete Python client. MCP reference

Technical indicators

read-only

Nineteen indicators computed on demand, from RSI and MACD to ADX, for one to ten pairs: the LLM never does the math.

Example call

tools/call

get_market_indicators(symbol="BTCUSDT", timeframe="1h", indicators=[{"id": "rsi_14", "type": "rsi", "period": 14}])

Every parameter, field and response of the eleven tools, with a complete Python client. MCP reference

Options and spot ETFs

read-only

Open interest, put/call, implied volatility, max pain, greeks and OI by strike per expiry, plus the SEC filings of spot ETFs.

Example call

tools/call

get_options_data(asset="BTC", fields=["options_summary"], expiries=True)

Every parameter, field and response of the eleven tools, with a complete Python client. MCP reference

Whole market

read-only

Total market cap and volume, BTC and ETH dominance, two Fear & Greed indices, altcoin season and the CMC20 and CMC100 indices.

Example call

tools/call

get_market_overview(fields=["fear_greed", "global_market"])

Every parameter, field and response of the eleven tools, with a complete Python client. MCP reference

On-chain

read-only

Bitcoin and Ethereum on-chain: mempool, fees, mining, MVRV, NVT, active addresses, gas, staking, supply and DeFi.

Example call

tools/call

get_onchain_data(fields=["btc_mvrv", "eth_staking"])

Every parameter, field and response of the eleven tools, with a complete Python client. MCP reference

Macro

read-only

US and global macro from FRED series, intraday instruments, net liquidity, crypto-macro correlations and a risk score.

Example call

tools/call

get_macro_data(series="DGS10", fields=["macro"])

Every parameter, field and response of the eleven tools, with a complete Python client. MCP reference

Field definitions

read-only

What a field returns, the unit of every column and the thresholds of every label, so the AI agent reads numbers right. Free.

Example call

tools/call

describe_fields(fields=["fear_greed_cmc"])

Every parameter, field and response of the eleven tools, with a complete Python client. MCP reference

Plan and service

read-only

Your plan, its history depth and remaining quota, the served pairs, data freshness and the catalogues. Free.

Example call

tools/call

get_system_info(include=["symbols", "freshness"])

Every parameter, field and response of the eleven tools, with a complete Python client. MCP reference

Read the rest

read-only

A long answer is cut to fit the LLM’s context: read_export pages through the full data for an hour, with no quota used.

Example call

tools/call

read_export(export_id="…", key="cvd@15m", offset=200)

Every parameter, field and response of the eleven tools, with a complete Python client. MCP reference

What your AI agent needs to know.

Connect: One address, Streamable HTTP. The key goes in X-API-KEY, or after Authorization: Bearer for clients that only send a token. Apps that can’t send a header sign in with OAuth: the access token lasts an hour and renews itself.
Units and time: _pct is a percent (58.5 means 58.5 %), _ratio a fraction (0.585). Times are ISO 8601 in UTC; a row is dated at the start of its bucket, newest first. describe_fields gives every unit, for free.
Now or history: Without a window, a tool returns the current value. last (for example 48h), or since_ms and until_ms, returns the history, closed buckets only. context places each latest value in its own recent history (percentile, z-score): always in get_pair_brief, on request elsewhere.
Plans and limits: Every plan connects and reads its own data: get_system_info tells your AI agent which. Outside the plan, a tool answers 403 with plan_family or history_depth. dry_run=true gives the cost of a call and your remaining quota without making it; max_quota_cost refuses any call above a budget.
Response size: About 6,000 tokens per response by default, up to 16,000 with max_tokens. A longer series keeps its newest rows; read_export pages through the rest for an hour, with no quota used.
Errors: A failed call returns isError with a code, a message and often a hint; wrong_tool names the right tool. On a 429, wait retry_after_s seconds, then call again.

Full MCP documentation

Then let your AI agent ask.

A free key connects every client on this page, with no card. Add the skills, and your AI agent also knows which tool to call and how to read the answer.

Get a free API key AI agent skills