---
title: "12 cosas que puedes hacer más rápido con Alchemy CLI"
description: "Alchemy CLI convierte cada flujo de trabajo onchain en un solo comando: auth, agent wallets, lecturas multi-chain, sends, swaps, bridges e integraciones con AI agents."
---

# 12 cosas que puedes hacer más rápido con Alchemy CLI

<ImageBlock
  src="https://media.alchemy.com/blog/12-things-alchemy-cli-hero-v2.png"
  alt="12 cosas que puedes hacer más rápido con Alchemy CLI"
  width={1920}
  height={900}
  priority
/>

Todo proyecto onchain solía empezar de la misma forma: abrir un dashboard, copiar una API key, pegar una private key en `.env`, hacer npm install de tres SDKs y recién entonces escribir la línea que realmente te interesaba. Tu agente de código gastaba media sesión averiguando qué método RPC llamar. El [Alchemy CLI](https://www.alchemy.com/docs/alchemy-cli) elimina ese costo de configuración con comandos que puedes encadenar, incluir en scripts o entregarle a un agente de código. Tu terminal es el camino más rápido hacia onchain.

Este post recorre doce cosas que el CLI hace en un solo comando: iniciar sesión, levantar una agent wallet, leer cualquier chain, simular writes, enviar tokens, hacer swap, hacer bridge, y conectar la misma herramienta a Cursor, Claude Code o Codex. Cada comando mostrado funciona hoy.

## Qué es el Alchemy CLI

El Alchemy CLI es un único [paquete de npm](https://www.npmjs.com/package/@alchemy/cli), `@alchemy/cli`, que envuelve cada superficie de API que ofrecemos (Core RPC, la Data API, swap, bridge, simulate, webhook, admin y wallet) detrás de un conjunto consistente de subcomandos. Instálalo una vez con `npm i -g @alchemy/cli@latest`, ejecuta `alchemy auth`, y el mismo conjunto de flags funciona en todos los comandos. Encadena `--json` con `jq`, protege scripts con `--no-interactive`, y la misma superficie que corre en tu terminal también corre dentro de un agente de código con IA.

El punto central: el flujo de trabajo que tu equipo ya ejecuta a través del dashboard o un SDK ahora se reduce a una línea de comando que un desarrollador puede scriptear y un agente puede invocar.

## Auth e identidad en una sola terminal

### 1. Inicia sesión una vez con `alchemy auth`

`alchemy auth` abre un navegador, inicia sesión en tu cuenta y guarda la sesión en disco. Se acabó pegar API keys en cada `.env` de cada proyecto. Cambia de team con `alchemy auth login --force`, revisa el estado con `alchemy auth status`, límpialo con `alchemy auth logout`.

<CodeSnippet
  language="bash"
  code={`npm i -g @alchemy/cli@latest
alchemy auth`}
/>

<ImageBlock
  src="https://media.alchemy.com/blog/12-things-alchemy-cli-auth.png"
  alt="Pantalla de Autorizar inicio de sesión que otorga a Alchemy CLI acceso limitado a tu cuenta"
  width={1580}
  height={1190}
/>

Un solo comando reemplaza el ciclo de "copiar key, pegar key, gitignore key, rotar key" que se repite en cada proyecto.

### 2. Levanta una agent wallet con `alchemy wallet connect`

El CLI incluye [agent wallets con custodia de Privy](https://www.alchemy.com/blog/agent-wallets-alchemy-cli). Privy es el proveedor de embedded wallets que mantiene la private key de la wallet en su lado. `alchemy wallet connect --mode session` genera localmente un par de claves P-256 nuevo, registra una sesión acotada en el tiempo contra el backend de Privy, y firma en dos pasos: el CLI firma el payload de la session key, Privy firma la wallet. La private key nunca sale de Privy y la session key nunca sale de tu dispositivo.

<CodeSnippet
  language="bash"
  code={`alchemy wallet connect --mode session`}
/>

Revócala desde el dashboard o con `alchemy wallet disconnect`, y la sesión deja de funcionar de inmediato. Para un flujo con clave local: `alchemy wallet connect --mode local --chain evm --import ~/.wallet/key`. De cualquier forma, la private key nunca queda guardada en `.env`.

### 3. Paga sobre la marcha con `--x402`

Define `--x402` en cualquier comando y el CLI se autentica contra nuestras APIs con la wallet conectada en lugar de una API key. Cuando una solicitud llega a un endpoint pago, el endpoint devuelve HTTP 402, el CLI firma el [payload de pago x402](https://docs.x402.org/), y la solicitud se completa. x402 es una especificación abierta de Coinbase para pagos nativos de HTTP; las liquidaciones corren en USDC sobre Base. Los agentes pueden empezar con [tan solo $1](https://www.alchemy.com/blog/ai-agents-can-now-sign-up-for-alchemy) en créditos de cómputo, sin necesidad de registrarse en el dashboard.

<CodeSnippet
  language="bash"
  code={`# Pay per call with the wallet you connected in step 2
alchemy evm rpc eth_blockNumber -n base-mainnet --x402

# Or make it the default so you can drop the flag:
alchemy config set x402 true`}
/>

Un agente (o un desarrollador humano que nunca se registró) ya puede usar las mismas APIs que corren tus cargas de trabajo en producción. Sin API key, sin dashboard, sin contrato.

## Lee cualquier chain sin escribir boilerplate de fetch

### 4. Llama a cualquier método JSON-RPC en cualquier chain

`alchemy evm rpc` pasa cualquier método JSON-RPC directo a la red que selecciones con `-n`. Sin escribir a mano envoltorios de fetch, sin la danza de instalar un SDK para un script de cinco líneas.

<CodeSnippet
  language="bash"
  code={`alchemy evm rpc eth_blockNumber -n base-mainnet --json
alchemy evm rpc eth_getLogs '[{"fromBlock":"0x123","topics":["0x..."]}]' \\
  -n arb-mainnet --json`}
/>

Para Solana, usa `alchemy solana rpc` para JSON-RPC y `alchemy solana das` para métodos Digital Asset Standard. La estructura se mantiene igual en cada chain que soportamos.

### 5. Trae un portfolio multi-chain en una sola llamada

`alchemy evm data portfolio tokens` devuelve balances de tokens en cada chain que una wallet haya tocado. Sin tener que combinar siete proveedores de RPC, sin llamar `eth_call` chain por chain a cada contrato ERC-20.

<CodeSnippet
  language="bash"
  code={`alchemy evm data portfolio tokens --json --body '{
  "addresses":[{
    "address":"vitalik.eth",
    "networks":["eth-mainnet","base-mainnet","arb-mainnet"]
  }]
}'`}
/>

Combínalo con `portfolio nfts` para lograr lo mismo con colecciones de NFT. Los mismos endpoints impulsan nuestros indexadores de la [Data API](https://www.alchemy.com/docs/data) en producción.

### 6. Consulta balances, transfers y NFTs con un solo comando

Balances, metadata de tokens, historial de transfers y NFTs se ofrecen cada uno como un único subcomando dentro de la superficie de la Data API. Agrega `--metadata` y la llamada devuelve nombre, símbolo, decimales y URL del logo en línea.

<CodeSnippet
  language="bash"
  code={`alchemy evm data tokens balances 0xabc... --metadata -n base-mainnet --json
alchemy evm data history 0xabc... -n eth-mainnet --json
alchemy evm data nfts 0xabc... --limit 20 -n eth-mainnet --json`}
/>

Las lecturas que antes requerían cuatro clientes de SDK distintos ahora se ofrecen como cuatro flags en un solo CLI.

## Escribe transacciones desde tu shell

### 7. Simula antes de enviar

`alchemy evm simulate asset-changes` devuelve un diff legible de cada movimiento de token y ETH que provocaría una transacción. `simulate execution` devuelve el trace completo. Quien lo lee ve exactamente qué hace la llamada antes de que llegue onchain.

<CodeSnippet
  language="bash"
  code={`alchemy evm simulate asset-changes --json --tx '{
  "from":"vitalik.eth",
  "to":"0x...",
  "data":"0x..."
}'`}
/>

Ejecuta esto antes de cualquier `evm send` o `contract call` que toque fondos en mainnet. Evita el "acabo de romper mi hot wallet" y tener que rehacer todo.

### 8. Envía a un nombre ENS en una línea

<CodeSnippet
  language="bash"
  code={`alchemy evm send vitalik.eth 0.01 -n base-mainnet
alchemy evm send 0xabc... 100 --token 0xUsdcAddress -n base-mainnet`}
/>

`alchemy evm send` resuelve ENS, maneja el gas y firma con la wallet que esté activa en ese momento (session, local, o custodiada por Privy). Combínalo con `--x402` y la misma llamada se enruta a través de la wallet que conectaste en el paso 2.

### 9. Aprueba, haz swap y bridge desde el mismo shell

`alchemy evm swap execute` lleva un swap en la misma chain desde la cotización hasta la ejecución. `alchemy xchain bridge execute` hace lo mismo pero cross-chain. `alchemy evm approve` maneja el allowance ERC-20 que todo swap en un DEX necesita primero.

<CodeSnippet
  language="bash"
  code={`alchemy evm approve 0xPool --token-address 0xUsdc --amount 100 -n base-mainnet
alchemy evm swap execute --from 0xUsdc --to 0xEth --amount 100 -n base-mainnet
alchemy xchain bridge execute --from 0xUsdcBase --to 0xUsdcArb \\
  --amount 0.2 --to-network arb-mainnet -n base-mainnet`}
/>

El swap en la misma chain está disponible en 11 mainnets EVM, incluyendo Ethereum, Base, Arbitrum, Optimism, Polygon y BSC, según la [documentación del Alchemy CLI](https://www.alchemy.com/docs/alchemy-cli). El bridge cross-chain también está disponible hoy en el CLI. El wizard del dashboard se reduce a tres líneas de shell.

## Conecta el CLI a tu agente de código

### 10. Genera un manifiesto completo para agentes con `alchemy agent-prompt`

`alchemy agent-prompt` genera un documento JSON que describe cada comando, flag, código de error y ejemplo. Pásalo al system prompt de tu agente y este deja de adivinar nombres de flags.

<CodeSnippet
  language="bash"
  code={`alchemy agent-prompt > .alchemy-prompt.json`}
/>

El manifiesto incluye una política de ejecución, verificaciones previas, la matriz de auth, el árbol de comandos con sus opciones, un catálogo de errores con semántica de reintentos, y ejemplos ejecutables. Para Cursor, Claude Code, Codex, o cualquier otro agente de código, el archivo va directo al system prompt. Patrón en la práctica: [Cómo construir agentes onchain](https://www.alchemy.com/blog/how-to-build-onchain-agents).

### 11. Instala Alchemy Skills

`alchemy install skills` instala el [paquete de Alchemy Skills](https://github.com/alchemyplatform/skills) en tu cliente de agente. Skills son flujos de trabajo legibles por máquina que le enseñan a un agente de código cómo usar el CLI sin tener que leer documentación en tiempo de ejecución.

<CodeSnippet
  language="bash"
  code={`alchemy install skills`}
/>

El paquete cubre cuatro superficies: el CLI en sí, la integración de apps mediante API keys, MCP, y el flujo de pago basado en wallet. Un comando reemplaza "el agente tiene que revisar la documentación cada sesión" por "el agente ya conoce el flujo de trabajo".

### 12. Conecta MCP

`alchemy install mcp` conecta el [servidor Alchemy MCP](https://www.alchemy.com/docs/alchemy-mcp-server) a tu cliente de agente. MCP (Model Context Protocol) es una especificación abierta que permite a los agentes descubrir e invocar herramientas en tiempo de ejecución. El servidor hospedado vive en `https://mcp.alchemy.com/mcp` y expone más de 150 herramientas en más de 100 chains: admin, cada método RPC, y la superficie de la Data API.

<CodeSnippet
  language="bash"
  code={`alchemy install mcp`}
/>

Para Claude Code en particular:

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

Skills, el manifiesto para el prompt del agente, y MCP juntos hacen que el CLI sea una capacidad de primera clase dentro del inventario de herramientas de un agente, no una dependencia secundaria.

## La demo de agente en cinco llamadas: comparación de yield, bridge, supply

La demo canónica que se distribuye con el [repositorio de Alchemy Skills](https://github.com/alchemyplatform/skills) lee el APY de supply de USDC en Polygon, Arbitrum y Optimism, hace bridge de 0.2 USDC de Base a la chain con mayor rendimiento, y lo deposita en Aave V3. Cinco llamadas al CLI, la misma superficie que impulsa el resto de este post.

<ImageBlock
  src="https://media.alchemy.com/blog/12-things-alchemy-cli-demo.png"
  alt="Un agente que usa Alchemy CLI para comparar rendimientos de USDC en Aave entre L2s, transferir de Base a Arbitrum y depositar en Aave, todo desde la terminal sin exponer la clave privada"
  width={1058}
  height={1292}
  caption="Source: https://x.com/uttam_singhk/status/2054540200874025224"
/>

En la demo de arriba, el agente encuentra el mejor mercado de Aave para USDC, hace bridge de los fondos a la chain correcta, y los deposita en el pool. Hasta hoy, ese flujo de trabajo requería código de agente a medida que guardara una private key, o una integración construida a mano entre un SDK de wallet y un asistente de código. Ahora son unos pocos comandos y un clic en el dashboard.

## Empieza tu primer comando

Acabas de ver doce comandos. Aquí está el onboarding de dos minutos: instalar, iniciar sesión, conectar una wallet, enviar.

<CodeSnippet
  language="bash"
  code={`npm i -g @alchemy/cli@latest
alchemy auth
alchemy wallet connect --mode session
alchemy evm send vitalik.eth 0.001 -n base-mainnet`}
/>

Sin dispersión de SDKs, sin private key en `.env`, sin ida y vuelta al dashboard. Sea cual sea tu flujo de trabajo onchain, el CLI lo ejecuta desde un solo prompt. Tu terminal es el camino más rápido hacia onchain.