Início rápido

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:

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 para métodos públicos, intervalos históricos e limites por IP.

2. Criar uma API key

Acesse o console, 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.

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:

: "${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 para pesos dos métodos e códigos de erro e Preços 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 abaixo para outras falhas.

4. Continuar com uma tarefa de negócio

• Consultar a atividade de ações tokenizadas on-chain na Robinhood Chain
• Recuperar logs históricos da HyperEVM em partes
• Receber atividade de carteiras e transferências de tokens com Webhooks

Referência

API keys e saldo

Template inicial completo: 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.

# 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":[]}'

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

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:

{
  "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

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:

{
  "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 para as redes atualmente disponíveis e seus identificadores.

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\"}]}"

curl -fsS 'https://api.blockvectra.com/v1/data/arb_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"

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\"}]}"

curl -fsS 'https://api.blockvectra.com/v1/data/base_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"

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\"}]}"

curl -fsS 'https://api.blockvectra.com/v1/data/bsc_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"

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\"}]}"

curl -fsS 'https://api.blockvectra.com/v1/data/eth_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"

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\"}]}"

curl -fsS 'https://api.blockvectra.com/v1/data/eth_sepolia/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"

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\"}]}"

curl -fsS 'https://api.blockvectra.com/v1/data/hyperevm_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"

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\"}]}"

curl -fsS 'https://api.blockvectra.com/v1/data/polygon_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"

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\"}]}"

curl -fsS 'https://api.blockvectra.com/v1/data/robinhood_mainnet/status/freshness' -H "x-api-key: $BLOCKVECTRA_API_KEY"

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'

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\"}]}"

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'

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. 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>.

API key no caminho da URL

: "${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":[]}'

API key em um cabeçalho de requisição

: "${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":[]}'

Um cabeçalho Authorization: Bearer <api_key> 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 -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"]}
  ]'

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 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 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 — esta página apresenta apenas o formato de uma requisição.

Erros comuns

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).

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 -s "https://api.blockvectra.com/v1/data/robinhood_mainnet/blocks/72838701" \
  -H "x-api-key: $BLOCKVECTRA_API_KEY"

{
  "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 -s "https://api.blockvectra.com/v1/data/robinhood_mainnet/status/freshness" \
  -H "x-api-key: $BLOCKVECTRA_API_KEY"

{
  "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 -s "https://api.blockvectra.com/v1/data/robinhood_mainnet/addresses/0x1111111111111111111111111111111111111111/balances" \
  -H "x-api-key: $BLOCKVECTRA_API_KEY"

{
  "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.

Leitura adicional

• Referência da API → JSON-RPC — métodos, pesos em CU e códigos de erro
• Referência completa de JSON-RPC — especificações completas, parâmetros e esquemas de retorno de todos os métodos compatíveis
• Referência da API → Data API — endpoints REST para dados de rede
• Conjuntos de dados — conjuntos de dados derivados nas redes compatíveis
• Guias — guias práticos para integração com APIs, gestão de CU e fluxos multichain
• Redes compatíveis — identificadores de rede e URLs de endpoints

FAQ