# Démarrage rapide

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

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 :

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

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](https://blockvectra.com/fr/free/#public-rpc) 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](https://console.blockvectra.com/login/?next=%2Fkeys%2F), 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.

> **Vous n'avez pas encore d'API key ?**
>
> Si vous possédez un portefeuille Ethereum : suivez le [guide d'inscription programmatique](https://docs.blockvectra.com/fr/guides/programmatic-signup/) pour vous inscrire et créer une API key à l'aide d'une signature de portefeuille Ethereum, sans navigateur. Si vous ne possédez pas de portefeuille : demandez à l'utilisateur de se connecter sur [console.blockvectra.com](https://console.blockvectra.com/login/?next=%2Fkeys%2F), de créer une clé et de la définir comme variable d'environnement `BLOCKVECTRA_API_KEY`. Ne demandez pas à l'utilisateur de coller la clé dans le chat.


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

```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` est à nouveau une hauteur de bloc hexadécimale. Cette requête consomme des CU ; consultez la [référence JSON-RPC](https://docs.blockvectra.com/fr/api/json-rpc/) pour les pondérations des méthodes et les codes d'erreur, ainsi que les [Tarifs](https://blockvectra.com/fr/pricing/) 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](#common-errors) 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](https://docs.blockvectra.com/fr/guides/stocks/)
* [Rétro-remplir les logs HyperEVM par fragments](https://docs.blockvectra.com/fr/guides/hyperevm-backfill/)
* [Recevoir l'activité du portefeuille et les transferts de tokens avec des Webhooks](https://docs.blockvectra.com/fr/guides/webhook-push/)

## Référence

### API keys et solde

Modèle de démarrage complet : [blockvectra/agent-quickstart](https://github.com/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.

> Lorsque votre solde est insuffisant, le serveur renvoie HTTP 402 (code d'erreur JSON-RPC `-32020` ; `error.code` de la Data API `insufficient_balance`). Rendez-vous sur la [page Facturation](https://console.blockvectra.com/billing/) de la console pour consulter votre solde et les méthodes de recharge.


### Essayer sans clé

Vous pouvez appeler immédiatement l'endpoint JSON-RPC public sans créer de compte ni fournir de clé API. L'endpoint dans l'exemple ci-dessous est limité en débit par IP (3 req/s, burst 20, taille de lot max 10). Les requêtes qui dépassent les limites de débit renvoient HTTP 429 avec la raison `public_rate_limit` ou `public_pool_busy` (avec un en-tête `Retry-After`) ; les méthodes non prises en charge renvoient l'erreur JSON-RPC `-32601` (`method_not_public`).

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

#### Endpoints publics par chaîne

- Arbitrum One: https://api.blockvectra.com/v1/arb_mainnet/public — Lecture et diffusion des transactions signées (eth_sendRawTransaction)
- Base: https://api.blockvectra.com/v1/base_mainnet/public — Lecture et diffusion des transactions signées (eth_sendRawTransaction)
- BNB Smart Chain: https://api.blockvectra.com/v1/bsc_mainnet/public — Lecture et diffusion des transactions signées (eth_sendRawTransaction)
- Ethereum: https://api.blockvectra.com/v1/eth_mainnet/public — Lecture et diffusion des transactions signées (eth_sendRawTransaction)
- Ethereum Sepolia: https://api.blockvectra.com/v1/eth_sepolia/public — Lecture et diffusion des transactions signées (eth_sendRawTransaction)
- HyperEVM: https://api.blockvectra.com/v1/hyperevm_mainnet/public — Lecture seule
- Polygon: https://api.blockvectra.com/v1/polygon_mainnet/public — Lecture et diffusion des transactions signées (eth_sendRawTransaction)
- Robinhood Chain: https://api.blockvectra.com/v1/robinhood_mainnet/public — Lecture et diffusion des transactions signées (eth_sendRawTransaction)
- Robinhood Chain Testnet: https://api.blockvectra.com/v1/robinhood_testnet/public — Lecture et diffusion des transactions signées (eth_sendRawTransaction)

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

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

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

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

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

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

### 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](https://docs.blockvectra.com/fr/chains/) pour connaître les chaînes actuellement disponibles et leurs identifiants.

| Chaîne | {chain} | Chain ID | Tracing | Endpoint public | WebSocket | Data API | Méthodes avec une clé API | Notifications Webhook | Envoyer des transactions | Envoyer des transactions (endpoint public sans key) | Fenêtre d'historique d'état | Plage maximale de blocs pour eth_getLogs | Jeux de données Data API | Réseaux de test associés | Guides associés |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| [RPC et Data API arb_mainnet](https://blockvectra.com/fr/chains/arb_mainnet/) | arb_mainnet | 42161 | ✓ | `https://api.blockvectra.com/v1/arb_mainnet/public` | Non pris en charge | Ouvert | 43 | [Pris en charge · Confirmations 1–1 (par défaut 1)](https://blockvectra.com/fr/webhooks/), [Guide des notifications Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) | Pris en charge | Pris en charge | État historique pour les 6,000 blocs les plus récents | 1,000 blocs | Blocs, Transactions, Transactions d'adresses, Transferts, Métadonnées de jetons, Fraîcheur des données | Inconnu | Inconnu |
| [RPC et Data API base_mainnet](https://blockvectra.com/fr/chains/base_mainnet/) | base_mainnet | 8453 | — | `https://api.blockvectra.com/v1/base_mainnet/public` | Non pris en charge | Ouvert | 39 | [Pris en charge · Confirmations 1–1 (par défaut 1)](https://blockvectra.com/fr/webhooks/), [Guide des notifications Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) | Pris en charge | Pris en charge | État historique pour les 10,000 blocs les plus récents | 1,000 blocs | Blocs, Transactions, Transactions d'adresses, Transferts, Métadonnées de jetons, Fraîcheur des données | Inconnu | [Base](https://docs.blockvectra.com/fr/guides/base/) |
| [RPC et Data API bsc_mainnet](https://blockvectra.com/fr/chains/bsc_mainnet/) | bsc_mainnet | 56 | — | `https://api.blockvectra.com/v1/bsc_mainnet/public` | Non pris en charge | Ouvert | 25 | [Pris en charge · Confirmations 1–1 (par défaut 1)](https://blockvectra.com/fr/webhooks/), [Guide des notifications Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) | Pris en charge | Pris en charge | État historique pour les 100 blocs les plus récents | 1,000 blocs | Blocs, Transactions, Transactions d'adresses, Transferts, Métadonnées de jetons, Fraîcheur des données | Inconnu | Inconnu |
| [RPC et Data API Ethereum](https://blockvectra.com/fr/chains/eth_mainnet/) | eth_mainnet | 1 | ✓ | `https://api.blockvectra.com/v1/eth_mainnet/public` | Non pris en charge | Ouvert | 38 | [Pris en charge · Confirmations 1–1 (par défaut 1)](https://blockvectra.com/fr/webhooks/), [Guide des notifications Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) | Pris en charge | Pris en charge | État historique pour les 250,000 blocs les plus récents | 1,000 blocs | Blocs, Transactions, Transactions d'adresses, Transferts, Métadonnées de jetons, Fraîcheur des données | Inconnu | Inconnu |
| [RPC et Data API eth_sepolia](https://blockvectra.com/fr/chains/eth_sepolia/) | eth_sepolia | 11155111 | — | `https://api.blockvectra.com/v1/eth_sepolia/public` | Non pris en charge | Ouvert | 29 | [Pris en charge · Confirmations 1–1 (par défaut 1)](https://blockvectra.com/fr/webhooks/), [Guide des notifications Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) | Pris en charge | Pris en charge | Inconnu | 1,000 blocs | Blocs, Transactions, Transactions d'adresses, Transferts, Métadonnées de jetons, Fraîcheur des données | Inconnu | Inconnu |
| [RPC et Data API HyperEVM](https://blockvectra.com/fr/chains/hyperevm_mainnet/) | hyperevm_mainnet | 999 | — | `https://api.blockvectra.com/v1/hyperevm_mainnet/public` | Non pris en charge | Ouvert | 24 | [Pris en charge · Confirmations 1–1 (par défaut 1)](https://blockvectra.com/fr/webhooks/), [Guide des notifications Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) | Non pris en charge | Non pris en charge | Inconnu | 1,000 blocs | Blocs, Transactions, Transactions d'adresses, Transferts, Métadonnées de jetons, Soldes, Détenteurs, NFT, Fraîcheur des données | Inconnu | [HyperEVM backfill and polling](https://docs.blockvectra.com/fr/guides/hyperevm-backfill/) |
| [RPC et Data API polygon_mainnet](https://blockvectra.com/fr/chains/polygon_mainnet/) | polygon_mainnet | 137 | ✓ | `https://api.blockvectra.com/v1/polygon_mainnet/public` | Non pris en charge | Ouvert | 43 | [Pris en charge · Confirmations 1–1 (par défaut 1)](https://blockvectra.com/fr/webhooks/), [Guide des notifications Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) | Pris en charge | Pris en charge | État historique pour les 126 blocs les plus récents | 1,000 blocs | Blocs, Transactions, Transactions d'adresses, Transferts, Métadonnées de jetons, Fraîcheur des données | Inconnu | Inconnu |
| [RPC et Data API Robinhood Chain](https://blockvectra.com/fr/chains/robinhood_mainnet/) | robinhood_mainnet | 4663 | ✓ | `https://api.blockvectra.com/v1/robinhood_mainnet/public` | Pris en charge (newHeads, logs) | Ouvert | 43 | [Pris en charge · Confirmations 1–1 (par défaut 1)](https://blockvectra.com/fr/webhooks/), [Guide des notifications Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) | Pris en charge | Pris en charge | État historique pour les 900 blocs les plus récents | 1,000 blocs | Blocs, Transactions, Transactions d'adresses, Transferts, Métadonnées de jetons, Soldes, Détenteurs, NFT, Swaps DEX, Prix DEX, Actions tokenisées, Traces, Fraîcheur des données | Inconnu | [Robinhood Chain](https://docs.blockvectra.com/fr/guides/robinhood-chain/), [Stock token multiplier](https://docs.blockvectra.com/fr/guides/stock-token-multiplier/), [Tokenized stocks](https://docs.blockvectra.com/fr/guides/stocks/) |
| [RPC robinhood_testnet](https://blockvectra.com/fr/chains/robinhood_testnet/) | robinhood_testnet | 46630 | ✓ | `https://api.blockvectra.com/v1/robinhood_testnet/public` | Pris en charge (newHeads, logs) | Pas encore disponible | 43 | [Pris en charge · Confirmations 1–1 (par défaut 1)](https://blockvectra.com/fr/webhooks/), [Guide des notifications Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) | Pris en charge | Pris en charge | État historique pour les 1,023 blocs les plus récents | 1,000 blocs | Non pris en charge | Inconnu | [Testnet faucet](https://docs.blockvectra.com/fr/guides/robinhood-testnet-faucet/), [Robinhood Chain Testnet starter](https://docs.blockvectra.com/fr/guides/robinhood-testnet-starter/) |

## Étapes suivantes avec une clé 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/fr/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/fr/api/data/)

[Créer un abonnement Webhook](https://blockvectra.com/fr/webhooks/) · [Créer un abonnement Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) · [Utilisation et CU](https://console.blockvectra.com/usage/) · [Recharger](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/fr/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/fr/api/data/)

[Créer un abonnement Webhook](https://blockvectra.com/fr/webhooks/) · [Créer un abonnement Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) · [Utilisation et CU](https://console.blockvectra.com/usage/) · [Recharger](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/fr/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/fr/api/data/)

[Créer un abonnement Webhook](https://blockvectra.com/fr/webhooks/) · [Créer un abonnement Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) · [Utilisation et CU](https://console.blockvectra.com/usage/) · [Recharger](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/fr/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/fr/api/data/)

[Créer un abonnement Webhook](https://blockvectra.com/fr/webhooks/) · [Créer un abonnement Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) · [Utilisation et CU](https://console.blockvectra.com/usage/) · [Recharger](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/fr/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/fr/api/data/)

[Créer un abonnement Webhook](https://blockvectra.com/fr/webhooks/) · [Créer un abonnement Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) · [Utilisation et CU](https://console.blockvectra.com/usage/) · [Recharger](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/fr/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/fr/api/data/)

[Créer un abonnement Webhook](https://blockvectra.com/fr/webhooks/) · [Créer un abonnement Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) · [Utilisation et CU](https://console.blockvectra.com/usage/) · [Recharger](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/fr/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/fr/api/data/)

[Créer un abonnement Webhook](https://blockvectra.com/fr/webhooks/) · [Créer un abonnement Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) · [Utilisation et CU](https://console.blockvectra.com/usage/) · [Recharger](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/fr/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/fr/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/fr/guides/websocket-subscriptions/)

[Créer un abonnement Webhook](https://blockvectra.com/fr/webhooks/) · [Créer un abonnement Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) · [Utilisation et CU](https://console.blockvectra.com/usage/) · [Recharger](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/fr/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/fr/guides/websocket-subscriptions/)

[Créer un abonnement Webhook](https://blockvectra.com/fr/webhooks/) · [Créer un abonnement Webhook](https://docs.blockvectra.com/fr/guides/webhook-push/) · [Utilisation et CU](https://console.blockvectra.com/usage/) · [Recharger](https://console.blockvectra.com/billing/)

**HyperEVM**
Les blocs HyperEVM incluent des transactions système HyperCore (provenant de l'adresse 0x2222…2222 ou 0x20…, gasPrice 0).
L'envoi de transactions n'est pas encore pris en charge sur cette chaîne (`eth_sendRawTransaction` renvoie `-32601` `method_not_allowed`) ; les méthodes de lecture fonctionnent normalement.

[Voir l'état en direct →](https://blockvectra.com/fr/status/)

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

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

Modèle de démarrage complet : [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(())
}
```


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

**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(())
}
```


> **Pas de barre oblique finale**
>
> Lorsque vous transmettez la clé dans un en-tête, appelez `https://api.blockvectra.com/v1/robinhood_mainnet` exactement comme indiqué : l'URL se termine
>   par le nom de la chaîne, **sans** barre oblique finale. Le JSON-RPC est servi uniquement sur `/v1/{chain}`
>   et `/v1/{chain}/{api_key}`. Une barre oblique finale (comme `/v1/{chain}/`) ou une requête sans segment de chaîne (comme `/v1` ou `/v1/`) renvoie `404` avec un corps vide.


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

```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(())
}
```


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](#common-errors) 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](https://blockvectra.com/fr/pricing/) 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](https://docs.blockvectra.com/fr/api/json-rpc/) — cette page traite uniquement du
format d'une requête.

#### Erreurs courantes

| Ce que vous avez fait                                                                                                                                                                                                                                                                           | Ce qui est renvoyé                                                          | Action                                                                                                                                                                                                                                                                                                                                                                      |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Chaîne inconnue ou pas encore publique                                                                                                                                                                                                                                                          | HTTP `404` avec corps JSON `error.data.reason: "unknown_chain"`             | Vérifiez le nom de la chaîne dans l'URL                                                                                                                                                                                                                                                                                                                                     |
| Requête sans segment de chaîne (par ex. `/v1` ou `/v1/`)                                                                                                                                                                                                                                        | HTTP `404` avec un corps vide                                               | Incluez le nom de la chaîne dans l'URL (`/v1/{chain}`)                                                                                                                                                                                                                                                                                                                      |
| API key manquante, inconnue ou désactivée                                                                                                                                                                                                                                                       | HTTP `401`, code JSON-RPC `-32024` (`missing_api_key` ou `invalid_api_key`) | Utilisez une API key valide et active (les clés nouvellement créées ou renouvelées prennent effet sur chaque instance en environ 5 secondes ; durant ce laps de temps, elles peuvent renvoyer 401 `invalid_api_key`, ou 503 `-32021` (avec `Retry-After`) lorsque l'état de facturation ne peut pas être confirmé pour le moment, patientez donc un instant puis réessayez) |
| Solde nul ou négatif                                                                                                                                                                                                                                                                            | HTTP `402`, code JSON-RPC `-32020`                                          | Rechargez votre solde ou attendez la recharge gratuite                                                                                                                                                                                                                                                                                                                      |
| Envoi de requêtes trop rapide (limite de débit ou surcharge temporaire)                                                                                                                                                                                                                         | HTTP `429` (ou `200`), code JSON-RPC `-32005`                               | Réessayez plus tard (respectez `Retry-After` lorsqu'il est présent)                                                                                                                                                                                                                                                                                                         |
| Requête unique ou batch dépassant la capacité de burst de la clé (`burst_cu`, par défaut 1,600 CU ; débit par défaut 400 CU/s), ou le lot du forfait gratuit dépasse les appels/sec (25 appels/s)                                                                                                                                                                                      | HTTP `429`, code JSON-RPC `-32022` (`request_exceeds_burst`)                | Découpez la requête en batches plus petits (ne pourra jamais aboutir sous cette forme)                                                                                                                                                                                                                                                                                      |
| Nœud en amont temporairement indisponible                                                                                                                                                                                                                                                       | HTTP `200`, code JSON-RPC `-32603` (`upstream unavailable`), non facturé    | Réessayez la requête                                                                                                                                                                                                                                                                                                                                                        |
| État historique situé en dehors de la fenêtre d'état de cette chaîne (voir `state_window_blocks` dans `GET /v1/chains`)                                                                                                                                                                         | HTTP `200`, code JSON-RPC `-32011`, non facturé                             | Interrogez un bloc plus récent                                                                                                                                                                                                                                                                                                                                              |
| Transaction ou bloc non trouvé, ou réponse trop volumineuse ; sur Ethereum, les requêtes de blocs / reçus / logs hors de la fenêtre récente renvoient également -32000 "old data not available due to pruning" (non facturé ; voir [Chaînes prises en charge → Ethereum](https://docs.blockvectra.com/fr/chains/#ethereum)) | HTTP `200`, code JSON-RPC `-32000`                                          | Modifiez la requête (vérifiez le hash ou le numéro de bloc ; les hashs de trace mal formés renvoient transaction not found)                                                                                                                                                                                                                                                 |
| Traceur non autorisé, ou délai d'expiration de trace non autorisé (appels `debug_trace`)                                                                                                                                                                                                        | HTTP `200`, code JSON-RPC `-32602`, non facturé                             | Utilisez un traceur natif autorisé (`callTracer`, `flatCallTracer`, `prestateTracer`, `4byteTracer`, `noopTracer`, ou omettez) et un délai ≤ 30s                                                                                                                                                                                                                            |
| Une méthode que la liste des méthodes de la chaîne n'autorise pas (voir [Chaînes prises en charge](https://docs.blockvectra.com/fr/chains/))                                                                                                                                                                                | HTTP `200`, code JSON-RPC `-32601`, non facturé                             | N'appelez que des méthodes autorisées par la chaîne                                                                                                                                                                                                                                                                                                                         |
| Corps JSON mal formé                                                                                                                                                                                                                                                                            | HTTP `200`, code JSON-RPC `-32700`, non facturé                             | Corrigez la syntaxe JSON de la requête                                                                                                                                                                                                                                                                                                                                      |
| Plus de 100 appels dans un seul batch                                                                                                                                                                                                                                                           | HTTP `200`, code JSON-RPC `-32600` (`batch too large`), non facturé         | Découpez le batch en 100 appels au maximum                                                                                                                                                                                                                                                                                                                                  |

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

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

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

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

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

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

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

### Pour aller plus loin

* [Référence de l'API → JSON-RPC](https://docs.blockvectra.com/fr/api/json-rpc/) — méthodes, pondérations en CU, codes d'erreur
* [Référence JSON-RPC complète](https://docs.blockvectra.com/fr/api/json-rpc/reference/) — 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](https://docs.blockvectra.com/fr/api/data/) — points de terminaison REST pour les données de la chaîne
* [Jeux de données](https://docs.blockvectra.com/fr/datasets/) — jeux de données dérivés sur les chaînes prises en charge
* [Guides](https://docs.blockvectra.com/fr/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](https://docs.blockvectra.com/fr/chains/) — identifiants de réseaux et URL des points de terminaison

## FAQ

### Quelles chaînes sont prises en charge ?

9 chaînes sont prises en charge : Arbitrum One, Base, BNB Smart Chain, Ethereum, Ethereum Sepolia, HyperEVM, Polygon, Robinhood Chain, Robinhood Chain Testnet. La liste suit GET /v1/chains et se met à jour lors du lancement de nouvelles chaînes. Consultez la [page d'état](https://blockvectra.com/fr/status/) pour connaître l'état en direct. [Voir les chaînes prises en charge](https://blockvectra.com/fr/chains/)

### WebSocket est-il pris en charge ?

L'appel de eth_subscribe via HTTP renvoie -32601 ; sur les chaînes où ws est true dans /v1/chains, eth_subscribe est disponible via WebSocket. Sinon, interrogez eth_getLogs. [Voir les chaînes prises en charge](https://blockvectra.com/fr/chains/)

### Puis-je interroger l'état historique et les traces ?

Oui, mais cela varie selon la chaîne. La fenêtre d'état historique est définie par le champ state_window_blocks de /v1/chains (null signifie historique complet) ; la disponibilité des traces dépend du fait que methods.allow pour cette chaîne inclut des méthodes debug_trace (telles que debug_traceTransaction) ; la plage maximale de blocs pour une seule requête eth_getLogs est max_logs_block_range. [Voir le répertoire des chaînes et les paramètres par chaîne](https://blockvectra.com/fr/chains/)

### Une seule clé API peut-elle être utilisée sur toutes les chaînes ?

Oui. Une seule clé API fonctionne pour le JSON-RPC sur chaque chaîne prise en charge et pour la Data API sur les chaînes qui la proposent ; une clé appartient au compte, pas à une chaîne spécifique. [Lire le guide « Une clé, plusieurs chaînes »](https://docs.blockvectra.com/en/guides/one-key-many-chains/)