Inicio rápido

Los desarrolladores y agentes de IA pueden probar el RPC público sin una API key y, luego, crear una API key para continuar.

1. Consultar la altura de bloque sin API key

Llame al punto de enlace JSON-RPC público de la cadena de ejemplo robinhood_mainnet sin crear una cuenta ni proporcionar una 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":[]}'

El id: 1 de la respuesta coincide con esta solicitud; result es una altura de bloque hexadecimal y puede cambiar entre llamadas. Si la respuesta contiene error, verifique su código y motivo. Consulte los puntos de enlace RPC públicos gratuitos para ver métodos públicos, rangos históricos y límites por IP.

2. Crear una API key

Acceda a la consola, inicie sesión con GitHub, Google o una billetera Ethereum (su cuenta se crea en el primer inicio de sesión) y cree una API key. El secreto se muestra solo una vez: guárdelo de forma segura y configúrelo en la variable de entorno BLOCKVECTRA_API_KEY. No lo incluya en código ejecutado en el navegador del cliente. Las cuentas nuevas reciben 30,000,000 CU al registrarse — sin tarjeta de crédito.

3. Enviar tu primera llamada autenticada

Consulte la altura de bloque de la misma cadena con el encabezado x-api-key. La URL termina con el nombre de la cadena, sin barra diagonal 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 es nuevamente una altura de bloque hexadecimal. Esta solicitud consume CU; consulte la referencia JSON-RPC para ver los pesos de los métodos y los códigos de error, y Precios para conocer los precios actuales. Una nueva API key entra en vigor en unos 5 segundos; si recibe invalid_api_key, espere un momento y reintente. Consulte Errores comunes a continuación para ver otros fallos.

4. Continuar con una tarea de negocio

• Consultar la actividad de acciones tokenizadas on-chain en Robinhood Chain
• Recuperar logs históricos de HyperEVM en fragmentos
• Recibir actividad de billeteras y transferencias de tokens con Webhooks

Referencia

API keys y saldo

Plantilla de inicio completa: blockvectra/agent-quickstart

Toda API key tiene el prefijo rgw_ seguido de 64 caracteres hexadecimales, por ejemplo rgw_1f2e... (abreviado). Manténgala en secreto — cualquier persona con la API key puede consumir su 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":[]}'

Los dos puntos de enlace públicos de metadatos a continuación muestran el estado del servicio y la configuración de cada cadena; no requieren API key y no se facturan.

Verificar el estado del servicio y de las cadenas

curl https://api.blockvectra.com/v1/status

Devuelve la marca temporal de verificación checked_at, el estado operativo del servicio gateway.status y, para cada cadena compatible, el progreso de sincronización del nodo sync, la altura del bloque más reciente y la latencia 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 cadenas compatibles y políticas de métodos

curl https://api.blockvectra.com/v1/chains

Devuelve el chain_id de cada cadena compatible, los indicadores de capacidad de JSON-RPC, Data API y WebSocket, las políticas de métodos permitidos y denegados (methods.allow y methods.deny), el límite de rango de bloques por consulta de logs max_logs_block_range y la ventana 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": {}
    }
  ]
}

Elegir una cadena

Cada punto de enlace de BlockVectra corresponde a una cadena: las solicitudes JSON-RPC incluyen el nombre de la cadena {chain} en la ruta de la URL, y las solicitudes de la Data API lo usan como prefijo de la ruta. Consulte Cadenas compatibles para ver las cadenas disponibles y sus 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 los ejemplos de esta página usan robinhood_mainnet.

Consejo: elija en la matriz anterior una cadena que admita el servicio, el método y la ventana histórica del ejemplo; después sustituya robinhood_mainnet por su {chain}. La misma API key funciona en todas las cadenas compatibles.

Otras opciones de autenticación y ejemplos por lenguaje

