Una configuración lista para pegar para cada agente de IA.

Servidor MCPClaude DesktopTodos los parámetros en la documentación MCP

api.bytnode.com/mcpinitializeconectadotools/list11 herramientasX-API-KEY

Tu clave de API

Se queda en esta página: rellena los bloques de abajo y nunca se envía ni se guarda. Obtener una clave gratis

Claude Desktop

Clave de API o inicio de sesión OAuth

Sin clave (recomendado): en Claude Desktop, abre Customize → Connectors → Add custom connector, pega esta URL e inicia sesión en tu cuenta de BytNode.
URL del servidor MCP
```
https://api.bytnode.com/mcp
```

Con tu clave de API: abre Settings → Developer → Edit config, pega esto en claude_desktop_config.json y reinicia Claude Desktop. Ese archivo solo arranca servidores locales: pasa por el puente mcp-remote, que necesita Node.js 18 o superior.

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

Sin clave: inicio de sesión OAuth

En claude.ai, abre Customize → Connectors → Add custom connector, llámalo BytNode, pega esta URL e inicia sesión en tu cuenta de BytNode. Sin clave que pegar: el conector también funciona en Claude Desktop y en el móvil.
URL del servidor MCP
```
https://api.bytnode.com/mcp
```
En un plan Team o Enterprise, un propietario lo añade una vez para todos en Organization settings → Connectors.

ChatGPT

Sin clave: inicio de sesión OAuth

ChatGPT no puede enviar una clave de API, así que se conecta con OAuth. En los ajustes de apps de ChatGPT, activa el modo desarrollador, añade un servidor MCP personalizado con esta URL y elige OAuth.
URL del servidor MCP
```
https://api.bytnode.com/mcp
```
ChatGPT abre la página de inicio de sesión de BytNode: autoriza el acceso y las once herramientas aparecen en tus chats. El modo desarrollador depende de tu plan de ChatGPT.

Claude Code

Clave de API o inicio de sesión OAuth

Ejecuta esto en un terminal. --scope user deja BytNode disponible en todos tus proyectos:

Terminal

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

Sin clave: añade solo el servidor y escribe /mcp en Claude Code para iniciar sesión en BytNode.
Terminal
```
claude mcp add --transport http --scope user bytnode https://api.bytnode.com/mcp
```
Para un repositorio compartido: sube este .mcp.json a la raíz del proyecto. Cada desarrollador guarda la clave en la variable de entorno BYTNODE_API_KEY, nunca en el archivo.
.mcp.json
```
{
  "mcpServers": {
    "bytnode": {
      "type": "http",
      "url": "https://api.bytnode.com/mcp",
      "headers": { "X-API-KEY": "${BYTNODE_API_KEY}" }
    }
  }
}
```

Cursor

Clave de API

Edita ~/.cursor/mcp.json para todos tus proyectos, o .cursor/mcp.json para este:

~/.cursor/mcp.json

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

BytNode aparece en la lista MCP con sus once herramientas. Deja el archivo fuera de git: contiene tu clave.

Codex

Clave de API o inicio de sesión OAuth

Añade esta tabla a ~/.codex/config.toml, o a .codex/config.toml en un proyecto de confianza. La CLI, la extensión del IDE y la app la comparten:
~/.codex/config.toml
```
[mcp_servers.bytnode]
url = "https://api.bytnode.com/mcp"
http_headers = { "X-API-KEY" = "YOUR_API_KEY" }
```
Sin clave: registra la URL e inicia sesión en BytNode en el navegador que se abre:
Terminal
```
codex mcp add bytnode --url https://api.bytnode.com/mcp
```
Terminal
```
codex mcp login bytnode
```

VS Code (GitHub Copilot)

Clave de API

Para el modo agente de GitHub Copilot, un comando añade el servidor a tu perfil de VS Code:

Terminal

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

Para un espacio de trabajo: sube .vscode/mcp.json. VS Code pide la clave a cada desarrollador la primera vez, así nunca llega al repositorio:

.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)

Clave de API

Windsurf ahora es Devin Desktop. Abre ~/.config/devin/mcp_config.json (en Windows, %AppData%\devin\mcp_config.json) y añade BytNode:
~/.config/devin/mcp_config.json
```
{
  "mcpServers": {
    "bytnode": {
      "url": "https://api.bytnode.com/mcp",
      "headers": { "X-API-KEY": "YOUR_API_KEY" }
    }
  }
}
```

Gemini CLI

Clave de API

Ejecuta esto en un terminal. -s user añade BytNode a todos tus proyectos:

Terminal

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

O edita ~/.gemini/settings.json. Para Streamable HTTP la clave es httpUrl, no url:

~/.gemini/settings.json

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

n8n

Clave de API

