---
title: "Configure o Claude Code com a Alchemy em 60 segundos"
description: "Conecte o Claude Code à Alchemy com um único comando. Seu coding agent passa a ter dados em tempo real em mais de 100 chains: preços, saldos, NFTs, transfers e simulation."
---

# Configure o Claude Code com a Alchemy em 60 segundos

<ImageBlock
  src="https://media.alchemy.com/blog/setup-claude-code-alchemy-hero-16x9-20260821.png"
  alt="Configure o Claude Code com a Alchemy em 60 segundos"
  width={1920}
  height={1080}
  priority
/>

O Claude Code é bom em escrever código que conversa com uma blockchain. O problema começa depois disso. Ele tenta adivinhar qual método [RPC](https://www.alchemy.com/rpc-api) chamar, inventa o formato da resposta e não tem como verificar um saldo, um preço ou o que uma transação realmente fez. Então ele escreve código plausível com base em dados que não consegue ver.

Um único comando resolve isso. Conecte o Claude Code à Alchemy e ele para de adivinhar. Ele lê dados em tempo real em mais de 100 chains, simula uma transação antes de qualquer execução e, se você permitir, assina e envia. Um comando transforma o Claude Code em um agente onchain, e a configuração leva cerca de um minuto.

## O que a conexão entre Claude Code e Alchemy faz?

A conexão funciona sobre o MCP (Model Context Protocol), um padrão aberto que permite a um agente descobrir e chamar ferramentas externas em tempo de execução. Nosso [servidor Alchemy MCP](https://www.alchemy.com/docs/alchemy-mcp-server) é hospedado, então não há nada para rodar localmente. Aponte o Claude Code para ele uma vez e ele passa a ter acesso a [168 ferramentas em mais de 100 redes](https://www.alchemy.com/docs/alchemy-mcp-server), agrupadas em três famílias: admin (gerenciamento dos seus apps), RPC (todo método JSON-RPC em cada chain) e data (preços, saldos de tokens e NFTs, histórico de transferências, portfólios multi-chain e simulação de transações).

A diferença aparece na primeira vez que você faz uma pergunta real. Sem uma conexão de dados, "qual é o preço atual do ETH?" te dá um número vindo dos dados de treinamento, que já estava desatualizado no dia em que o modelo foi lançado. Com o servidor conectado, o Claude Code chama uma ferramenta e lê o preço de um endpoint ao vivo. O mesmo vale para o saldo de uma carteira, o dono de um NFT ou as mudanças de ativos que uma transação pendente causaria. Seu agente deixa de escrever código sobre a chain e passa a ler a chain diretamente.

## Configuração em 60 segundos

O caminho mais rápido é o servidor hospedado. Execute um comando no seu terminal:

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

Reinicie o Claude Code (ou abra uma nova conversa) e execute `/mcp` para confirmar que `alchemy` aparece na lista de servidores ativos. Na primeira vez que o Claude Code chamar uma ferramenta da Alchemy, uma janela do navegador abre para você fazer login com sua conta. A autenticação usa OAuth, então não há chave de API para colar, nenhuma instalação local, e nada em um arquivo `.env`.

Depois disso, aponte seu agente para um dos seus apps ("select an Alchemy app") e comece a perguntar. É essa a configuração completa: um comando, um login pelo navegador, e seu agente de código já está lendo dados onchain em tempo real.

## O que você pode perguntar depois de conectado?

O ponto da conexão é que você pergunta em português claro (ou inglês) e o Claude Code escolhe a ferramenta certa. Alguns prompts que funcionam assim que o servidor está conectado:

- "What's the current price of ETH and USDC?" lê preços à vista na superfície Prices da [Data API](https://www.alchemy.com/docs/data).
- "Show me the tokens vitalik.eth holds across Ethereum, Base, and Arbitrum." traz um portfólio multi-chain em uma única chamada, em vez de consultar cada chain manualmente.
- "What did transaction 0xabc... actually do?" roda uma simulação e retorna um diff legível de cada movimento de token e ETH, para que o agente raciocine sobre os efeitos, não sobre calldata bruto.
- "Which contracts has this address interacted with in the last 100 blocks?" lê o histórico de transferências e os logs de eventos diretamente.

Cada resposta volta como dado estruturado que o agente pode usar, não como texto que ele precisa interpretar. É isso que torna um agente conectado útil. Ele lê sua própria fonte de verdade e, a partir daí, escreve código ou faz uma recomendação com base em dados que são verdadeiros agora.

## Como ir além com a CLI e Skills?

O servidor hospedado é o caminho mais rápido para começar. Se você preferir algo empacotado, o [Alchemy plugin for Claude Code](https://www.alchemy.com/blog/alchemy-claude-plugin-now-live) empacota o mesmo servidor MCP com slash commands como `/alchemy:balance` e Agent Skills em uma única instalação. E a [Alchemy CLI](https://agents.alchemy.com/) é o caminho para ir mais fundo, porque ela adiciona duas coisas que nenhuma das outras opções oferece: comandos scriptáveis que você pode encadear em pipe e assinatura de transações com uma carteira que você controla.

Instale, faça login e conecte à Claude Code:

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

`alchemy install skills` adiciona [Alchemy Skills](https://github.com/alchemyplatform/skills), fluxos de trabalho legíveis por máquina que ensinam um agente de código a usar a CLI sem precisar varrer a documentação em tempo de execução. O pacote cobre quatro superfícies: a própria CLI, integração de apps com uma chave de API, MCP e o fluxo de pagamento baseado em carteira. Mais um comando, `alchemy agent-prompt`, gera um manifesto JSON com todo comando, flag, código de erro e exemplo executável, que você pode colocar diretamente no contexto do Claude Code. Juntos, Skills e o manifesto fazem com que o agente já conheça a superfície antes mesmo de ver uma única página de documentação. A referência completa está nos [Alchemy CLI docs](https://www.alchemy.com/docs/alchemy-cli) e no [build with AI overview](https://www.alchemy.com/docs/build-with-ai-overview).

## O Claude Code pode assinar e enviar transações?

Leitura é segura por padrão. Escrita precisa de uma carteira, e a primeira pergunta que todo desenvolvedor deveria fazer é onde fica a chave privada. Com a CLI, ela nunca fica no contexto do seu agente.

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

Isso conecta [agent wallets com custódia da Privy](https://www.alchemy.com/blog/agent-wallets-alchemy-cli). A Privy mantém a chave privada da carteira do lado dela. A CLI gera uma chave de sessão nova e com tempo limitado no seu dispositivo e assina com ela, então um prompt comprometido não consegue esvaziar a carteira, e a chave bruta nunca chega ao modelo. Revogue a sessão pelo dashboard ou com `alchemy wallet disconnect`, e ela para de funcionar imediatamente. A partir daí o agente pode simular uma transação, mostrar o diff para você e enviar somente depois da sua aprovação. A regra vale qualquer que seja o modo escolhido. O agente nunca vê uma chave privada bruta, e se o seu design colocar uma no contexto, você construiu uma vulnerabilidade em vez de um agente.

Esse também é o padrão que vale a pena ensinar às suas ferramentas. Um agente de código sem contexto da Alchemy tende a recorrer ao manuseio bruto de chaves quando você pede para assinar algo. Conecte a CLI e o fluxo de sessão gerenciada se torna o padrão que ele usa, que é a resposta mais segura e a que você quer que ele aprenda. Para a arquitetura completa, veja [how to build onchain agents](https://www.alchemy.com/blog/how-to-build-onchain-agents).

Se quiser explorar mais, confira estas demos:

<a
  href="https://x.com/uttam_singhk/status/2054540200874025224"
  target="_blank"
  rel="noopener noreferrer"
>
  <ImageBlock
    src="https://media.alchemy.com/blog/setup-claude-code-alchemy-tweet-aave.png"
    alt="Um agente usando a Alchemy CLI para encontrar o melhor yield de USDC na Aave, comparar taxas entre L2s do Ethereum, fazer bridge da Base para a Arbitrum, e fazer supply, tudo pelo terminal sem chave privada bruta"
    width={1036}
    height={1322}
    caption="Source: https://x.com/uttam_singhk/status/2054540200874025224"
  />
</a>

<a
  href="https://x.com/uttam_singhk/status/2071581970807902420"
  target="_blank"
  rel="noopener noreferrer"
>
  <ImageBlock
    src="https://media.alchemy.com/blog/setup-claude-code-alchemy-tweet-solana.png"
    alt="Um agente de trading orientado por notícias na Solana: Phoenix para execução via phoenix-cli, conectado a um feed de notícias em tempo real, o modelo de sua escolha, e a Alchemy para RPC rápido e confiável"
    width={1036}
    height={1322}
    caption="Source: https://x.com/uttam_singhk/status/2071581970807902420"
  />
</a>

## Comece em 60 segundos

Conecte o Claude Code a dados onchain em tempo real com um comando:

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

Faça login quando o navegador abrir e comece a perguntar. Sem chave de API, sem cadastro no dashboard, sem instalação local. Quer assinatura e comandos scriptáveis também? Instale a [Alchemy CLI](https://agents.alchemy.com/), execute `alchemy auth login`, e seu agente pode ler, simular e enviar a partir da mesma configuração. Seu agente de código já escreve código onchain. Agora ele também pode executá-lo.