---
title: "MCP para datos de blockchain: cada API de Alchemy en tu asistente de IA"
description: "Conecta el servidor MCP de Alchemy a tu agente de código y haz preguntas onchain en lenguaje simple. Más de 168 herramientas en 100+ chains, con inicio de sesión OAuth y sin instalación local."
---

# MCP para datos de blockchain: cada API de Alchemy en tu asistente de IA

<ImageBlock
  src="https://media.alchemy.com/mcp-server.png"
  alt="Alchemy MCP Server"
  width={1920}
  height={900}
  priority
/>

Abre Claude y haz una pregunta que normalmente escribirías un script para responder: "¿Cuáles son los principales mercados de préstamos de USDC en este momento, y cuál tiene el APY de suministro más alto?"

Unos segundos después, responde. Tasas en vivo de Aave, Compound y Morpho, ordenadas, con la chain en la que está cada una. Sin script. Sin copiar un endpoint de la documentación. Sin buscar la dirección de contrato correcta. Preguntaste, y tu asistente leyó la chain y te lo dijo.

Eso funciona porque tu asistente está conectado al [Alchemy MCP server](https://www.alchemy.com/docs/alchemy-mcp-server): un servicio hospedado que expone cada API de blockchain de Alchemy como una herramienta que tu asistente de IA puede invocar en una conversación normal. Las preguntas sobre la chain se responden de la misma manera en que tu asistente ya responde preguntas sobre tu código.

## Qué acaba de pasar

Los asistentes de codificación son buenos razonando y malos adivinando. Pídele a uno datos de blockchain en vivo sin darle una forma real de obtenerlos, y a menudo inventará un endpoint que no existe o te dará números desactualizados de sus datos de entrenamiento. La inteligencia está ahí. La conexión con la realidad no.

[MCP](https://modelcontextprotocol.io/) cierra esa brecha. Cuando tu asistente está conectado a Alchemy vía MCP, "cuáles son los principales mercados de préstamos de USDC" deja de ser una pregunta que resuelve por coincidencia de patrones y se convierte en una pregunta que responde leyendo la chain de verdad: llamando a los contratos, obteniendo tasas actuales y devolviendo números reales de este mismo minuto.

## ¿Qué es MCP para datos de blockchain?

MCP, el Model Context Protocol, es un estándar abierto para conectar asistentes de IA con herramientas y datos externos. Piénsalo como un enchufe común. Un proveedor de herramientas expone un conjunto de capacidades, el asistente las descubre, y a partir de ahí el asistente puede invocar esas capacidades en una conversación normal.

El [Alchemy MCP server](https://www.alchemy.com/docs/alchemy-mcp-server) es ese enchufe para datos de blockchain. Expone la superficie de API de Alchemy como herramientas que tu asistente puede tomar y usar: 168 de ellas, en [más de 100 chains](https://www.alchemy.com/rpc-api). Balances de tokens, propiedad de NFTs, historial de transacciones, datos de portafolio, precios, estimaciones de gas, simulación de transacciones, traces, llamadas RPC crudas. Si puedes hacerlo con una API de Alchemy, tu asistente puede hacerlo a través de MCP.

Como MCP es un estándar y no un plugin para una app específica, te conectas una vez y el asistente se encarga del resto. No hay nada que instalar en tu proyecto ni ningún SDK que configurar. El servidor corre en `https://mcp.alchemy.com/mcp`, tu asistente se conecta a él, y las herramientas aparecen.

## Cada API de Alchemy, ahora algo que tu asistente puede invocar

La parte útil no es ninguna herramienta individual. Es que toda la superficie está disponible a la vez, así que tu asistente puede encadenar pasos de la misma forma en que tú lo harías.

Pregunta "qué billeteras suministraron más de $1M de USDC a Aave en Base en las últimas 24 horas", y puede obtener las transferencias, filtrarlas y sumarlas. Pregunta "qué hay en esta billetera", y puede leer balances, metadatos de tokens y tenencias de NFTs, y darte un resumen limpio. Pregunta "simula este swap antes de enviarlo", y puede ejecutar la simulación y decirte qué pasaría, antes de gastar gas.

Estas son las preguntas que ya haces durante un build. Normalmente cada una es un desvío: encontrar el endpoint, escribir la llamada, parsear la respuesta, leerla. Con cada API de Alchemy en el asistente, el desvío se reduce a una frase.

El servidor agrupa las herramientas en tres categorías. Las herramientas **Admin** gestionan tu cuenta y apps de Alchemy. Las herramientas **RPC** cubren JSON-RPC estándar de EVM, RPC de Solana, APIs de tokens, transferencias, simulación, tracing, debug y account abstraction. Las herramientas **Data** llaman a las APIs REST de Alchemy para NFTs, precios y datos de portafolio multi-chain. Después de ejecutar `select_app`, las herramientas de data y RPC usan las credenciales de esa app durante la sesión. Consulta la lista completa de herramientas en la [documentación del MCP server](https://www.alchemy.com/docs/alchemy-mcp-server).

## Funciona con el asistente que ya usas

El Alchemy MCP server no está atado a un modelo ni a una app en particular. Funciona con Claude, Cursor, Codex, ChatGPT y otros clientes compatibles con MCP. Traes el asistente con el que ya trabajas, y Alchemy se conecta a él. No hay un modelo propietario que adoptar ni nada que quitar después.

Eso importa porque la herramienta correcta es la que ya está abierta junto a tu editor. MCP encaja ahí, en lugar de pedirte que cambies tu forma de trabajar.

<ExternalVideo
  url="https://www.youtube.com/watch?v=LzaWFtmYMDU"
  provider="youtube"
  providerUid="LzaWFtmYMDU"
/>

## ¿Cómo lo configuro?

Agregas el servidor a la configuración MCP de tu asistente una vez, inicias sesión con tu cuenta de Alchemy cuando se te pida, y empiezas a hacer preguntas. La autenticación es OAuth sobre el servidor hospedado en `https://mcp.alchemy.com/mcp`. Sin API key que copiar y sin proceso local que ejecutar.

<ExternalVideo
  url="https://www.youtube.com/watch?v=Qtq4cbOazeY"
  provider="youtube"
  providerUid="Qtq4cbOazeY"
/>


Para **Cursor**, agrega esto a `~/.cursor/mcp.json` (global) o `.cursor/mcp.json` (a nivel de proyecto), y luego reinicia el editor:

<CodeSnippet
  language="json"
  code={`{
  "mcpServers": {
    "alchemy": {
      "type": "streamable-http",
      "url": "https://mcp.alchemy.com/mcp"
    }
  }
}`}
/>

Para **Claude Code**, ejecuta:

<CodeSnippet
  language="bash"
  code={`claude mcp add alchemy --transport http https://mcp.alchemy.com/mcp`}
/>

Para **Codex**:

<CodeSnippet
  language="bash"
  code={`codex mcp add alchemy --url https://mcp.alchemy.com/mcp`}
/>

La primera vez que tu asistente invoca una herramienta de Alchemy, se abre una ventana del navegador para el inicio de sesión OAuth. Después de eso, dile que seleccione una app (por ejemplo, "selecciona mi app de Alchemy para Base mainnet") para que las herramientas RPC y Data sepan qué credenciales usar.

Los pasos específicos para Claude Desktop, VS Code Copilot y otros clientes MCP están en la [documentación del Alchemy MCP server](https://www.alchemy.com/docs/alchemy-mcp-server). También puedes conectar el servidor con un solo comando usando `alchemy install mcp` del [Alchemy CLI](https://www.alchemy.com/docs/alchemy-cli).

Una vez conectado, las herramientas simplemente están ahí. Abre un chat, haz una pregunta sobre la chain en lenguaje natural, y tu asistente recurre a la API de Alchemy correcta por su cuenta.

## Cuándo usar MCP, el CLI, o Skills

MCP es el camino más rápido cuando quieres respuestas en una conversación: explorar datos, verificar estado, probar una idea antes de escribir código. Nada que instalar en tu repo. Preguntas y lees.

Cuando quieres que tu asistente tome acción desde la terminal, configure un repo, fondee una billetera de prueba o ejecute un comando, el [Alchemy CLI](https://www.alchemy.com/docs/alchemy-cli) es la mejor opción. Y cuando quieres que escriba código de integración de Alchemy correcto en una app que se va a lanzar, [Agent Skills](https://www.alchemy.com/docs/alchemy-agent-skills) carga la especificación completa de la API para que el código generado use los endpoints, la autenticación y la paginación correctos desde la primera vez.

La mayoría de los builds terminan usando los tres. MCP suele ser el punto de partida, porque hacer una pregunta es la forma de entrada que menos esfuerzo requiere.

<EmbeddedTable
  table={{
    columns: [
      { key: "option", width: 200, title: "", dataType: "object" },
      { key: "bestFor", width: 420, title: "Best for", dataType: "object" },
    ],
    data: [
      {
        option: {
          title:
            '<a href="https://www.alchemy.com/docs/alchemy-mcp-server">MCP server</a>',
          tooltip: "",
          icon: "",
        },
        bestFor: {
          title:
            "Live onchain answers inside Cursor, Claude, Codex, or any MCP client, without writing fetch code",
          tooltip: "",
          icon: "",
        },
        id: 0,
      },
      {
        option: {
          title:
            '<a href="https://www.alchemy.com/docs/alchemy-cli">Alchemy CLI</a>',
          tooltip: "",
          icon: "",
        },
        bestFor: {
          title:
            "Terminal workflows: sends, swaps, bridges, admin, and scripting the same surface your agent can call",
          tooltip: "",
          icon: "",
        },
        id: 1,
      },
      {
        option: {
          title:
            '<a href="https://www.alchemy.com/docs/alchemy-agent-skills">Agent Skills</a>',
          tooltip: "",
          icon: "",
        },
        bestFor: {
          title:
            "Shipping application code that calls Alchemy APIs with correct patterns baked in",
          tooltip: "",
          icon: "",
        },
        id: 2,
      },
    ],
  }}
/>

Mira cómo encajan las piezas en [Alchemy for agents](https://www.alchemy.com/agents).

## Empieza a hacerle preguntas sobre la chain a tu asistente

La misma infraestructura que sirve a más de 100M de usuarios en más de 100 chains con 99.99% de uptime ahora es algo con lo que puedes hablar. Conecta el [Alchemy MCP server](https://www.alchemy.com/docs/alchemy-mcp-server), pregúntale a tu asistente qué está pasando en la chain, y observa cómo responde con datos reales.