En tu workflow, abre el nodo AI Agent y añade una herramienta: MCP Client Tool (n8n 1.104 o posterior).
Endpoint:
URL del servidor MCP
```
https://api.bytnode.com/mcp
```
Server Transport: HTTP Streamable. Authentication: Header Auth, con una credencial nueva: Name y luego Value:
Name
```
X-API-KEY
```
Value
```
YOUR_API_KEY
```
Tools to Include: All. Tu agente de IA ya puede llamar a BytNode en cada ejecución.

LangChain

Clave de API

Instala LangChain y sus adaptadores MCP, y pon tu clave en el entorno:

Terminal

pip install langchain langchain-anthropic langchain-mcp-adapters

Terminal

export BYTNODE_API_KEY=YOUR_API_KEY

Carga las once herramientas y dáselas a un agente de LangChain. Sirve cualquier modelo de chat; este usa 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

Clave de API

Instala el OpenAI Agents SDK y pon tu clave en el entorno:
Terminal
```
pip install openai-agents
```
Terminal
```
export BYTNODE_API_KEY=YOUR_API_KEY
```

Conecta BytNode a un agente como servidor MCP Streamable HTTP:

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

Clave de API

Instala el SDK de Anthropic y pon tu clave de BytNode en el entorno:
Terminal
```
pip install anthropic
```
Terminal
```
export BYTNODE_API_KEY=YOUR_API_KEY
```

La API Messages se conecta ella misma al servidor MCP, sin código cliente: declara el servidor y su toolset. La clave viaja como token Bearer, que BytNode acepta:

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

Clave de API

Instala el SDK de OpenAI y pon tu clave de BytNode en el entorno:
Terminal
```
pip install openai
```
Terminal
```
export BYTNODE_API_KEY=YOUR_API_KEY
```

La Responses API llama por ti a los servidores MCP remotos: declara BytNode como herramienta mcp:

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)

Cualquier otro cliente MCP

Clave de API o inicio de sesión OAuth

La mayoría de los clientes MCP leen este objeto mcpServers. Algunos omiten type, o lo llaman streamableHttp: revisa la documentación de tu cliente.

mcp.json

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

Si tu cliente solo puede enviar un token Bearer, BytNode lee la clave en él:
Cabecera HTTP
```
Authorization: Bearer YOUR_API_KEY
```
Si tu cliente admite OAuth, pega solo la URL e inicia sesión en BytNode: el servidor anuncia él mismo su servidor de autorización.
URL del servidor MCP
```
https://api.bytnode.com/mcp
```

Un comando en tu terminal, o un archivo de configuración.

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}

Los agentes de código añaden BytNode con un comando. El archivo de configuración hace lo mismo a mano, pegado tal cual.

Tu agente de código

Un comando añade BytNode a todos tus proyectos. Sin clave, escribe /mcp en Claude Code para iniciar sesión.

Leer la documentación MCP Obtener una clave gratis

Sin clave, un inicio de sesión OAuth.

ChatGPT, claude.ai y Claude Desktop se conectan solo con la dirección. Inicias sesión en BytNode: ninguna clave sale de tu cuenta.

Tu app de IA

En los ajustes de apps, activa el modo desarrollador, añade un servidor MCP con esta dirección y elige OAuth.

https://api.bytnode.com/mcp

Leer la documentación MCP Obtener una clave gratis

ChatGPT

Añadir conectorNombreBytNodeURL del servidor MCP remotohttps://api.bytnode.com/mcpAñadir

En el código de tu agente, bastan unas líneas.

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

Los frameworks de agentes y las API de LLM cargan las once herramientas desde la dirección. La clave se queda en BYTNODE_API_KEY, nunca en el código.

Tu framework o tu API

MultiServerMCPClient carga las once herramientas y se las da a cualquier agente de LangChain.

Leer la documentación MCP Obtener una clave gratis

Once herramientas, para inspeccionar antes que tu agente.

Lo que tu agente de IA recibe de tools/list. Todas de solo lectura e idempotentes: un objetivo por herramienta, los mismos parámetros en todas, un tool calling sencillo para el LLM.

tools/listget_pair_brief

Ficha de un par

solo lectura

El estado de un par en una llamada, siempre con la misma forma: precio y variaciones, próximo funding, basis, open interest, CVD y las liquidaciones de las últimas 24 horas.

Ejemplo de llamada

tools/call

get_pair_brief(symbol="BTCUSDT")

Cada parámetro, campo y respuesta de las once herramientas, con un cliente Python completo. Referencia MCP

Datos de un par

solo lectura

Velas, operaciones, libro de órdenes, flujo de órdenes, open interest, funding, basis y liquidaciones de un par o de hasta diez, ahora o en una ventana fechada.

Ejemplo de llamada

tools/call

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

