# Inicio rápido

> Source: https://docs.blockvectra.com/es/quickstart/

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:

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

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](https://blockvectra.com/en/free/#public-rpc) para ver métodos públicos, rangos históricos y límites por IP.

## 2. Crear una API key

Acceda a la [consola](https://console.blockvectra.com/login/?next=%2Fkeys%2F), 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.

> **¿Aún no tiene una API key?**
>
> Si tiene una billetera Ethereum: siga la [guía de registro programático](https://docs.blockvectra.com/en/guides/programmatic-signup/) para registrarse y crear una API key con la firma de una billetera Ethereum, sin necesidad de navegador. Si no tiene una billetera: pídale al usuario que inicie sesión en [console.blockvectra.com](https://console.blockvectra.com/login/?next=%2Fkeys%2F), cree una API key y la configure en la variable de entorno `BLOCKVECTRA_API_KEY`. No le pida al usuario que pegue la API key en el chat.


## 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:

```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` es nuevamente una altura de bloque hexadecimal. Esta solicitud consume CU; consulte la [referencia JSON-RPC](https://docs.blockvectra.com/en/api/json-rpc/) para ver los pesos de los métodos y los códigos de error, y [Precios](https://blockvectra.com/en/pricing/) 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](#common-errors) 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](https://docs.blockvectra.com/en/guides/stocks/)
* [Recuperar logs históricos de HyperEVM en fragmentos](https://docs.blockvectra.com/en/guides/hyperevm-backfill/)
* [Recibir actividad de billeteras y transferencias de tokens con Webhooks](https://docs.blockvectra.com/en/guides/webhook-push/)

## Referencia

### API keys y saldo

Plantilla de inicio completa: [blockvectra/agent-quickstart](https://github.com/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.

> Cuando su saldo es insuficiente, el servidor devuelve HTTP 402 (código de error JSON-RPC `-32020`; Data API `error.code` `insufficient_balance`). Visite la [página de facturación](https://console.blockvectra.com/billing/) de la consola para comprobar su saldo y los métodos de recarga.


### Probar sin una API key

Puedes llamar al endpoint JSON-RPC público de inmediato sin crear una cuenta ni proporcionar una API key. El endpoint en el siguiente ejemplo tiene límite de tasa por IP (3 req/s, ráfaga de 20, máximo de 10 llamadas por lote). Las solicitudes que superan los límites devuelven HTTP 429 con motivo `public_rate_limit` o `public_pool_busy` (con encabezado `Retry-After`); los métodos no admitidos devuelven el error 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 cadena

- Arbitrum One: https://api.blockvectra.com/v1/arb_mainnet/public — Leer y transmitir transacciones firmadas (eth_sendRawTransaction)
- Base: https://api.blockvectra.com/v1/base_mainnet/public — Leer y transmitir transacciones firmadas (eth_sendRawTransaction)
- BNB Smart Chain: https://api.blockvectra.com/v1/bsc_mainnet/public — Leer y transmitir transacciones firmadas (eth_sendRawTransaction)
- Ethereum: https://api.blockvectra.com/v1/eth_mainnet/public — Leer y transmitir transacciones firmadas (eth_sendRawTransaction)
- Ethereum Sepolia: https://api.blockvectra.com/v1/eth_sepolia/public — Leer y transmitir transacciones firmadas (eth_sendRawTransaction)
- HyperEVM: https://api.blockvectra.com/v1/hyperevm_mainnet/public — Solo lectura
- Polygon: https://api.blockvectra.com/v1/polygon_mainnet/public — Leer y transmitir transacciones firmadas (eth_sendRawTransaction)
- Robinhood Chain: https://api.blockvectra.com/v1/robinhood_mainnet/public — Leer y transmitir transacciones firmadas (eth_sendRawTransaction)
- Robinhood Chain Testnet: https://api.blockvectra.com/v1/robinhood_testnet/public — Leer y transmitir transacciones firmadas (eth_sendRawTransaction)

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

```bash
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`:

```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 cadenas compatibles y políticas de métodos

```bash
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`:

```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": {}
    }
  ]
}
```

### 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](https://docs.blockvectra.com/en/chains/) para ver las cadenas disponibles y sus identificadores.

| Cadena | {chain} | Chain ID | Tracing | Endpoint público | WebSocket | Data API | Métodos con clave API | Notificaciones Webhook | Enviar transacciones | Enviar transacciones (endpoint público sin key) | Ventana de historial de estado | Rango máximo de bloques para eth_getLogs | Conjuntos de datos de Data API | Redes de prueba relacionadas | Guías relacionadas |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| [RPC y Data API de arb_mainnet](https://blockvectra.com/es/chains/arb_mainnet/) | arb_mainnet | 42161 | ✓ | `https://api.blockvectra.com/v1/arb_mainnet/public` | No compatible | Disponible | 43 | [Compatible · Confirmaciones 1–1 (predeterminado 1)](https://blockvectra.com/es/webhooks/), [Guía de notificaciones Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatible | Compatible | Estado histórico para los 6,000 bloques más recientes | 1,000 bloques | Bloques, Transacciones, Transacciones de direcciones, Transferencias, Metadatos de tokens, Frescura de datos | Desconocida | Desconocida |
| [RPC y Data API de base_mainnet](https://blockvectra.com/es/chains/base_mainnet/) | base_mainnet | 8453 | — | `https://api.blockvectra.com/v1/base_mainnet/public` | No compatible | Disponible | 39 | [Compatible · Confirmaciones 1–1 (predeterminado 1)](https://blockvectra.com/es/webhooks/), [Guía de notificaciones Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatible | Compatible | Estado histórico para los 10,000 bloques más recientes | 1,000 bloques | Bloques, Transacciones, Transacciones de direcciones, Transferencias, Metadatos de tokens, Frescura de datos | Desconocida | [Base](https://docs.blockvectra.com/en/guides/base/) |
| [RPC y Data API de bsc_mainnet](https://blockvectra.com/es/chains/bsc_mainnet/) | bsc_mainnet | 56 | — | `https://api.blockvectra.com/v1/bsc_mainnet/public` | No compatible | Disponible | 25 | [Compatible · Confirmaciones 1–1 (predeterminado 1)](https://blockvectra.com/es/webhooks/), [Guía de notificaciones Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatible | Compatible | Estado histórico para los 100 bloques más recientes | 1,000 bloques | Bloques, Transacciones, Transacciones de direcciones, Transferencias, Metadatos de tokens, Frescura de datos | Desconocida | Desconocida |
| [RPC y Data API de Ethereum](https://blockvectra.com/es/chains/eth_mainnet/) | eth_mainnet | 1 | ✓ | `https://api.blockvectra.com/v1/eth_mainnet/public` | No compatible | Disponible | 38 | [Compatible · Confirmaciones 1–1 (predeterminado 1)](https://blockvectra.com/es/webhooks/), [Guía de notificaciones Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatible | Compatible | Estado histórico para los 250,000 bloques más recientes | 1,000 bloques | Bloques, Transacciones, Transacciones de direcciones, Transferencias, Metadatos de tokens, Frescura de datos | Desconocida | Desconocida |
| [RPC y Data API de eth_sepolia](https://blockvectra.com/es/chains/eth_sepolia/) | eth_sepolia | 11155111 | — | `https://api.blockvectra.com/v1/eth_sepolia/public` | No compatible | Disponible | 29 | [Compatible · Confirmaciones 1–1 (predeterminado 1)](https://blockvectra.com/es/webhooks/), [Guía de notificaciones Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatible | Compatible | Desconocida | 1,000 bloques | Bloques, Transacciones, Transacciones de direcciones, Transferencias, Metadatos de tokens, Frescura de datos | Desconocida | Desconocida |
| [RPC y Data API de HyperEVM](https://blockvectra.com/es/chains/hyperevm_mainnet/) | hyperevm_mainnet | 999 | — | `https://api.blockvectra.com/v1/hyperevm_mainnet/public` | No compatible | Disponible | 24 | [Compatible · Confirmaciones 1–1 (predeterminado 1)](https://blockvectra.com/es/webhooks/), [Guía de notificaciones Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | No compatible | No compatible | Desconocida | 1,000 bloques | Bloques, Transacciones, Transacciones de direcciones, Transferencias, Metadatos de tokens, Saldos, Titulares, NFT, Frescura de datos | Desconocida | [HyperEVM backfill and polling](https://docs.blockvectra.com/en/guides/hyperevm-backfill/) |
| [RPC y Data API de polygon_mainnet](https://blockvectra.com/es/chains/polygon_mainnet/) | polygon_mainnet | 137 | ✓ | `https://api.blockvectra.com/v1/polygon_mainnet/public` | No compatible | Disponible | 43 | [Compatible · Confirmaciones 1–1 (predeterminado 1)](https://blockvectra.com/es/webhooks/), [Guía de notificaciones Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatible | Compatible | Estado histórico para los 126 bloques más recientes | 1,000 bloques | Bloques, Transacciones, Transacciones de direcciones, Transferencias, Metadatos de tokens, Frescura de datos | Desconocida | Desconocida |
| [RPC y Data API de Robinhood Chain](https://blockvectra.com/es/chains/robinhood_mainnet/) | robinhood_mainnet | 4663 | ✓ | `https://api.blockvectra.com/v1/robinhood_mainnet/public` | Compatible (newHeads, logs) | Disponible | 43 | [Compatible · Confirmaciones 1–1 (predeterminado 1)](https://blockvectra.com/es/webhooks/), [Guía de notificaciones Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatible | Compatible | Estado histórico para los 900 bloques más recientes | 1,000 bloques | Bloques, Transacciones, Transacciones de direcciones, Transferencias, Metadatos de tokens, Saldos, Titulares, NFT, Intercambios de DEX, Precios de DEX, Acciones tokenizadas, Trazas, Frescura de datos | Desconocida | [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/es/chains/robinhood_testnet/) | robinhood_testnet | 46630 | ✓ | `https://api.blockvectra.com/v1/robinhood_testnet/public` | Compatible (newHeads, logs) | Aún no disponible | 43 | [Compatible · Confirmaciones 1–1 (predeterminado 1)](https://blockvectra.com/es/webhooks/), [Guía de notificaciones Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) | Compatible | Compatible | Estado histórico para los 1,023 bloques más recientes | 1,000 bloques | No compatible | Desconocida | [Testnet faucet](https://docs.blockvectra.com/en/guides/robinhood-testnet-faucet/), [Robinhood Chain Testnet starter](https://docs.blockvectra.com/en/guides/robinhood-testnet-starter/) |

## Siguientes pasos con una clave 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/)

[Crear una suscripción Webhook](https://blockvectra.com/es/webhooks/) · [Crear una suscripción Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso y CU](https://console.blockvectra.com/usage/) · [Recargar](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/)

[Crear una suscripción Webhook](https://blockvectra.com/es/webhooks/) · [Crear una suscripción Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso y CU](https://console.blockvectra.com/usage/) · [Recargar](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/)

[Crear una suscripción Webhook](https://blockvectra.com/es/webhooks/) · [Crear una suscripción Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso y CU](https://console.blockvectra.com/usage/) · [Recargar](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/)

[Crear una suscripción Webhook](https://blockvectra.com/es/webhooks/) · [Crear una suscripción Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso y CU](https://console.blockvectra.com/usage/) · [Recargar](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/)

[Crear una suscripción Webhook](https://blockvectra.com/es/webhooks/) · [Crear una suscripción Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso y CU](https://console.blockvectra.com/usage/) · [Recargar](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/)

[Crear una suscripción Webhook](https://blockvectra.com/es/webhooks/) · [Crear una suscripción Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso y CU](https://console.blockvectra.com/usage/) · [Recargar](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/)

[Crear una suscripción Webhook](https://blockvectra.com/es/webhooks/) · [Crear una suscripción Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso y CU](https://console.blockvectra.com/usage/) · [Recargar](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/)

[Crear una suscripción Webhook](https://blockvectra.com/es/webhooks/) · [Crear una suscripción Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso y CU](https://console.blockvectra.com/usage/) · [Recargar](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/)

[Crear una suscripción Webhook](https://blockvectra.com/es/webhooks/) · [Crear una suscripción Webhook](https://docs.blockvectra.com/en/guides/webhook-push/) · [Uso y CU](https://console.blockvectra.com/usage/) · [Recargar](https://console.blockvectra.com/billing/)

**HyperEVM**
Los bloques de HyperEVM incluyen transacciones del sistema HyperCore (desde la dirección 0x2222…2222 o 0x20…, gasPrice 0).
El envío de transacciones aún no es compatible en esta cadena (`eth_sendRawTransaction` devuelve `-32601` `method_not_allowed`); los métodos de lectura funcionan con normalidad.

[Ver estado en tiempo real →](https://blockvectra.com/es/status/)

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](https://docs.blockvectra.com/en/chains/). 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

**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
```

Plantilla de inicio completa: [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<dyn std::error::Error>> {
    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 en un encabezado de solicitud

**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<dyn std::error::Error>> {
    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(())
}
```


> **Sin barra diagonal final**
>
> Al enviar la API key en un encabezado, llame a `https://api.blockvectra.com/v1/robinhood_mainnet` exactamente como se muestra: la URL termina con el nombre de la cadena, **sin** barra diagonal final. JSON-RPC solo se sirve en `/v1/{chain}` y `/v1/{chain}/{api_key}`. Una barra diagonal final (como `/v1/{chain}/`) o una solicitud sin el segmento de la cadena (como `/v1` o `/v1/`) devuelve `404` con un cuerpo vacío.


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

```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<dyn std::error::Error>> {
    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(())
}
```


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](#common-errors) 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](https://blockvectra.com/en/pricing/) 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](https://docs.blockvectra.com/en/api/json-rpc/) — esta página solo presenta el formato de una solicitud.

#### Errores comunes

| Lo que hizo                                                                                                                                                                                                                                                                                               | Lo que devuelve                                                                | Acción                                                                                                                                                                                                                                                                                                                                           |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Cadena desconocida o aún no pública                                                                                                                                                                                                                                                                       | HTTP `404` con cuerpo JSON `error.data.reason: "unknown_chain"`                | Verifique el nombre de la cadena en la URL                                                                                                                                                                                                                                                                                                       |
| Solicitud sin el segmento de la cadena (por ejemplo, `/v1` o `/v1/`)                                                                                                                                                                                                                                      | HTTP `404` con cuerpo vacío                                                    | Incluya el nombre de la cadena en la URL (`/v1/{chain}`)                                                                                                                                                                                                                                                                                         |
| API key ausente, desconocida o deshabilitada                                                                                                                                                                                                                                                              | HTTP `401`, código JSON-RPC `-32024` (`missing_api_key` o `invalid_api_key`)   | Use una API key válida y activa (las API keys nuevas o rotadas entran en vigor en todas las instancias en unos 5 segundos; durante ese intervalo pueden devolver 401 `invalid_api_key` o 503 `-32021` (con `Retry-After`) cuando no se puede confirmar el estado de facturación en el momento, por lo que espere un momento y vuelva a intentar) |
| Saldo cero o negativo                                                                                                                                                                                                                                                                                     | HTTP `402`, código JSON-RPC `-32020`                                           | Recargue su saldo o espere a la renovación gratuita                                                                                                                                                                                                                                                                                              |
| Solicitudes enviadas con demasiada rapidez (límite de tasa o sobrecarga temporal)                                                                                                                                                                                                                         | HTTP `429` (o `200`), código JSON-RPC `-32005`                                 | Reintente más tarde (respete `Retry-After` cuando esté presente)                                                                                                                                                                                                                                                                                 |
| Solicitud individual o lote supera la capacidad de ráfaga de la API key (`burst_cu`, predeterminado 1,600 CU; tasa predeterminada 400 CU/s), o el lote del plan gratuito supera llamadas/s (25 llamadas/s)                                                                                                                                                                                         | HTTP `429`, código JSON-RPC `-32022` (`request_exceeds_burst`)                 | Divida la solicitud en lotes más pequeños (nunca tendrá éxito tal como se envió)                                                                                                                                                                                                                                                                 |
| Nodo upstream no disponible temporalmente                                                                                                                                                                                                                                                                 | HTTP `200`, código JSON-RPC `-32603` (`upstream unavailable`), sin facturación | Reintente la solicitud                                                                                                                                                                                                                                                                                                                           |
| Estado histórico fuera de la ventana de estado de la cadena (consulte `state_window_blocks` en `GET /v1/chains`)                                                                                                                                                                                          | HTTP `200`, código JSON-RPC `-32011`, sin facturación                          | Consulte un bloque más reciente                                                                                                                                                                                                                                                                                                                  |
| Transacción o bloque no encontrado, o respuesta demasiado grande; en Ethereum, las consultas de bloques / recibos / logs fuera de la ventana reciente también devuelven -32000 "old data not available due to pruning" (sin facturación; consulte [Cadenas compatibles → Ethereum](https://docs.blockvectra.com/en/chains/#ethereum)) | HTTP `200`, código JSON-RPC `-32000`                                           | Modifique la solicitud (verifique el hash o número de bloque; los hashes de traza con formato incorrecto devuelven transacción no encontrada)                                                                                                                                                                                                    |
| Trazador no permitido o tiempo de espera de traza no permitido (llamadas `debug_trace`)                                                                                                                                                                                                                   | HTTP `200`, código JSON-RPC `-32602`, sin facturación                          | Use un trazador nativo permitido (`callTracer`, `flatCallTracer`, `prestateTracer`, `4byteTracer`, `noopTracer` u omítalo) y tiempo de espera ≤ 30s                                                                                                                                                                                              |
| Método no permitido por la lista de métodos de la cadena (consulte [Cadenas compatibles](https://docs.blockvectra.com/en/chains/))                                                                                                                                                                                                    | HTTP `200`, código JSON-RPC `-32601`, sin facturación                          | Llame únicamente a los métodos permitidos por la cadena                                                                                                                                                                                                                                                                                          |
| Cuerpo JSON con formato incorrecto                                                                                                                                                                                                                                                                        | HTTP `200`, código JSON-RPC `-32700`, sin facturación                          | Corrija la sintaxis JSON de la solicitud                                                                                                                                                                                                                                                                                                         |
| Más de 100 llamadas en un lote                                                                                                                                                                                                                                                                            | HTTP `200`, código JSON-RPC `-32600` (`batch too large`), sin facturación      | Divida el lote en un máximo de 100 llamadas                                                                                                                                                                                                                                                                                                      |

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](https://docs.blockvectra.com/en/api/json-rpc/#error-codes)).

### 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**

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

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

```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: 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**

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

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](https://docs.blockvectra.com/en/api/data/).

### Otras lecturas

* [Referencia de la API → JSON-RPC](https://docs.blockvectra.com/en/api/json-rpc/) — métodos, pesos en CU y códigos de error
* [Referencia completa de JSON-RPC](https://docs.blockvectra.com/en/api/json-rpc/reference/) — especificaciones completas, parámetros y esquemas de respuesta para todos los métodos compatibles
* [Referencia de la API → Data API](https://docs.blockvectra.com/en/api/data/) — puntos de enlace REST para datos de cadena
* [Conjuntos de datos](https://docs.blockvectra.com/en/datasets/) — conjuntos de datos derivados en las cadenas compatibles
* [Guías](https://docs.blockvectra.com/en/guides/) — guías prácticas para integración con API, gestión de CU y flujos de trabajo multicadena
* [Cadenas compatibles](https://docs.blockvectra.com/en/chains/) — identificadores de cadenas y URL de puntos de enlace

## FAQ

### ¿Qué cadenas están admitidas?

Se admiten 9 cadenas: Arbitrum One, Base, BNB Smart Chain, Ethereum, Ethereum Sepolia, HyperEVM, Polygon, Robinhood Chain, Robinhood Chain Testnet. La lista se basa en GET /v1/chains y se actualiza cuando se lanzan nuevas cadenas. Consulta la [página de estado](https://blockvectra.com/es/status/) para ver el estado en tiempo real. [Ver cadenas admitidas](https://blockvectra.com/es/chains/)

### ¿Se admite WebSocket?

Llamar a eth_subscribe a través de HTTP devuelve -32601; en las cadenas donde ws es true en /v1/chains, eth_subscribe está disponible a través de WebSocket. De lo contrario, sondea eth_getLogs. [Ver cadenas admitidas](https://blockvectra.com/es/chains/)

### ¿Puedo consultar estados históricos y trazas?

Sí, pero varía según la cadena. La ventana de estado histórico es el campo state_window_blocks de /v1/chains (null significa historial completo); la disponibilidad de trazas depende de si methods.allow para esa cadena incluye métodos debug_trace (como debug_traceTransaction); el rango máximo de bloques para una sola solicitud eth_getLogs es max_logs_block_range. [Ver el directorio de cadenas y los parámetros por cadena](https://blockvectra.com/es/chains/)

### ¿Se puede usar una sola clave de API en todas las cadenas?

Sí. Una sola clave de API funciona para JSON-RPC en todas las cadenas admitidas y para la Data API en las cadenas que la ofrecen; una clave pertenece a la cuenta, no a una cadena específica. [Guía: una clave, muchas cadenas](https://docs.blockvectra.com/en/guides/one-key-many-chains/)