---
title: "12 coisas que você pode fazer mais rápido com a Alchemy CLI"
description: "A Alchemy CLI transforma cada workflow onchain em um único comando: auth, agent wallets, leituras multi-chain, sends, swaps, bridges e integrações com agentes de IA."
---

# 12 coisas que você pode fazer mais rápido com a Alchemy CLI

<ImageBlock
  src="https://media.alchemy.com/blog/12-things-alchemy-cli-hero-v2.png"
  alt="12 coisas que você pode fazer mais rápido com o Alchemy CLI"
  width={1920}
  height={900}
  priority
/>

Todo projeto onchain costumava começar do mesmo jeito: abrir um dashboard, copiar uma API key, colar uma private key em `.env`, rodar npm install em três SDKs, e só então escrever a linha que você realmente queria. Seu agente de código gastava metade da sessão tentando descobrir qual método de RPC chamar. O [Alchemy CLI](https://www.alchemy.com/docs/alchemy-cli) elimina esse custo de setup transformando tudo em comandos que você pode encadear (pipe), automatizar em scripts, ou passar para um agente de código. Seu terminal é o caminho mais rápido para o onchain.

Este post percorre doze coisas que o CLI faz em um único comando: fazer login, subir uma agent wallet, ler qualquer chain, simular writes, enviar tokens, fazer swap, bridge, e conectar a mesma ferramenta ao Cursor, Claude Code ou Codex. Todos os comandos mostrados já estão disponíveis hoje.

## O que é o Alchemy CLI?

O Alchemy CLI é um único [pacote npm](https://www.npmjs.com/package/@alchemy/cli), `@alchemy/cli`, que envolve toda a superfície de API que oferecemos (Core RPC, a Data API, swap, bridge, simulate, webhook, admin e wallet) em um conjunto consistente de subcomandos. Instale uma vez com `npm i -g @alchemy/cli@latest`, rode `alchemy auth`, e o mesmo conjunto de flags funciona em todos os comandos. Encadeie `--json` com `jq`, condicione scripts com `--no-interactive`, e a mesma superfície que roda no seu terminal também roda dentro de um agente de código com IA.

O ponto central: o fluxo de trabalho que sua equipe já executa pelo dashboard ou por um SDK agora se resume a uma única linha de comando que um desenvolvedor pode automatizar e um agente pode chamar.

## Auth e identidade em um único terminal

### 1. Faça login uma vez com `alchemy auth`

`alchemy auth` abre um navegador, faz login na sua conta e armazena a sessão em disco. Chega de colar API keys em todo `.env` de cada projeto. Troque de time com `alchemy auth login --force`, verifique o estado com `alchemy auth status`, limpe com `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="Tela de Authorize Login concedendo ao Alchemy CLI acesso restrito à sua conta"
  width={1580}
  height={1190}
/>

Um comando substitui o ciclo de "copiar key, colar key, colocar no gitignore, rotacionar key" que todo projeto repete.

### 2. Suba uma agent wallet com `alchemy wallet connect`

O CLI vem com [agent wallets com custódia Privy](https://www.alchemy.com/blog/agent-wallets-alchemy-cli). Privy é o provedor de embedded wallet que mantém a private key da wallet do lado deles. `alchemy wallet connect --mode session` gera um novo par de chaves P-256 localmente, registra uma sessão com prazo determinado junto ao backend da Privy, e assina em duas etapas: o CLI assina o payload da session-key, e a Privy assina a wallet. A private key nunca sai da Privy e a session key nunca sai do seu dispositivo.

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

Revogue pelo dashboard ou com `alchemy wallet disconnect`, e a sessão para de funcionar imediatamente. Para um fluxo com chave local: `alchemy wallet connect --mode local --chain evm --import ~/.wallet/key`. De qualquer forma, a private key nunca fica armazenada em `.env`.

### 3. Pague conforme o uso com `--x402`

Defina `--x402` em qualquer comando e o CLI se autentica nas nossas APIs usando a wallet conectada em vez de uma API key. Quando uma requisição atinge um endpoint pago, o endpoint retorna HTTP 402, o CLI assina o [payload de pagamento x402](https://docs.x402.org/), e a requisição é concluída. x402 é uma especificação aberta da Coinbase para pagamentos nativos em HTTP; as liquidações rodam em USDC na Base. Agentes podem começar com [apenas $1](https://www.alchemy.com/blog/ai-agents-can-now-sign-up-for-alchemy) em créditos de computação, sem precisar de cadastro no 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`}
/>

Um agente (ou um dev humano que nunca se cadastrou) agora pode acessar as mesmas APIs que rodam suas cargas de trabalho de produção. Sem API key, sem dashboard, sem contrato.

## Leia qualquer chain sem escrever boilerplate de fetch

### 4. Chame qualquer método JSON-RPC em qualquer chain

`alchemy evm rpc` repassa qualquer método JSON-RPC para a rede que você selecionar com `-n`. Sem escrever envelopes de fetch na mão, sem a dança de instalar um SDK para um script de cinco linhas.

<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, use `alchemy solana rpc` para JSON-RPC e `alchemy solana das` para métodos Digital Asset Standard. A estrutura se mantém a mesma em todas as chains que suportamos.

### 5. Puxe um portfólio multi-chain em uma única chamada

`alchemy evm data portfolio tokens` retorna saldos de tokens em todas as chains que uma wallet já tocou. Sem costurar sete provedores de RPC, sem fazer `eth_call` chain por chain para 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"]
  }]
}'`}
/>

