Démarrage rapide

Les développeurs et les agents IA peuvent essayer le RPC public sans clé, puis créer une clé pour continuer.

1. Lire la hauteur de bloc sans clé

Appelez le point de terminaison JSON-RPC public pour la chaîne d'exemple robinhood_mainnet sans créer de compte ni fournir d'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":[]}'

Le champ id: 1 de la réponse correspond à cette requête ; result est une hauteur de bloc hexadécimale et peut changer entre deux appels. Si la réponse contient error, vérifiez son code et son motif. Consultez les points de terminaison RPC publics gratuits pour voir les méthodes publiques, les plages d'historique et les limites par IP.

2. Créer une API key

Rendez-vous sur la console, connectez-vous avec GitHub, Google ou un portefeuille Ethereum (votre compte est créé dès la première connexion), et créez une API key. Le secret n'est affiché qu'une seule fois : conservez-le en lieu sûr et définissez-le dans la variable d'environnement BLOCKVECTRA_API_KEY. Ne l'incluez pas dans le code navigateur côté client. Les nouveaux comptes reçoivent 30,000,000 CU à l'inscription — aucune carte bancaire requise.

3. Envoyer votre premier appel authentifié

Lisez la hauteur de bloc de la même chaîne à l'aide de l'en-tête x-api-key. L'URL se termine par le nom de la chaîne, sans barre oblique finale :

: "${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 est à nouveau une hauteur de bloc hexadécimale. Cette requête consomme des CU ; consultez la référence JSON-RPC pour les pondérations des méthodes et les codes d'erreur, ainsi que les Tarifs pour les prix actuels. Une nouvelle clé prend effet en environ 5 secondes ; si vous obtenez invalid_api_key, patientez un instant et réessayez. Consultez les Erreurs courantes ci-dessous pour les autres types d'échecs.

4. Poursuivre avec une tâche métier

• Consulter l'activité des actions tokenisées on-chain sur Robinhood Chain
• Rétro-remplir les logs HyperEVM par fragments
• Recevoir l'activité du portefeuille et les transferts de tokens avec des Webhooks

Référence

API keys et solde

Modèle de démarrage complet : blockvectra/agent-quickstart

Chaque clé commence par rgw_ suivi de 64 caractères hexadécimaux, par exemple rgw_1f2e... (tronqué). Gardez-la secrète — quiconque détient la clé peut dépenser votre solde.

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

# Ou en utilisant le modèle de repli de clé API (public par défaut si BLOCKVECTRA_API_KEY n'est pas défini) :
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":[]}'

Les deux points de terminaison de métadonnées publics suivants affichent l'état du service et la configuration de chaque chaîne ; ils ne nécessitent aucune API key et ne sont pas facturés.

Vérifier l'état de santé du service et des chaînes

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

Renvoie l'horodatage de la vérification checked_at, l'état opérationnel du service gateway.status, ainsi que la progression de synchronisation des nœuds de chaque chaîne prise en charge sync, la hauteur du bloc de tête et la latence 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
      }
    }
  ]
}

Interroger les chaînes prises en charge et les politiques de méthodes

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

Renvoie le chain_id de chaque chaîne prise en charge, les indicateurs de fonctionnalités pour JSON-RPC, Data API et WebSocket, les listes d'autorisation et de refus de méthodes (methods.allow et methods.deny), la limite de plage de blocs par requête de logs max_logs_block_range, et la fenêtre d'état historique 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": {}
    }
  ]
}

Choisir une chaîne

Chaque point de terminaison BlockVectra est spécifique à une chaîne : les requêtes JSON-RPC intègrent le nom de la chaîne {chain} dans le chemin d'accès de l'URL, et les requêtes Data API le préfixent au chemin de la route. Consultez les Chaînes prises en charge pour connaître les chaînes actuellement disponibles et leurs identifiants.

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'

Tous les exemples de cette page utilisent robinhood_mainnet.

Astuce : choisissez une chaîne qui prend en charge le service, la méthode et la fenêtre d'historique de l'exemple dans la matrice ci-dessus, puis remplacez robinhood_mainnet par son {chain}. La même API key fonctionne sur toutes les chaînes prises en charge.

Autres options d'authentification et exemples par langage

