# Início rápido > Source: https://docs.blockvectra.com/pt-br/quickstart/ Desenvolvedores e agentes de IA podem testar o RPC público sem API key e, depois, criar uma API key para continuar. ## 1. Consultar a altura de bloco sem API key Chame o endpoint JSON-RPC público da rede de exemplo `robinhood_mainnet` sem criar uma conta nem fornecer uma API key: ```bash curl -s "https://api.blockvectra.com/v1/robinhood_mainnet/public" \ -H 'Content-Type: application/json' \ -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' ``` O `id: 1` da resposta corresponde a esta requisição; `result` é uma altura de bloco hexadecimal e pode mudar entre chamadas. Se a resposta contiver `error`, verifique seu código e motivo. Consulte os [endpoints RPC públicos gratuitos](https://blockvectra.com/en/free/#public-rpc) para métodos públicos, intervalos históricos e limites por IP. ## 2. Criar uma API key Acesse o [console](https://console.blockvectra.com/login/?next=%2Fkeys%2F), entre com GitHub, Google ou uma carteira Ethereum (sua conta é criada no primeiro login) e crie uma API key. O segredo é exibido apenas uma vez: armazene-o com segurança e defina-o na variável de ambiente `BLOCKVECTRA_API_KEY`. Não o inclua em código executado no navegador do cliente. Novas contas recebem 30,000,000 CU no cadastro — sem cartão de crédito. > **No API key yet?** > > Se você tem uma carteira Ethereum: siga o [guia de cadastro programático](https://docs.blockvectra.com/en/guides/programmatic-signup/) para se cadastrar e criar uma API key com uma assinatura da carteira Ethereum, sem navegador. Se não tem uma carteira: peça ao usuário que entre em [console.blockvectra.com](https://console.blockvectra.com/login/?next=%2Fkeys%2F), crie uma API key e a defina na variável de ambiente `BLOCKVECTRA_API_KEY`. Não peça ao usuário que cole a API key no chat. ## 3. Enviar sua primeira chamada autenticada Consulte a altura de bloco da mesma rede com o cabeçalho `x-api-key`. A URL termina com o nome da rede, sem barra final: ```bash : "${BLOCKVECTRA_API_KEY:?Set BLOCKVECTRA_API_KEY first}" curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \ -H 'Content-Type: application/json' \ -H "x-api-key: $BLOCKVECTRA_API_KEY" \ -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' ``` `result` é novamente uma altura de bloco hexadecimal. Esta requisição consome CU; consulte a [referência JSON-RPC](https://docs.blockvectra.com/en/api/json-rpc/) para pesos dos métodos e códigos de erro e [Preços](https://blockvectra.com/en/pricing/) para os preços atuais. Uma API key nova entra em vigor em cerca de 5 segundos; se receber `invalid_api_key`, aguarde um momento e tente novamente. Consulte [Erros comuns](#common-errors) abaixo para outras falhas. ## 4. Continuar com uma tarefa de negócio * [Consultar a atividade de ações tokenizadas on-chain na Robinhood Chain](https://docs.blockvectra.com/en/guides/stocks/) * [Recuperar logs históricos da HyperEVM em partes](https://docs.blockvectra.com/en/guides/hyperevm-backfill/) * [Receber atividade de carteiras e transferências de tokens com Webhooks](https://docs.blockvectra.com/en/guides/webhook-push/) ## Referência ### API keys e saldo Template inicial completo: [blockvectra/agent-quickstart](https://github.com/blockvectra/agent-quickstart) Toda API key tem o prefixo `rgw_` seguido de 64 caracteres hexadecimais, por exemplo `rgw_1f2e...` (abreviado). Mantenha-a em segredo — qualquer pessoa com a API key pode gastar seu saldo. > Quando seu saldo é insuficiente, o servidor retorna HTTP 402 (código de erro JSON-RPC `-32020`; Data API `error.code` `insufficient_balance`). Acesse a [página de cobrança](https://console.blockvectra.com/billing/) do console para verificar seu saldo e os métodos de recarga. ### Teste sem API key Você pode chamar o endpoint JSON-RPC público imediatamente sem criar uma conta nem fornecer uma API key. O endpoint do exemplo abaixo tem limite de taxa por IP (3 req/s, burst 20, máximo de 10 chamadas por lote). Requisições que ultrapassam os limites retornam HTTP 429 com o motivo `public_rate_limit` ou `public_pool_busy` (com um cabeçalho `Retry-After`); métodos não compatíveis retornam o erro JSON-RPC `-32601` (`method_not_public`). ```bash # Direct public endpoint: curl -s "https://api.blockvectra.com/v1/robinhood_mainnet/public" \ -H 'Content-Type: application/json' \ -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' # Or using the API key fallback pattern (defaults to public when BLOCKVECTRA_API_KEY is unset): curl -s "https://api.blockvectra.com/v1/robinhood_mainnet/${BLOCKVECTRA_API_KEY:-public}" \ -H 'Content-Type: application/json' \ -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' ``` #### Endpoints públicos por rede - Arbitrum One: https://api.blockvectra.com/v1/arb_mainnet/public — Ler e transmitir transações assinadas (eth_sendRawTransaction) - Base: https://api.blockvectra.com/v1/base_mainnet/public — Ler e transmitir transações assinadas (eth_sendRawTransaction) - BNB Smart Chain: https://api.blockvectra.com/v1/bsc_mainnet/public — Ler e transmitir transações assinadas (eth_sendRawTransaction) - Ethereum: https://api.blockvectra.com/v1/eth_mainnet/public — Ler e transmitir transações assinadas (eth_sendRawTransaction) - Ethereum Sepolia: https://api.blockvectra.com/v1/eth_sepolia/public — Ler e transmitir transações assinadas (eth_sendRawTransaction) - HyperEVM: https://api.blockvectra.com/v1/hyperevm_mainnet/public — Somente leitura - Polygon: https://api.blockvectra.com/v1/polygon_mainnet/public — Ler e transmitir transações assinadas (eth_sendRawTransaction) - Robinhood Chain: https://api.blockvectra.com/v1/robinhood_mainnet/public — Ler e transmitir transações assinadas (eth_sendRawTransaction) - Robinhood Chain Testnet: https://api.blockvectra.com/v1/robinhood_testnet/public — Ler e transmitir transações assinadas (eth_sendRawTransaction) Os dois endpoints públicos de metadados abaixo mostram o status do serviço e a configuração de cada rede; não exigem API key e não são cobrados. ### Verificar o status do serviço e das redes ```bash curl https://api.blockvectra.com/v1/status ``` Retorna o horário da verificação `checked_at`, o status operacional do serviço `gateway.status` e, para cada rede compatível, o progresso de sincronização do nó `sync`, a altura do bloco mais recente e a latência `head`: ```json { "checked_at": "2026-10-03T13:30:47Z", "gateway": { "status": "ok" }, "chains": [ { "chain": "bsc_mainnet", "name": "BNB Smart Chain", "chain_id": 56, "jsonrpc": true, "data": true, "data_features": [ "blocks", "transactions", "address_transactions", "transfers", "token_metadata", "freshness" ], "data_status": "ok", "data_head_block": 125492675, "data_head_age_seconds": 3, "status": "ok", "sync": { "stage": "synced", "node_block": 125492676, "target_block": null }, "head": { "block": 125492676, "time": "2026-10-03T13:30:45Z", "lag_seconds": 2 } } ] } ``` ### Consultar redes compatíveis e políticas de métodos ```bash curl https://api.blockvectra.com/v1/chains ``` Retorna o `chain_id` de cada rede compatível, indicadores de recursos para JSON-RPC, Data API e WebSocket, políticas de métodos permitidos e negados (`methods.allow` e `methods.deny`), limite do intervalo de blocos por consulta de logs `max_logs_block_range` e janela de estado histórico `state_window_blocks`: ```json { "chains": [ { "chain": "bsc_mainnet", "name": "BNB Smart Chain", "chain_id": 56, "jsonrpc": true, "data": true, "ws": false, "subscriptions": [], "methods": { "allow": [ "eth_blockNumber", "eth_call", "eth_chainId", "eth_getLogs" ], "deny": [ "eth_newFilter", "eth_subscribe", "eth_unsubscribe" ] }, "max_logs_block_range": 1000, "state_window_blocks": 990000, "info": {} } ] } ``` ### Escolher uma rede Todo endpoint BlockVectra é específico de uma rede: requisições JSON-RPC levam o nome da rede `{chain}` no caminho da URL, e requisições Data API usam esse nome como prefixo da rota. Consulte [Redes compatíveis](https://docs.blockvectra.com/en/chains/) para as redes atualmente disponíveis e seus identificadores. | Rede | {chain} | Chain ID | Tracing | Endpoint público | WebSocket | Data API | Métodos com chave API | Notificações Webhook | Enviar transações | Enviar transações (endpoint público sem key) | Janela de histórico de estado | Intervalo máximo de blocos para eth_getLogs | Conjuntos de dados da Data API | Redes de teste relacionadas | Guias relacionados | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | [RPC e Data API de arb_mainnet](https://blockvectra.com/pt-br/chains/arb_mainnet/) | arb_mainnet | 42161 | ✓ | `https://api.blockvectra.com/v1/arb_mainnet/public` | Não compatível | Disponível | 43 | [Compatível · Confirmações 1–1 (padrão 1)](https://blockvectra.com/pt-br/webhooks/), [Guia de notificações Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatível | Compatível | Estado histórico para os 6,000 blocos mais recentes | 1,000 blocos | Blocos, Transações, Transações de endereços, Transferências, Metadados de tokens, Atualidade dos dados | Desconhecida | Desconhecida | | [RPC e Data API de base_mainnet](https://blockvectra.com/pt-br/chains/base_mainnet/) | base_mainnet | 8453 | — | `https://api.blockvectra.com/v1/base_mainnet/public` | Não compatível | Disponível | 39 | [Compatível · Confirmações 1–1 (padrão 1)](https://blockvectra.com/pt-br/webhooks/), [Guia de notificações Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatível | Compatível | Estado histórico para os 10,000 blocos mais recentes | 1,000 blocos | Blocos, Transações, Transações de endereços, Transferências, Metadados de tokens, Atualidade dos dados | Desconhecida | [Base](https://docs.blockvectra.com/en/guides/base/) | | [RPC e Data API de bsc_mainnet](https://blockvectra.com/pt-br/chains/bsc_mainnet/) | bsc_mainnet | 56 | — | `https://api.blockvectra.com/v1/bsc_mainnet/public` | Não compatível | Disponível | 25 | [Compatível · Confirmações 1–1 (padrão 1)](https://blockvectra.com/pt-br/webhooks/), [Guia de notificações Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatível | Compatível | Estado histórico para os 100 blocos mais recentes | 1,000 blocos | Blocos, Transações, Transações de endereços, Transferências, Metadados de tokens, Atualidade dos dados | Desconhecida | Desconhecida | | [RPC e Data API de Ethereum](https://blockvectra.com/pt-br/chains/eth_mainnet/) | eth_mainnet | 1 | ✓ | `https://api.blockvectra.com/v1/eth_mainnet/public` | Não compatível | Disponível | 38 | [Compatível · Confirmações 1–1 (padrão 1)](https://blockvectra.com/pt-br/webhooks/), [Guia de notificações Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatível | Compatível | Estado histórico para os 250,000 blocos mais recentes | 1,000 blocos | Blocos, Transações, Transações de endereços, Transferências, Metadados de tokens, Atualidade dos dados | Desconhecida | Desconhecida | | [RPC e Data API de eth_sepolia](https://blockvectra.com/pt-br/chains/eth_sepolia/) | eth_sepolia | 11155111 | — | `https://api.blockvectra.com/v1/eth_sepolia/public` | Não compatível | Disponível | 29 | [Compatível · Confirmações 1–1 (padrão 1)](https://blockvectra.com/pt-br/webhooks/), [Guia de notificações Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatível | Compatível | Desconhecida | 1,000 blocos | Blocos, Transações, Transações de endereços, Transferências, Metadados de tokens, Atualidade dos dados | Desconhecida | Desconhecida | | [RPC e Data API de HyperEVM](https://blockvectra.com/pt-br/chains/hyperevm_mainnet/) | hyperevm_mainnet | 999 | — | `https://api.blockvectra.com/v1/hyperevm_mainnet/public` | Não compatível | Disponível | 24 | [Compatível · Confirmações 1–1 (padrão 1)](https://blockvectra.com/pt-br/webhooks/), [Guia de notificações Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Não compatível | Não compatível | Desconhecida | 1,000 blocos | Blocos, Transações, Transações de endereços, Transferências, Metadados de tokens, Saldos, Detentores, NFT, Atualidade dos dados | Desconhecida | [HyperEVM backfill and polling](https://docs.blockvectra.com/en/guides/hyperevm-backfill/) | | [RPC e Data API de polygon_mainnet](https://blockvectra.com/pt-br/chains/polygon_mainnet/) | polygon_mainnet | 137 | ✓ | `https://api.blockvectra.com/v1/polygon_mainnet/public` | Não compatível | Disponível | 43 | [Compatível · Confirmações 1–1 (padrão 1)](https://blockvectra.com/pt-br/webhooks/), [Guia de notificações Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatível | Compatível | Estado histórico para os 126 blocos mais recentes | 1,000 blocos | Blocos, Transações, Transações de endereços, Transferências, Metadados de tokens, Atualidade dos dados | Desconhecida | Desconhecida | | [RPC e Data API de Robinhood Chain](https://blockvectra.com/pt-br/chains/robinhood_mainnet/) | robinhood_mainnet | 4663 | ✓ | `https://api.blockvectra.com/v1/robinhood_mainnet/public` | Compatível (newHeads, logs) | Disponível | 43 | [Compatível · Confirmações 1–1 (padrão 1)](https://blockvectra.com/pt-br/webhooks/), [Guia de notificações Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatível | Compatível | Estado histórico para os 900 blocos mais recentes | 1,000 blocos | Blocos, Transações, Transações de endereços, Transferências, Metadados de tokens, Saldos, Detentores, NFT, Swaps de DEX, Preços de DEX, Ações tokenizadas, Traces, Atualidade dos dados | Desconhecida | [Robinhood Chain](https://docs.blockvectra.com/en/guides/robinhood-chain/), [Stock token multiplier](https://docs.blockvectra.com/en/guides/stock-token-multiplier/), [Tokenized stocks](https://docs.blockvectra.com/en/guides/stocks/) | | [RPC de robinhood_testnet](https://blockvectra.com/pt-br/chains/robinhood_testnet/) | robinhood_testnet | 46630 | ✓ | `https://api.blockvectra.com/v1/robinhood_testnet/public` | Compatível (newHeads, logs) | Ainda indisponível | 43 | [Compatível · Confirmações 1–1 (padrão 1)](https://blockvectra.com/pt-br/webhooks/), [Guia de notificações Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatível | Compatível | Estado histórico para os 1,023 blocos mais recentes | 1,000 blocos | Não compatível | Desconhecida | [Testnet faucet](https://docs.blockvectra.com/en/guides/robinhood-testnet-faucet/), [Robinhood Chain Testnet starter](https://docs.blockvectra.com/en/guides/robinhood-testnet-starter/) | ## Próximos passos com uma chave API ### arb_mainnet #### eth_getLogs ```bash set -eu MAX_LOGS_BLOCK_RANGE=1000 head=$(curl -fsS 'https://api.blockvectra.com/v1/arb_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))') from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0)) from_hex=$(printf '0x%x' "$from") to_hex=$(printf '0x%x' "$head") curl -fsS 'https://api.blockvectra.com/v1/arb_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \ -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}" ``` [eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/) #### Data API ```bash curl -fsS 'https://api.blockvectra.com/v1/data/arb_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` [Data API](https://docs.blockvectra.com/en/api/data/) [Criar uma assinatura Webhook](https://blockvectra.com/pt-br/webhooks/) · [Criar uma assinatura Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso e CU](https://console.blockvectra.com/usage/) · [Recarregar](https://console.blockvectra.com/billing/) ### base_mainnet #### eth_getLogs ```bash set -eu MAX_LOGS_BLOCK_RANGE=1000 head=$(curl -fsS 'https://api.blockvectra.com/v1/base_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))') from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0)) from_hex=$(printf '0x%x' "$from") to_hex=$(printf '0x%x' "$head") curl -fsS 'https://api.blockvectra.com/v1/base_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \ -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}" ``` [eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/) #### Data API ```bash curl -fsS 'https://api.blockvectra.com/v1/data/base_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` [Data API](https://docs.blockvectra.com/en/api/data/) [Criar uma assinatura Webhook](https://blockvectra.com/pt-br/webhooks/) · [Criar uma assinatura Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso e CU](https://console.blockvectra.com/usage/) · [Recarregar](https://console.blockvectra.com/billing/) ### bsc_mainnet #### eth_getLogs ```bash set -eu MAX_LOGS_BLOCK_RANGE=1000 head=$(curl -fsS 'https://api.blockvectra.com/v1/bsc_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))') from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0)) from_hex=$(printf '0x%x' "$from") to_hex=$(printf '0x%x' "$head") curl -fsS 'https://api.blockvectra.com/v1/bsc_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \ -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}" ``` [eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/) #### Data API ```bash curl -fsS 'https://api.blockvectra.com/v1/data/bsc_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` [Data API](https://docs.blockvectra.com/en/api/data/) [Criar uma assinatura Webhook](https://blockvectra.com/pt-br/webhooks/) · [Criar uma assinatura Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso e CU](https://console.blockvectra.com/usage/) · [Recarregar](https://console.blockvectra.com/billing/) ### Ethereum #### eth_getLogs ```bash set -eu MAX_LOGS_BLOCK_RANGE=1000 head=$(curl -fsS 'https://api.blockvectra.com/v1/eth_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))') from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0)) from_hex=$(printf '0x%x' "$from") to_hex=$(printf '0x%x' "$head") curl -fsS 'https://api.blockvectra.com/v1/eth_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \ -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}" ``` [eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/) #### Data API ```bash curl -fsS 'https://api.blockvectra.com/v1/data/eth_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` [Data API](https://docs.blockvectra.com/en/api/data/) [Criar uma assinatura Webhook](https://blockvectra.com/pt-br/webhooks/) · [Criar uma assinatura Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso e CU](https://console.blockvectra.com/usage/) · [Recarregar](https://console.blockvectra.com/billing/) ### eth_sepolia #### eth_getLogs ```bash set -eu MAX_LOGS_BLOCK_RANGE=1000 head=$(curl -fsS 'https://api.blockvectra.com/v1/eth_sepolia' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))') from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0)) from_hex=$(printf '0x%x' "$from") to_hex=$(printf '0x%x' "$head") curl -fsS 'https://api.blockvectra.com/v1/eth_sepolia' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \ -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}" ``` [eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/) #### Data API ```bash curl -fsS 'https://api.blockvectra.com/v1/data/eth_sepolia/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` [Data API](https://docs.blockvectra.com/en/api/data/) [Criar uma assinatura Webhook](https://blockvectra.com/pt-br/webhooks/) · [Criar uma assinatura Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso e CU](https://console.blockvectra.com/usage/) · [Recarregar](https://console.blockvectra.com/billing/) ### HyperEVM #### eth_getLogs ```bash set -eu MAX_LOGS_BLOCK_RANGE=1000 head=$(curl -fsS 'https://api.blockvectra.com/v1/hyperevm_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))') from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0)) from_hex=$(printf '0x%x' "$from") to_hex=$(printf '0x%x' "$head") curl -fsS 'https://api.blockvectra.com/v1/hyperevm_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \ -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}" ``` [eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/) #### Data API ```bash curl -fsS 'https://api.blockvectra.com/v1/data/hyperevm_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` [Data API](https://docs.blockvectra.com/en/api/data/) [Criar uma assinatura Webhook](https://blockvectra.com/pt-br/webhooks/) · [Criar uma assinatura Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso e CU](https://console.blockvectra.com/usage/) · [Recarregar](https://console.blockvectra.com/billing/) ### polygon_mainnet #### eth_getLogs ```bash set -eu MAX_LOGS_BLOCK_RANGE=1000 head=$(curl -fsS 'https://api.blockvectra.com/v1/polygon_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))') from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0)) from_hex=$(printf '0x%x' "$from") to_hex=$(printf '0x%x' "$head") curl -fsS 'https://api.blockvectra.com/v1/polygon_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \ -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}" ``` [eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/) #### Data API ```bash curl -fsS 'https://api.blockvectra.com/v1/data/polygon_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` [Data API](https://docs.blockvectra.com/en/api/data/) [Criar uma assinatura Webhook](https://blockvectra.com/pt-br/webhooks/) · [Criar uma assinatura Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso e CU](https://console.blockvectra.com/usage/) · [Recarregar](https://console.blockvectra.com/billing/) ### Robinhood Chain #### eth_getLogs ```bash set -eu MAX_LOGS_BLOCK_RANGE=1000 head=$(curl -fsS 'https://api.blockvectra.com/v1/robinhood_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))') from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0)) from_hex=$(printf '0x%x' "$from") to_hex=$(printf '0x%x' "$head") curl -fsS 'https://api.blockvectra.com/v1/robinhood_mainnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \ -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}" ``` [eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/) #### Data API ```bash curl -fsS 'https://api.blockvectra.com/v1/data/robinhood_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` [Data API](https://docs.blockvectra.com/en/api/data/) #### WebSocket ```bash echo '{"jsonrpc":"2.0","id":1,"method":"eth_subscribe","params":["newHeads"]}' | websocat --no-close -H="x-api-key: $BLOCKVECTRA_API_KEY" 'wss://api.blockvectra.com/v1/robinhood_mainnet' ``` [WebSocket](https://docs.blockvectra.com/en/guides/websocket-subscriptions/) [Criar uma assinatura Webhook](https://blockvectra.com/pt-br/webhooks/) · [Criar uma assinatura Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso e CU](https://console.blockvectra.com/usage/) · [Recarregar](https://console.blockvectra.com/billing/) ### robinhood_testnet #### eth_getLogs ```bash set -eu MAX_LOGS_BLOCK_RANGE=1000 head=$(curl -fsS 'https://api.blockvectra.com/v1/robinhood_testnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' | python3 -c 'import json,sys; print(int(json.load(sys.stdin)["result"],16))') from=$((head >= MAX_LOGS_BLOCK_RANGE ? head - MAX_LOGS_BLOCK_RANGE + 1 : 0)) from_hex=$(printf '0x%x' "$from") to_hex=$(printf '0x%x' "$head") curl -fsS 'https://api.blockvectra.com/v1/robinhood_testnet' -H "x-api-key: $BLOCKVECTRA_API_KEY" -H 'Content-Type: application/json' \ -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getLogs\",\"params\":[{\"fromBlock\":\"$from_hex\",\"toBlock\":\"$to_hex\"}]}" ``` [eth_getLogs](https://docs.blockvectra.com/en/guides/getlogs-block-range/) #### WebSocket ```bash echo '{"jsonrpc":"2.0","id":1,"method":"eth_subscribe","params":["newHeads"]}' | websocat --no-close -H="x-api-key: $BLOCKVECTRA_API_KEY" 'wss://api.blockvectra.com/v1/robinhood_testnet' ``` [WebSocket](https://docs.blockvectra.com/en/guides/websocket-subscriptions/) [Criar uma assinatura Webhook](https://blockvectra.com/pt-br/webhooks/) · [Criar uma assinatura Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso e CU](https://console.blockvectra.com/usage/) · [Recarregar](https://console.blockvectra.com/billing/) **HyperEVM** Os blocos da HyperEVM incluem transações do sistema HyperCore (do endereço 0x2222…2222 ou 0x20…, gasPrice 0). O envio de transações ainda não é compatível com esta rede (`eth_sendRawTransaction` retorna `-32601` `method_not_allowed`); métodos de leitura funcionam normalmente. [Ver status em tempo real →](https://blockvectra.com/pt-br/status/) Todos os exemplos nesta página usam `robinhood_mainnet`. > **Dica**: escolha uma rede que ofereça o serviço, o método e a janela histórica do exemplo na matriz acima e substitua `robinhood_mainnet` por seu `{chain}`. A mesma API key funciona em todas as redes compatíveis. ### Outras opções de autenticação e exemplos por linguagem Os endpoints JSON-RPC são específicos de uma rede: `POST /v1/{chain}/{api_key}` com a API key no caminho ou `POST /v1/{chain}` com a API key no cabeçalho `x-api-key`. `{chain}` é o nome da rede também usado pela Data API; para Robinhood Chain, é `robinhood_mainnet`, portanto o endpoint nesta página é `https://api.blockvectra.com/v1/robinhood_mainnet`. Chamar `eth_subscribe` por HTTP retorna `-32601`; as assinaturas WebSocket estão listadas por rede em [Redes compatíveis](https://docs.blockvectra.com/en/chains/). A API envia `Access-Control-Allow-Origin: *`, mas você deve manter a API key em segredo e fazer requisições a partir de um serviço de backend, em vez de código no navegador do cliente. Você pode enviar a API key de três formas: no caminho da URL (`POST /v1/{chain}/{api_key}`, que usa apenas a API key do caminho e ignora os dois cabeçalhos), no cabeçalho `x-api-key` ou em um cabeçalho `Authorization: Bearer `. #### API key no caminho da URL **cURL** ```bash : "${BLOCKVECTRA_API_KEY:?Set BLOCKVECTRA_API_KEY first}" curl -s "https://api.blockvectra.com/v1/robinhood_mainnet/$BLOCKVECTRA_API_KEY" \ -H 'Content-Type: application/json' \ -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' ``` **TypeScript** ```ts import { createPublicClient, http } from "viem"; const key = process.env.BLOCKVECTRA_API_KEY!; const client = createPublicClient({ transport: http(`https://api.blockvectra.com/v1/robinhood_mainnet/${key}`), }); console.log(await client.getBlockNumber()); // Run with: npx tsx example.mts ``` Template inicial completo: [blockvectra/multichain-viem](https://github.com/blockvectra/multichain-viem) **Python** ```python import os from web3 import Web3 w3 = Web3(Web3.HTTPProvider("https://api.blockvectra.com/v1/robinhood_mainnet/" + os.environ["BLOCKVECTRA_API_KEY"])) print(w3.eth.block_number) ``` **Go** ```go // Run with: go mod init example && go get github.com/ethereum/go-ethereum && go mod tidy && go run . package main import ( "context" "fmt" "log" "os" "github.com/ethereum/go-ethereum/ethclient" ) func main() { client, err := ethclient.Dial("https://api.blockvectra.com/v1/robinhood_mainnet/" + os.Getenv("BLOCKVECTRA_API_KEY")) if err != nil { log.Fatal(err) } number, err := client.BlockNumber(context.Background()) if err != nil { log.Fatal(err) } fmt.Println(number) } ``` **Rust** ```toml [dependencies] alloy = { version = "1", features = ["provider-http", "rpc-types"] } tokio = { version = "1", features = ["macros", "rt-multi-thread"] } ``` ```rust use alloy::providers::{Provider, ProviderBuilder}; #[tokio::main] async fn main() -> Result<(), Box> { let key = std::env::var("BLOCKVECTRA_API_KEY")?; let url = format!("https://api.blockvectra.com/v1/robinhood_mainnet/{key}"); let provider = ProviderBuilder::new().connect_http(url.parse()?); println!("{}", provider.get_block_number().await?); Ok(()) } ``` #### API key em um cabeçalho de requisição **cURL** ```bash : "${BLOCKVECTRA_API_KEY:?Set BLOCKVECTRA_API_KEY first}" curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \ -H 'Content-Type: application/json' \ -H "x-api-key: $BLOCKVECTRA_API_KEY" \ -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' ``` **TypeScript** ```ts import { createPublicClient, http } from "viem"; const key = process.env.BLOCKVECTRA_API_KEY!; const client = createPublicClient({ transport: http("https://api.blockvectra.com/v1/robinhood_mainnet", { fetchOptions: { headers: { "x-api-key": key } }, }), }); console.log(await client.getBlockNumber()); // Run with: npx tsx example.mts ``` **Python** ```python import os from web3 import Web3 key = os.environ["BLOCKVECTRA_API_KEY"] # request_kwargs replaces the provider's default headers entirely, so # Content-Type must be repeated here or the server can't parse the body. headers = {"Content-Type": "application/json", "x-api-key": key} w3 = Web3(Web3.HTTPProvider("https://api.blockvectra.com/v1/robinhood_mainnet", request_kwargs={"headers": headers})) print(w3.eth.block_number) ``` **Go** ```go // Run with: go mod init example && go get github.com/ethereum/go-ethereum && go mod tidy && go run . package main import ( "context" "fmt" "log" "os" "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/rpc" ) func main() { ctx := context.Background() c, err := rpc.DialOptions(ctx, "https://api.blockvectra.com/v1/robinhood_mainnet", rpc.WithHeader("x-api-key", os.Getenv("BLOCKVECTRA_API_KEY"))) if err != nil { log.Fatal(err) } number, err := ethclient.NewClient(c).BlockNumber(ctx) if err != nil { log.Fatal(err) } fmt.Println(number) } ``` **Rust** ```toml [dependencies] alloy = { version = "1", features = ["provider-http", "rpc-types"] } tokio = { version = "1", features = ["macros", "rt-multi-thread"] } reqwest = "0.13" ``` ```rust use alloy::providers::{Provider, ProviderBuilder}; use alloy::rpc::client::RpcClient; use reqwest::header::{HeaderMap, HeaderValue}; #[tokio::main] async fn main() -> Result<(), Box> { let key = std::env::var("BLOCKVECTRA_API_KEY")?; let mut headers = HeaderMap::new(); headers.insert("x-api-key", HeaderValue::from_str(&key)?); let http_client = reqwest::Client::builder().default_headers(headers).build()?; let rpc_client = RpcClient::new_http_with_client(http_client, "https://api.blockvectra.com/v1/robinhood_mainnet".parse()?); let provider = ProviderBuilder::new().connect_client(rpc_client); println!("{}", provider.get_block_number().await?); Ok(()) } ``` > **No trailing slash** > > Ao enviar a API key em um cabeçalho, chame `https://api.blockvectra.com/v1/robinhood_mainnet` exatamente como mostrado: a URL termina com o nome da rede, **sem** barra final. JSON-RPC é servido apenas em `/v1/{chain}` e `/v1/{chain}/{api_key}`. Uma barra final (como `/v1/{chain}/`) ou uma requisição sem o segmento da rede (como `/v1` ou `/v1/`) retorna `404` com corpo vazio. Um cabeçalho `Authorization: Bearer ` também funciona. Em `POST /v1/{chain}`, um `x-api-key` não vazio tem precedência sobre Bearer, e Bearer é usado apenas quando `x-api-key` está ausente ou vazio. A forma com API key no caminho ignora os dois cabeçalhos. ### Chamadas em lote Envie um array para fazer várias chamadas em uma requisição (até 100 por lote). Cada API key tem um bucket de CU (reposição `cu_per_sec`, capacidade `burst_cu` — os padrões são 400 CU/s e burst de 1,600 CU; exibido por API key na tabela Keys do console); uma única requisição — incluindo um lote JSON-RPC inteiro — cujo total de CU ultrapasse a capacidade de burst da API key é rejeitada com `-32022 request_exceeds_burst`, mesmo abaixo do limite de 100 chamadas por lote; divida-a em lotes menores. Este exemplo consulta o Chain ID e o saldo de uma conta em uma única ida e volta: **cURL** ```bash curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \ -H 'Content-Type: application/json' \ -H "x-api-key: $BLOCKVECTRA_API_KEY" \ -d '[ {"jsonrpc":"2.0","id":1,"method":"eth_chainId"}, {"jsonrpc":"2.0","id":2,"method":"eth_getBalance","params":["0x1111111111111111111111111111111111111111","latest"]} ]' ``` **TypeScript** ```ts import { createPublicClient, http } from "viem"; const key = process.env.BLOCKVECTRA_API_KEY!; const client = createPublicClient({ transport: http("https://api.blockvectra.com/v1/robinhood_mainnet", { batch: true, fetchOptions: { headers: { "x-api-key": key } }, }), }); // viem coalesces concurrent requests into a single JSON-RPC batch. const [chainId, balance] = await Promise.all([ client.getChainId(), client.getBalance({ address: "0x1111111111111111111111111111111111111111" }), ]); console.log(chainId, balance); // Run with: npx tsx example.mts ``` **Python** ```python import os from web3 import Web3 key = os.environ["BLOCKVECTRA_API_KEY"] headers = {"Content-Type": "application/json", "x-api-key": key} w3 = Web3(Web3.HTTPProvider("https://api.blockvectra.com/v1/robinhood_mainnet", request_kwargs={"headers": headers})) with w3.batch_requests() as batch: batch.add(w3.eth.chain_id) batch.add(w3.eth.get_balance("0x1111111111111111111111111111111111111111")) chain_id, balance = batch.execute() print(chain_id, balance) ``` **Go** ```go // Run with: go mod init example && go get github.com/ethereum/go-ethereum && go mod tidy && go run . package main import ( "context" "fmt" "log" "os" "github.com/ethereum/go-ethereum/rpc" ) func main() { ctx := context.Background() c, err := rpc.DialOptions(ctx, "https://api.blockvectra.com/v1/robinhood_mainnet", rpc.WithHeader("x-api-key", os.Getenv("BLOCKVECTRA_API_KEY"))) if err != nil { log.Fatal(err) } var chainID, balance string calls := []rpc.BatchElem{ {Method: "eth_chainId", Result: &chainID}, {Method: "eth_getBalance", Args: []any{"0x1111111111111111111111111111111111111111", "latest"}, Result: &balance}, } if err := c.BatchCallContext(ctx, calls); err != nil { log.Fatal(err) } for _, call := range calls { if call.Error != nil { log.Fatal(call.Error) } } fmt.Println(chainID, balance) } ``` **Rust** ```toml [dependencies] alloy = { version = "1", features = ["provider-http", "rpc-types"] } tokio = { version = "1", features = ["macros", "rt-multi-thread"] } reqwest = "0.13" ``` ```rust use alloy::primitives::{Address, U256}; use alloy::rpc::client::RpcClient; use reqwest::header::{HeaderMap, HeaderValue}; #[tokio::main] async fn main() -> Result<(), Box> { let key = std::env::var("BLOCKVECTRA_API_KEY")?; let mut headers = HeaderMap::new(); headers.insert("x-api-key", HeaderValue::from_str(&key)?); let http_client = reqwest::Client::builder().default_headers(headers).build()?; let rpc_client = RpcClient::new_http_with_client(http_client, "https://api.blockvectra.com/v1/robinhood_mainnet".parse()?); let address: Address = "0x1111111111111111111111111111111111111111".parse()?; let mut batch = rpc_client.new_batch(); let chain_id = batch.add_call::<_, U256>("eth_chainId", &())?; let balance = batch.add_call::<_, U256>("eth_getBalance", &(address, "latest"))?; batch.send().await?; println!("{} {}", chain_id.await?, balance.await?); Ok(()) } ``` As respostas chegam como um array, na mesma ordem das requisições, associadas pelo `id`. Se o servidor rejeitar o lote inteiro — por saldo insuficiente, limite de taxa, capacidade de burst ou lote muito grande (consulte [Erros comuns](#common-errors) abaixo) — ele retorna um único objeto de erro JSON-RPC em vez de um array; o modo `batch: true` do viem apresenta isso como um `UnknownRpcError` sem detalhes, então repita uma chamada individual para ver o erro real. ### Entender a cobrança em CU Toda chamada cobrada consome **Compute Units (CU)**: chamadas leves como `eth_blockNumber` ou `eth_chainId` têm o menor custo, leituras comuns como `eth_getBlockByNumber` custam um pouco mais, chamadas mais pesadas como `eth_call` ou `eth_getLogs` custam mais, e métodos de trace de execução (como `debug_traceTransaction`) têm o maior custo. O uso é cobrado por conta por período de uma hora, arredondado para baixo em unidades inteiras de cobrança (1 unidade = 1,000 CU), com o restante transferido para o próximo período (portanto, entre períodos, o total cobrado é `floor(total CU / 1,000)`); a liquidação ocorre cerca de 15 minutos após o fim do período. Por exemplo: 508 CU transferidas + 2557 CU consumidas = 3065 CU, resultando em 3 unidades de cobrança e 65 CU transferidas para o próximo período. Consulte [Preços](https://blockvectra.com/en/pricing/) para os preços atuais. A tabela completa de pesos por método e os códigos de erro estão em [Referência da API → JSON-RPC](https://docs.blockvectra.com/en/api/json-rpc/) — esta página apresenta apenas o formato de uma requisição. #### Erros comuns | O que você fez | O que retorna | Ação | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Rede desconhecida ou ainda não pública | HTTP `404` com corpo JSON `error.data.reason: "unknown_chain"` | Verifique o nome da rede na URL | | Requisição sem o segmento da rede (por exemplo, `/v1` ou `/v1/`) | HTTP `404` com corpo vazio | Inclua o nome da rede na URL (`/v1/{chain}`) | | API key ausente, desconhecida ou desativada | HTTP `401`, código JSON-RPC `-32024` (`missing_api_key` ou `invalid_api_key`) | Use uma API key válida e ativa (API keys novas ou rotacionadas entram em vigor em todas as instâncias em cerca de 5 segundos; nesse período, podem retornar 401 `invalid_api_key` ou 503 `-32021` (com `Retry-After`) quando não é possível confirmar o estado de cobrança no momento, então aguarde um momento e tente novamente) | | Saldo zero ou negativo | HTTP `402`, código JSON-RPC `-32020` | Recarregue seu saldo ou aguarde a renovação gratuita | | Requisições enviadas muito rapidamente (limite de taxa ou sobrecarga temporária) | HTTP `429` (ou `200`), código JSON-RPC `-32005` | Tente novamente mais tarde (respeite `Retry-After` quando presente) | | Requisição individual ou lote ultrapassa a capacidade de burst da API key (`burst_cu`, padrão 1,600 CU; taxa padrão 400 CU/s), ou lote do plano gratuito ultrapassa chamadas/s (25 chamadas/s) | HTTP `429`, código JSON-RPC `-32022` (`request_exceeds_burst`) | Divida a requisição em lotes menores (ela nunca terá sucesso como foi enviada) | | Nó upstream temporariamente indisponível | HTTP `200`, código JSON-RPC `-32603` (`upstream unavailable`), sem cobrança | Repita a requisição | | Estado histórico fora da janela de estado da rede (consulte `state_window_blocks` em `GET /v1/chains`) | HTTP `200`, código JSON-RPC `-32011`, sem cobrança | Consulte um bloco mais recente | | Transação ou bloco não encontrado, ou resposta muito grande; na Ethereum, consultas de blocos / recibos / logs fora da janela recente também retornam -32000 "old data not available due to pruning" (sem cobrança; consulte [Redes compatíveis → Ethereum](https://docs.blockvectra.com/en/chains/#ethereum)) | HTTP `200`, código JSON-RPC `-32000` | Altere a requisição (verifique o hash ou número do bloco; hashes de trace malformados retornam transação não encontrada) | | Tracer não permitido ou timeout de trace não permitido (chamadas `debug_trace`) | HTTP `200`, código JSON-RPC `-32602`, sem cobrança | Use um tracer nativo permitido (`callTracer`, `flatCallTracer`, `prestateTracer`, `4byteTracer`, `noopTracer` ou omita) e timeout ≤ 30s | | Método não permitido pela lista de métodos da rede (consulte [Redes compatíveis](https://docs.blockvectra.com/en/chains/)) | HTTP `200`, código JSON-RPC `-32601`, sem cobrança | Chame apenas os métodos permitidos pela rede | | Corpo JSON malformado | HTTP `200`, código JSON-RPC `-32700`, sem cobrança | Corrija a sintaxe JSON da requisição | | Mais de 100 chamadas em um lote | HTTP `200`, código JSON-RPC `-32600` (`batch too large`), sem cobrança | Divida o lote em no máximo 100 chamadas | As rejeições acima nunca são cobradas. Toda chamada aceita que recebe uma resposta é cobrada pelo peso público de CU do método; a tabela de códigos de erro lista os casos sem cobrança (consulte a coluna de cobrança em [Códigos de erro](https://docs.blockvectra.com/en/api/json-rpc/#error-codes)). ### Chamar a Data API A Data API expõe dados de rede somente de leitura (blocos, transações, saldos, detentores, atividade em DEX e muito mais) como REST/JSON. Toda rota, exceto `GET https://api.blockvectra.com/v1/data/chains`, tem um identificador de rede como prefixo: `robinhood_mainnet` é o identificador da rede (o campo `chain` retornado por `/chains` e em `meta`) usado em todos os caminhos abaixo. `GET https://api.blockvectra.com/v1/data/chains` lista apenas redes públicas e retorna somente `{"data": [...]}` (sem `meta`, sem `next_cursor`). As requisições são medidas e cobradas em Compute Units (CU); apenas respostas 2xx bem-sucedidas são cobradas. Toda requisição exige a mesma API key usada no JSON-RPC — envie-a no cabeçalho `x-api-key`. Toda resposta bem-sucedida específica de uma rede usa o mesmo envelope: `data` (os dados), `next_cursor` (uma string opaca, presente apenas quando há outra página — caso contrário, a chave fica totalmente ausente, nunca `null`) e `meta` (`chain`, `chain_slug` (forma de `chain` em letras maiúsculas), `chain_external_id`, `as_of_block`, `safe_block`, `finalized_block`, `coverage`, `refreshed_at`; `refreshed_at` pode ser `null`, indicando que o horário de atualização dos dados é desconhecido e eles devem ser tratados como desatualizados — endpoints baseados em blocos sempre retornam um valor). Respostas de erro normalmente contêm `{"error":{"code","message"}}` — `409 not_indexed_yet` adiciona `indexed_through` (o bloco mais recente indexado). Uma rede desconhecida ou não pública retorna HTTP `404` com `error.code` `not_found` (sem cobrança; os nomes de rede devem ser slugs exatos em letras minúsculas); uma API key ausente, desconhecida ou desativada retorna HTTP `401` com `error.code` `missing_api_key` ou `invalid_api_key`. Requisições limitadas por taxa retornam HTTP `429` (`error.code` `rate_limited`, `data.reason: "key_rate_limit"`), e saldo esgotado retorna HTTP `402` (`error.code` `insufficient_balance`); ambos sem cobrança. Valores que podem ultrapassar 2^53 (saldos, quantidades de tokens) são strings decimais, nunca números JSON. **Consultar um bloco pelo número:** **cURL** ```bash curl -s "https://api.blockvectra.com/v1/data/robinhood_mainnet/blocks/72838701" \ -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` **TypeScript** ```ts const res = await fetch("https://api.blockvectra.com/v1/data/robinhood_mainnet/blocks/72838701", { headers: { "x-api-key": process.env.BLOCKVECTRA_API_KEY! }, }); const body = await res.json(); console.log(body); // Run with: npx tsx example.mts ``` **Python** ```python import os, requests res = requests.get( "https://api.blockvectra.com/v1/data/robinhood_mainnet/blocks/72838701", headers={"x-api-key": os.environ["BLOCKVECTRA_API_KEY"]}, ) print(res.json()) ``` ```json { "data": { "number": 72838701, "hash": "0x9f2c1e7a4b6d3f805e1c9a72b4d6f1e0a3c8b5d7e2f4a1c6b9d3e7f0a2c4b6d8", "parent_hash": "0x1a3c5e7f9b1d3f5a7c9e1b3d5f7a9c1e3b5d7f9a1c3e5b7d9f1a3c5e7b9d1f3a", "timestamp": "2026-09-26T05:41:07Z", "miner": "0x00000000000000000000000000000000000a4b05", "gas_limit": 32000000, "gas_used": 4821932, "base_fee_per_gas": "100000000", "state_root": "0x2b4d6f8a1c3e5b7d9f1a3c5e7b9d1f3a5c7e9b1d3f5a7c9e1b3d5f7a9c1e3b5d", "transactions_root": "0x3c5e7b9d1f3a5c7e9b1d3f5a7c9e1b3d5f7a9c1e3b5d7f9a1c3e5b7d9f1a3c5e", "receipts_root": "0x4d6f8a1c3e5b7d9f1a3c5e7b9d1f3a5c7e9b1d3f5a7c9e1b3d5f7a9c1e3b5d7f", "tx_count": 239, "size": 48213, "l1_block_number": null, "extra": {} }, "meta": { "chain": "robinhood_mainnet", "chain_slug": "ROBINHOOD_MAINNET", "chain_external_id": "eip155:4663", "as_of_block": 72838957, "safe_block": 72838800, "finalized_block": 72838701, "coverage": "full", "refreshed_at": "2026-09-27T02:15:03Z" } } ``` Um número acima do bloco mais recente indexado (`as_of_block`) retorna `409` (`error.code: "not_indexed_yet"`), com `indexed_through` informando o bloco mais recente indexado — os dados ainda não estão disponíveis, então tente novamente mais tarde. Um número de bloco anterior a todo o histórico coberto da rede (`coverage.from_block`) retorna `422` (`error.code: "no_coverage"`). Dentro da cobertura, um número igual ou inferior a `as_of_block` sem registro ativo (nunca indexado ou revertido por reorg) retorna `404` (`error.code: "not_found"`). **Verificar a atualização dos dados** (quanto cada conjunto de dados acompanhado está atrasado em relação ao bloco mais recente da rede — útil para uma página de status ou verificação antes de confiar em uma consulta): **cURL** ```bash curl -s "https://api.blockvectra.com/v1/data/robinhood_mainnet/status/freshness" \ -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` **TypeScript** ```ts const res = await fetch("https://api.blockvectra.com/v1/data/robinhood_mainnet/status/freshness", { headers: { "x-api-key": process.env.BLOCKVECTRA_API_KEY! }, }); const body = await res.json(); console.log(body); // Run with: npx tsx example.mts ``` **Python** ```python import os, requests res = requests.get( "https://api.blockvectra.com/v1/data/robinhood_mainnet/status/freshness", headers={"x-api-key": os.environ["BLOCKVECTRA_API_KEY"]}, ) print(res.json()) ``` ```json { "data": [ { "dataset": "blocks", "category": "raw", "max_block_number": 72838957, "max_day": null, "max_time": "2026-09-27T02:15:01Z", "seconds_behind": 0, "blocks_behind": null, "days_behind": null, "checked_at": "2026-09-27T02:15:07Z" } ], "meta": { "chain": "robinhood_mainnet", "chain_slug": "ROBINHOOD_MAINNET", "chain_external_id": "eip155:4663", "as_of_block": 72838957, "safe_block": 72838800, "finalized_block": 72838701, "coverage": "full", "refreshed_at": "2026-09-27T02:15:07Z" } } ``` *(Abreviado: a resposta tem uma linha por conjunto de dados; apenas a linha `blocks` é exibida. A linha `traces` também contém `coverage_from_block`, `coverage_to_block` e `coverage_complete`.)* Se os dados de atualização estiverem temporariamente indisponíveis para essa rede, a resposta será `503` (`error.code: "unavailable"`) em vez de um resultado parcial; a resposta inclui um cabeçalho `Retry-After` (segundos) — aguarde pelo menos esse tempo e tente novamente. **Listar os saldos ERC-20 de um endereço** (um snapshot filtrado para saldos diferentes de zero, ordenado por token): **cURL** ```bash curl -s "https://api.blockvectra.com/v1/data/robinhood_mainnet/addresses/0x1111111111111111111111111111111111111111/balances" \ -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` **TypeScript** ```ts const res = await fetch( "https://api.blockvectra.com/v1/data/robinhood_mainnet/addresses/0x1111111111111111111111111111111111111111/balances", { headers: { "x-api-key": process.env.BLOCKVECTRA_API_KEY! } }, ); const body = await res.json(); console.log(body); // Run with: npx tsx example.mts ``` **Python** ```python import os, requests res = requests.get( "https://api.blockvectra.com/v1/data/robinhood_mainnet/addresses/0x1111111111111111111111111111111111111111/balances", headers={"x-api-key": os.environ["BLOCKVECTRA_API_KEY"]}, ) print(res.json()) ``` ```json { "data": [ { "token": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "balance": "185371464119396", "symbol": "WETH", "decimals": 18 }, { "token": "0x2295f15bd4914ae9b4685f01d52f4e6f89bf8b03", "balance": "10000000000000000", "symbol": "WNVDA", "decimals": 18 } ], "meta": { "chain": "robinhood_mainnet", "chain_slug": "ROBINHOOD_MAINNET", "chain_external_id": "eip155:4663", "as_of_block": 72838957, "safe_block": 72838800, "finalized_block": 72838701, "coverage": "full", "refreshed_at": "2026-09-27T02:10:00Z" } } ``` Um endereço sem saldos diferentes de zero ainda retorna `200` com `data: []` — nunca `404`. Envie `?limit=` (padrão 50, máximo 500) e o `next_cursor` retornado para consultar as próximas páginas. A cobertura completa dos endpoints — blocos, transações, endereços, tokens, NFTs, DEX e ações tokenizadas — está em [Referência da API → Data API](https://docs.blockvectra.com/en/api/data/). ### Leitura adicional * [Referência da API → JSON-RPC](https://docs.blockvectra.com/en/api/json-rpc/) — métodos, pesos em CU e códigos de erro * [Referência completa de JSON-RPC](https://docs.blockvectra.com/en/api/json-rpc/reference/) — especificações completas, parâmetros e esquemas de retorno de todos os métodos compatíveis * [Referência da API → Data API](https://docs.blockvectra.com/en/api/data/) — endpoints REST para dados de rede * [Conjuntos de dados](https://docs.blockvectra.com/en/datasets/) — conjuntos de dados derivados nas redes compatíveis * [Guias](https://docs.blockvectra.com/en/guides/) — guias práticos para integração com APIs, gestão de CU e fluxos multichain * [Redes compatíveis](https://docs.blockvectra.com/en/chains/) — identificadores de rede e URLs de endpoints ## FAQ ### Quais redes têm suporte? 9 redes têm suporte: Arbitrum One, Base, BNB Smart Chain, Ethereum, Ethereum Sepolia, HyperEVM, Polygon, Robinhood Chain, Robinhood Chain Testnet. A lista segue GET /v1/chains e é atualizada quando novas redes são lançadas. Consulte a [página de status](https://blockvectra.com/pt-br/status/) para ver o status em tempo real. [Ver redes com suporte](https://blockvectra.com/pt-br/chains/) ### O WebSocket tem suporte? Chamar eth_subscribe via HTTP retorna -32601; nas redes onde ws for true em /v1/chains, eth_subscribe está disponível via WebSocket. Caso contrário, consulte eth_getLogs periodicamente. [Ver redes com suporte](https://blockvectra.com/pt-br/chains/) ### Posso consultar estados históricos e traces? Sim, mas varia por rede. A janela de estado histórico é o campo state_window_blocks de /v1/chains (null significa histórico completo); a disponibilidade de traces depende se methods.allow para essa rede inclui métodos debug_trace (como debug_traceTransaction); o intervalo máximo de blocos para uma só requisição eth_getLogs é max_logs_block_range. [Ver diretório de redes e parâmetros por rede](https://blockvectra.com/pt-br/chains/) ### Uma só chave de API pode ser usada em todas as redes? Sim. Uma só chave de API funciona para JSON-RPC em todas as redes com suporte e para a Data API nas redes que a oferecem; uma chave pertence à conta, não a uma rede específica. [Guia: uma chave, muitas redes](https://docs.blockvectra.com/en/guides/one-key-many-chains/)