Cada parámetro, campo y respuesta de las once herramientas, con un cliente Python completo. Referencia MCP

Clasificar pares

solo lectura

Todos los pares servidos clasificados por una métrica, como open interest, volumen o funding, con una sola solicitud de cuota.

Ejemplo de llamada

tools/call

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

Cada parámetro, campo y respuesta de las once herramientas, con un cliente Python completo. Referencia MCP

Indicadores técnicos

solo lectura

Diecinueve indicadores calculados al momento, del RSI y el MACD al ADX, para uno a diez pares: el LLM nunca hace las cuentas.

Ejemplo de llamada

tools/call

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

Cada parámetro, campo y respuesta de las once herramientas, con un cliente Python completo. Referencia MCP

Opciones y ETF spot

solo lectura

Open interest, put/call, volatilidad implícita, max pain, griegas y OI por strike en cada vencimiento, más los registros SEC de los ETF spot.

Ejemplo de llamada

tools/call

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

Cada parámetro, campo y respuesta de las once herramientas, con un cliente Python completo. Referencia MCP

Todo el mercado

solo lectura

Capitalización y volumen totales, dominancia de BTC y ETH, dos índices Fear & Greed, la altcoin season y los índices CMC20 y CMC100.

Ejemplo de llamada

tools/call

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

Cada parámetro, campo y respuesta de las once herramientas, con un cliente Python completo. Referencia MCP

On-chain

solo lectura

On-chain de Bitcoin y Ethereum: mempool, comisiones, minería, MVRV, NVT, direcciones activas, gas, staking, oferta y DeFi.

Ejemplo de llamada

tools/call

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

Cada parámetro, campo y respuesta de las once herramientas, con un cliente Python completo. Referencia MCP

Macro

solo lectura

Macro de EE. UU. y global: series FRED, instrumentos intradía, liquidez neta, correlaciones cripto-macro y una puntuación de riesgo.

Ejemplo de llamada

tools/call

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

Cada parámetro, campo y respuesta de las once herramientas, con un cliente Python completo. Referencia MCP

Definición de campos

solo lectura

Qué devuelve un campo, la unidad de cada columna y los umbrales de cada etiqueta, para que el agente de IA lea bien las cifras. Gratis.

Ejemplo de llamada

tools/call

describe_fields(fields=["fear_greed_cmc"])

Cada parámetro, campo y respuesta de las once herramientas, con un cliente Python completo. Referencia MCP

Plan y servicio

solo lectura

Tu plan, su profundidad de historial y la cuota restante, los pares servidos, la frescura de los datos y los catálogos. Gratis.

Ejemplo de llamada

tools/call

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

Cada parámetro, campo y respuesta de las once herramientas, con un cliente Python completo. Referencia MCP

Leer el resto

solo lectura

Una respuesta larga se corta para caber en el contexto del LLM: read_export recorre los datos completos durante una hora, sin gastar cuota.

Ejemplo de llamada

tools/call

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

Cada parámetro, campo y respuesta de las once herramientas, con un cliente Python completo. Referencia MCP

Lo que tu agente de IA debe saber.

Conexión: Una dirección, en Streamable HTTP. La clave va en X-API-KEY, o tras Authorization: Bearer para los clientes que solo envían un token. Las apps que no pueden enviar una cabecera inician sesión con OAuth: el token de acceso dura una hora y se renueva solo.
Unidades y hora: _pct es un porcentaje (58.5 significa 58,5 %), _ratio una fracción (0.585). Las horas van en ISO 8601, en UTC; una fila se fecha al inicio de su intervalo, la más reciente primero. describe_fields da cada unidad, gratis.
Ahora o historial: Sin ventana, una herramienta devuelve el valor actual. last (por ejemplo 48h), o since_ms y until_ms, devuelve el historial, solo intervalos cerrados.
Planes y límites: Todos los planes se conectan y leen sus propios datos: get_system_info le dice a tu agente de IA cuáles. Fuera del plan, una herramienta responde 403 con plan_family o history_depth.
Tamaño de las respuestas: Unos 6.000 tokens por respuesta por defecto, hasta 16.000 con max_tokens. Una serie más larga conserva sus filas más recientes; read_export recorre el resto durante una hora, sin gastar cuota.
Errores: Una llamada fallida devuelve isError con un código, un mensaje y a menudo un hint; wrong_tool nombra la herramienta correcta. Ante un 429, espera retry_after_s segundos y vuelve a llamar.

Toda la documentación MCP

Y deja que tu agente de IA pregunte.

Una clave gratis conecta todos los clientes de esta página, sin tarjeta. Añade las skills, y tu agente de IA también sabrá qué herramienta llamar y cómo leer la respuesta.

Obtener una clave gratis Skills para agentes de IA