Les points de terminaison JSON-RPC sont ciblés sur une chaîne : POST /v1/{chain}/{api_key} avec la clé dans le chemin, ou POST /v1/{chain} avec la clé dans l'en-tête x-api-key. {chain} est le nom de chaîne que la Data API utilise également ; pour Robinhood Chain, il s'agit de robinhood_mainnet, donc le point de terminaison sur cette page est https://api.blockvectra.com/v1/robinhood_mainnet. L'appel de eth_subscribe via HTTP renvoie -32601 ; les abonnements WebSocket sont répertoriés par chaîne dans les Chaînes prises en charge. L'API transmet Access-Control-Allow-Origin: *, mais vous devez garder votre API key secrète et effectuer vos requêtes depuis un service back-end plutôt que depuis du code navigateur côté client.

Vous pouvez transmettre la clé de trois façons : dans le chemin de l'URL (POST /v1/{chain}/{api_key}, qui utilise uniquement la clé présente dans le chemin et ignore les deux en-têtes), dans l'en-tête x-api-key, ou dans un en-tête Authorization: Bearer <api_key>.

Clé dans le chemin de l'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":[]}'

Clé dans un en-tête de requête

: "${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 en-tête Authorization: Bearer <api_key> fonctionne également. Sur POST /v1/{chain}, un en-tête x-api-key non vide a la priorité sur Bearer, et Bearer n'est utilisé que lorsque x-api-key est absent ou vide. La forme utilisant le chemin ignore les deux en-têtes.

Appels groupés (batch)

Envoyez un tableau pour effectuer plusieurs appels en une seule requête (jusqu'à 100 par batch). Notez que chaque API key dispose d'un bucket de CU (recharge cu_per_sec, capacité burst_cu — les valeurs par défaut sont 400 CU/s et un burst de 1,600 CU ; affiché par clé dans le tableau Clés de la console) ; une requête unique — y compris un batch JSON-RPC complet — dont le coût total en CU dépasse la capacité de burst de la clé est rejetée avec -32022 request_exceeds_burst, même sous la limite de 100 appels par batch ; découpez-la en batches plus petits. Cet exemple lit le chain ID et le solde d'un compte en un seul aller-retour :

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

Les réponses reviennent sous la forme d'un tableau, dans le même ordre que les requêtes, associées par id.

Si le serveur rejette l'ensemble du batch — solde insuffisant, limitation de débit, dépassement de burst ou batch trop volumineux (voir les Erreurs courantes ci-dessous) — il renvoie un objet d'erreur JSON-RPC unique au lieu d'un tableau ; le mode batch: true de viem le signale alors sous la forme d'une erreur opaque UnknownRpcError, réessayez donc un appel unique pour identifier l'erreur réelle.

Comprendre la facturation des CU

Chaque appel facturé consomme des Compute Units (CU) : les appels légers comme eth_blockNumber ou eth_chainId coûtent le moins cher, les lectures courantes comme eth_getBlockByNumber coûtent un peu plus, les appels plus lourds comme eth_call ou eth_getLogs coûtent davantage, et les méthodes de trace d'exécution (telles que debug_traceTransaction) coûtent le plus cher. L'utilisation est facturée par compte et par période d'une heure, arrondie à l'unité de facturation inférieure entière (1 unité = 1,000 CU), le solde restant étant reporté sur la période suivante (ainsi, sur l'ensemble des périodes, le total facturé est floor(total CU / 1,000)) ; le règlement a lieu environ 15 minutes après la fin de la période. Par exemple : 508 CU reportées + 2557 CU consommées = 3065 CU, soit 3 unités de facturation débitées et 65 CU reportées sur la période suivante. Consultez les Tarifs pour connaître les prix actuels.

Le tableau complet des pondérations méthode par méthode et les codes d'erreur figurent dans la Référence de l'API → JSON-RPC — cette page traite uniquement du format d'une requête.

Erreurs courantes

Les rejets ci-dessus ne sont jamais facturés. Chaque appel accepté qui reçoit une réponse est facturé selon la pondération en CU publiée de la méthode ; le tableau des codes d'erreur énumère les cas qui ne sont pas facturés (voir la colonne Facturé dans les Codes d'erreur).

Appeler la Data API

La Data API expose les données de la chaîne en lecture seule (blocs, transactions, soldes, détenteurs, activité DEX, et plus encore) au format REST/JSON. Chaque route, à l'exception de GET https://api.blockvectra.com/v1/data/chains, est préfixée par un identifiant de chaîne : robinhood_mainnet est l'identifiant de chaîne (le champ chain renvoyé par /chains et dans meta) utilisé dans chaque chemin ci-dessous. GET https://api.blockvectra.com/v1/data/chains répertorie uniquement les chaînes publiques et renvoie seulement {"data": [...]} (pas de meta, pas de next_cursor). Les requêtes sont mesurées et facturées en Compute Units (CU) ; seules les réponses 2xx réussies sont facturées.

Chaque requête nécessite la même API key que pour le JSON-RPC — transmettez-la dans l'en-tête x-api-key. Chaque réponse réussie ciblée sur une chaîne utilise la même enveloppe : data (la charge utile), next_cursor (une chaîne opaque, présente uniquement lorsqu'il existe une page suivante — sinon la clé est totalement absente, jamais null), et meta (chain, chain_slug (forme en majuscules de chain), chain_external_id, as_of_block, safe_block, finalized_block, coverage, refreshed_at ; refreshed_at peut être null, ce qui signifie que l'heure de mise à jour des données est inconnue et qu'elles doivent être considérées comme obsolètes — les points de terminaison basés sur les blocs renvoient toujours une valeur). Les réponses d'erreur contiennent généralement {"error":{"code","message"}} — 409 not_indexed_yet ajoute indexed_through (le bloc indexé le plus élevé). Une chaîne inconnue ou non publique renvoie HTTP 404 avec error.code not_found (non facturé ; les noms de chaînes doivent être des slugs exacts en minuscules) ; une API key manquante, inconnue ou désactivée renvoie HTTP 401 avec error.code missing_api_key ou invalid_api_key. Les requêtes soumises à une limitation de débit renvoient HTTP 429 (error.code rate_limited, data.reason: "key_rate_limit"), et un solde épuisé renvoie HTTP 402 (error.code insufficient_balance) ; les deux ne sont pas facturés. Les valeurs pouvant dépasser 2^53 (soldes, montants de tokens) sont des chaînes décimales, jamais des nombres JSON.