Los puntos de enlace JSON-RPC corresponden a una cadena: POST /v1/{chain}/{api_key} con la API key en la ruta, o POST /v1/{chain} con la API key en el encabezado x-api-key. {chain} es el nombre de cadena que también utiliza la Data API; para Robinhood Chain es robinhood_mainnet, por lo que el punto de enlace de esta página es https://api.blockvectra.com/v1/robinhood_mainnet. Llamar a eth_subscribe mediante HTTP devuelve -32601; las suscripciones WebSocket se enumeran por cadena en Cadenas compatibles. La API envía Access-Control-Allow-Origin: *, pero debe mantener la API key en secreto y realizar las solicitudes desde un servicio backend en lugar de código ejecutado en el navegador del cliente.

Puede enviar la API key de tres formas: en la ruta de la URL (POST /v1/{chain}/{api_key}, que usa únicamente la API key de la ruta e ignora ambos encabezados), en el encabezado x-api-key o en un encabezado Authorization: Bearer <api_key>.

API key en la ruta de la 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 en un encabezado de solicitud

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

Un encabezado Authorization: Bearer <api_key> también funciona. En POST /v1/{chain}, un x-api-key no vacío tiene prioridad sobre Bearer, y Bearer se usa únicamente cuando x-api-key está ausente o vacío. La forma con API key en la ruta ignora ambos encabezados.

Llamadas por lotes

Envíe un array para realizar múltiples llamadas en una sola solicitud (hasta 100 por lote). Cada API key tiene un depósito de CU (reposición cu_per_sec, capacidad burst_cu — los valores predeterminados son 400 CU/s y ráfaga de 1,600 CU; mostrado por API key en la tabla Keys de la consola); una única solicitud —incluido un lote JSON-RPC completo— cuyo total de CU supere la capacidad de ráfaga de la API key se rechaza con -32022 request_exceeds_burst, incluso si está por debajo del límite de 100 llamadas por lote; divídala en lotes más pequeños. Este ejemplo consulta el Chain ID y el saldo de una cuenta en un solo viaje de ida y vuelta:

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

Las respuestas llegan en forma de array, en el mismo orden que las solicitudes, asociadas mediante el id.

Si el servidor rechaza el lote completo —por saldo insuficiente, límite de tasa, capacidad de ráfaga o lote demasiado grande (consulte Errores comunes a continuación)— devuelve un único objeto de error JSON-RPC en lugar de un array; el modo batch: true de viem muestra esto como un UnknownRpcError sin detalles, por lo que reintente una llamada individual para ver el error real.

Entender la facturación de CU

Toda llamada facturada consume Compute Units (CU): las llamadas ligeras como eth_blockNumber o eth_chainId tienen el menor costo, las lecturas habituales como eth_getBlockByNumber cuestan un poco más, las llamadas más complejas como eth_call o eth_getLogs cuestan más, y los métodos de traza de ejecución (como debug_traceTransaction) tienen el mayor costo. El uso se factura por cuenta por periodo de una hora, redondeado hacia abajo a unidades enteras de facturación (1 unidad = 1,000 CU), acumulándose el resto para el siguiente periodo (de modo que a través de los periodos el total cobrado es floor(total CU / 1,000)); la liquidación se ejecuta aprox. 15 minutos después de finalizar el periodo. Por ejemplo: 508 CU acumuladas + 2557 CU consumidas = 3065 CU, resultando en 3 unidades de facturación cobradas y 65 CU acumuladas para el siguiente periodo. Consulte Precios para conocer los precios actuales.

La tabla completa de pesos por método y los códigos de error se encuentran en Referencia de la API → JSON-RPC — esta página solo presenta el formato de una solicitud.

Errores comunes

Los rechazos anteriores nunca se facturan. Toda llamada aceptada que reciba una respuesta se factura según el peso público de CU del método; la tabla de códigos de error detalla los casos sin facturación (consulte la columna de facturación en Códigos de error).

Llamar a la Data API

La Data API expone datos de cadena de solo lectura (bloques, transacciones, saldos, titulares, actividad en DEX y más) como REST/JSON. Toda ruta, excepto GET https://api.blockvectra.com/v1/data/chains, tiene un identificador de cadena como prefijo: robinhood_mainnet es el identificador de la cadena (el campo chain devuelto por /chains y en meta) utilizado en todas las rutas siguientes. GET https://api.blockvectra.com/v1/data/chains enumera únicamente cadenas públicas y devuelve solo {"data": [...]} (sin meta, sin next_cursor). Las solicitudes se miden y facturan en Compute Units (CU); únicamente las respuestas 2xx exitosas se facturan.