Combine com `portfolio nfts` para o mesmo truque em coleções de NFT. Os mesmos endpoints alimentam os indexadores da nossa [Data API](https://www.alchemy.com/docs/data) em produção.

### 6. Consulte saldos, transferências e NFTs com um comando só

Saldos, metadados de token, histórico de transferências e NFTs vêm cada um como um único subcomando na superfície da Data API. Adicione `--metadata` e a chamada retorna nome, símbolo, decimais e URL do logo inline.

<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`}
/>

As leituras que antes exigiam quatro clientes de SDK diferentes agora são quatro flags em um único CLI.

## Envie transações direto do seu shell

### 7. Simule antes de enviar

`alchemy evm simulate asset-changes` retorna um diff legível de cada movimentação de token e ETH que uma transação causaria. `simulate execution` retorna o trace completo. Quem lê vê exatamente o que a chamada faz antes de ela chegar onchain.

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

Rode isso antes de qualquer `evm send` ou `contract call` que mexa com fundos na mainnet. Isso evita o "acabei de quebrar minha hot wallet" que exige refazer tudo.

### 8. Envie para um nome ENS em uma linha

<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` resolve o ENS, cuida do gas, e assina com qualquer wallet ativa no momento (sessão, local, ou custodiada pela Privy). Combine com `--x402` e a mesma chamada é roteada pela wallet que você conectou no passo 2.

### 9. Aprove, faça swap e bridge no mesmo shell

`alchemy evm swap execute` leva um swap na mesma chain do quote até a execução. `alchemy xchain bridge execute` faz a versão cross-chain. `alchemy evm approve` cuida do allowance ERC-20 que todo swap em DEX exige primeiro.

<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`}
/>

O swap na mesma chain já está disponível em 11 mainnets EVM, incluindo Ethereum, Base, Arbitrum, Optimism, Polygon e BSC, conforme os [docs do Alchemy CLI](https://www.alchemy.com/docs/alchemy-cli). O bridge cross-chain também já está disponível no CLI hoje. O assistente do dashboard se resume a três linhas de shell.

## Conecte o CLI ao seu agente de código

### 10. Gere um manifesto completo do agente com `alchemy agent-prompt`

`alchemy agent-prompt` gera um documento JSON descrevendo cada comando, flag, código de erro e exemplo. Encadeie-o no system prompt do seu agente e ele para de adivinhar nomes de flags.

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

O manifesto inclui uma política de execução, verificações preflight, a matriz de auth, a árvore de comandos com opções, um catálogo de erros com a semântica de retry, e exemplos executáveis. Para Cursor, Claude Code, Codex, ou qualquer outro agente de código, o arquivo vai direto para o system prompt. Padrão em prática: [Como construir agentes onchain](https://www.alchemy.com/blog/how-to-build-onchain-agents).

### 11. Instale o Alchemy Skills

`alchemy install skills` instala o [pacote Alchemy Skills](https://github.com/alchemyplatform/skills) no seu cliente de agente. Skills são fluxos de trabalho legíveis por máquina que ensinam um agente de código a usar o CLI sem precisar ler a documentação em tempo de execução.

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

O pacote cobre quatro superfícies: o próprio CLI, integração de apps via API keys, MCP, e o fluxo de pagamento baseado em wallet. Um comando troca "o agente tem que vasculhar a documentação a cada sessão" por "o agente já conhece o fluxo de trabalho".

### 12. Configure o MCP

`alchemy install mcp` conecta o [servidor Alchemy MCP](https://www.alchemy.com/docs/alchemy-mcp-server) no seu cliente de agente. MCP (Model Context Protocol) é uma especificação aberta que permite que agentes descubram e chamem ferramentas em tempo de execução. O servidor hospedado fica em `https://mcp.alchemy.com/mcp` e expõe mais de 150 ferramentas em mais de 100 chains: admin, todos os métodos de RPC, e a superfície da Data API.

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

Especificamente para Claude Code:

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

Skills, o manifesto de agent-prompt, e o MCP juntos fazem do CLI uma capacidade de primeira classe dentro do inventário de ferramentas de um agente, não uma dependência secundária.

## A demo de agente com cinco chamadas: comparação de yield, bridge, supply

A demo canônica que acompanha o [repositório do Alchemy Skills](https://github.com/alchemyplatform/skills) lê o APY de supply de USDC na Polygon, Arbitrum e Optimism, faz bridge de 0,2 USDC da Base para a chain com maior yield, e faz supply na Aave V3. Cinco chamadas de CLI, na mesma superfície que alimenta o resto deste post.

<ImageBlock
  src="https://media.alchemy.com/blog/12-things-alchemy-cli-demo.png"
  alt="Um agente usando o Alchemy CLI para comparar os rendimentos de USDC da Aave entre L2s, fazer bridge de Base para Arbitrum e fornecer liquidez à Aave, tudo pelo terminal, sem chave privada bruta"
  width={1058}
  height={1292}
  caption="Source: https://x.com/uttam_singhk/status/2054540200874025224"
/>

Na demo acima, o agente encontra o melhor mercado da Aave para USDC, faz bridge dos fundos para a chain certa, e deposita no pool. Até hoje, esse fluxo de trabalho exigia código customizado de agente segurando uma private key ou uma integração construída à mão entre um SDK de wallet e um assistente de código. Agora são alguns comandos e um clique no dashboard.

## Comece seu primeiro comando

Você acabou de ver doze comandos. Aqui está o on-ramp de dois minutos: instale, faça login, conecte uma wallet, envie.

<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`}
/>

Sem a bagunça de SDKs, sem private key em `.env`, sem ida e volta ao dashboard. Seja qual for o seu fluxo de trabalho onchain, o CLI o executa a partir de um único prompt. Seu terminal é o caminho mais rápido para o onchain.