Consulter un bloc par numéro :

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 numéro supérieur à la tête indexée (as_of_block) renvoie 409 (error.code: "not_indexed_yet") avec indexed_through indiquant le bloc indexé le plus élevé — les données ne sont pas encore disponibles, réessayez donc plus tard. Un numéro de bloc entièrement antérieur à l'historique couvert de la chaîne (coverage.from_block) renvoie 422 (error.code: "no_coverage"). Dans la zone de couverture, un numéro inférieur ou égal à as_of_block sans enregistrement actif (jamais indexé ou annulé lors d'une réorganisation) renvoie 404 (error.code: "not_found").

Vérifier la fraîcheur des données (dans quelle mesure chaque jeu de données suivi accuse un retard par rapport à la tête de la chaîne — utile pour une page de statut ou un contrôle préalable avant de faire confiance à une requête) :

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

(Abrégé : la réponse comporte une ligne par jeu de données ; seule la ligne blocks est affichée. La ligne traces comporte également coverage_from_block, coverage_to_block et coverage_complete.)

Si les données de fraîcheur sont temporairement indisponibles pour cette chaîne, cette requête renvoie 503 (error.code: "unavailable") au lieu d'un résultat partiel ; la réponse comprend un en-tête Retry-After (en secondes) — attendez au moins cette durée avant de réessayer.

Lister les soldes ERC-20 d'une adresse (un instantané filtré sur les soldes non nuls, ordonné par 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"
  }
}

Une adresse sans aucun solde non nul renvoie tout de même 200 avec data: [] — jamais 404. Transmettez ?limit= (50 par défaut, max 500) ainsi que le next_cursor renvoyé pour parcourir les pages suivantes.

La couverture complète des points de terminaison — blocs, transactions, adresses, tokens, NFT, DEX, actions tokenisées — est disponible dans la Référence de l'API → Data API.

Pour aller plus loin

• Référence de l'API → JSON-RPC — méthodes, pondérations en CU, codes d'erreur
• Référence JSON-RPC complète — spécifications complètes, paramètres et schémas de retour pour toutes les méthodes prises en charge
• Référence de l'API → Data API — points de terminaison REST pour les données de la chaîne
• Jeux de données — jeux de données dérivés sur les chaînes prises en charge
• Guides — guides pratiques pour l'intégration de l'API, la gestion des CU et les flux de travail multi-chaînes
• Chaînes prises en charge — identifiants de réseaux et URL des points de terminaison

FAQ