Toda solicitud requiere la misma API key utilizada en JSON-RPC — envíela en el encabezado x-api-key. Toda respuesta exitosa específica de una cadena utiliza la misma estructura: data (los datos), next_cursor (una cadena opaca, presente únicamente cuando hay otra página — de lo contrario, la clave no está presente, nunca null) y meta (chain, chain_slug (versión en mayúsculas de chain), chain_external_id, as_of_block, safe_block, finalized_block, coverage, refreshed_at; refreshed_at puede ser null, lo que indica que se desconoce el momento de actualización de los datos y deben tratarse como desactualizados — los puntos de enlace basados en bloques siempre devuelven un valor). Las respuestas de error normalmente contienen {"error":{"code","message"}} — 409 not_indexed_yet añade indexed_through (el bloque más reciente indexado). Una cadena desconocida o no pública devuelve HTTP 404 con error.code not_found (sin facturación; los nombres de cadena deben ser los slugs exactos en minúsculas); una API key ausente, desconocida o deshabilitada devuelve HTTP 401 con error.code missing_api_key o invalid_api_key. Las solicitudes limitadas por tasa devuelven HTTP 429 (error.code rate_limited, data.reason: "key_rate_limit"), y el saldo agotado devuelve HTTP 402 (error.code insufficient_balance); ambos sin facturación. Los valores que pueden superar 2^53 (saldos, cantidades de tokens) son cadenas decimales, nunca números JSON.

Consultar un bloque por 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"
  }
}

Un número por encima del bloque más reciente indexado (as_of_block) devuelve 409 (error.code: "not_indexed_yet"), con indexed_through indicando el bloque más reciente indexado — los datos aún no están disponibles, por lo que reintente más tarde. Un número de bloque anterior a todo el historial cubierto de la cadena (coverage.from_block) devuelve 422 (error.code: "no_coverage"). Dentro de la cobertura, un número igual o inferior a as_of_block sin registro activo (nunca indexado o revertido por reorg) devuelve 404 (error.code: "not_found").

Verificar la frescura de los datos (cuánto retraso lleva cada conjunto de datos supervisado respecto al bloque más reciente de la cadena — útil para una página de estado o comprobación antes de confiar en una 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: la respuesta contiene una fila por conjunto de datos; solo se muestra la fila blocks. La fila traces también contiene coverage_from_block, coverage_to_block y coverage_complete.)

Si los datos de actualización están temporalmente no disponibles para esa cadena, la respuesta será 503 (error.code: "unavailable") en lugar de un resultado parcial; la respuesta incluye un encabezado Retry-After (segundos) — espere al menos ese tiempo y reintente.

Listar los saldos ERC-20 de una dirección (una instantánea filtrada para saldos distintos de cero, ordenada 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"
  }
}

Una dirección sin saldos distintos de cero devuelve 200 con data: [] — nunca 404. Envíe ?limit= (por defecto 50, máximo 500) y el next_cursor devuelto para paginar las páginas siguientes.

La cobertura completa de los puntos de enlace —bloques, transacciones, direcciones, tokens, NFT, DEX y acciones tokenizadas— se encuentra en Referencia de la API → Data API.

Otras lecturas

• Referencia de la API → JSON-RPC — métodos, pesos en CU y códigos de error
• Referencia completa de JSON-RPC — especificaciones completas, parámetros y esquemas de respuesta para todos los métodos compatibles
• Referencia de la API → Data API — puntos de enlace REST para datos de cadena
• Conjuntos de datos — conjuntos de datos derivados en las cadenas compatibles
• Guías — guías prácticas para integración con API, gestión de CU y flujos de trabajo multicadena
• Cadenas compatibles — identificadores de cadenas y URL de puntos de enlace

FAQ