Schnellstart

Entwickler und KI-Agenten können den öffentlichen RPC ohne Schlüssel ausprobieren und anschließend einen Schlüssel erstellen, um fortzufahren.

1. Blockhöhe ohne Schlüssel abfragen

Rufen Sie den öffentlichen JSON-RPC-Endpunkt für die Beispiel-Chain robinhood_mainnet auf, ohne ein Konto anzulegen oder einen API-Schlüssel anzugeben:

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

Das Feld id: 1 in der Antwort stimmt mit dieser Anfrage überein; result ist eine hexadezimale Blockhöhe und kann sich zwischen Aufrufen ändern. Falls die Antwort ein Feld error enthält, prüfen Sie Code und Grund. Siehe kostenlose öffentliche RPC-Endpunkte für öffentliche Methoden, Verlaufsbereiche und Limits pro IP.

2. Einen API-Schlüssel erstellen

Rufen Sie die Konsole auf, melden Sie sich mit GitHub, Google oder einem Ethereum-Wallet an (Ihr Konto wird beim ersten Login erstellt) und generieren Sie einen API-Schlüssel. Das Secret wird nur ein einziges Mal angezeigt: Bewahren Sie es sicher auf und hinterlegen Sie es als Umgebungsvariable BLOCKVECTRA_API_KEY. Fügen Sie es keinesfalls in clientseitigen Browser-Code ein. Neue Konten erhalten 30,000,000 CU bei der Registrierung — keine Kreditkarte erforderlich.

3. Ihren ersten authentifizierten Aufruf senden

Lesen Sie die Blockhöhe derselben Chain mit dem Header x-api-key aus. Die URL endet mit dem Namen der Chain, ohne abschließenden Schrägstrich:

: "${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 ist wiederum eine hexadezimale Blockhöhe. Diese Anfrage verbraucht CU; siehe die JSON-RPC-Referenz für Methodengewichte und Fehlercodes sowie Preise für aktuelle Preise. Ein neuer Schlüssel wird in etwa 5 Sekunden aktiv; falls Sie invalid_api_key erhalten, warten Sie kurz und versuchen Sie es erneut. Siehe Häufige Fehler unten für sonstige Fehlerfälle.

4. Mit einer Geschäftsaufgabe fortfahren

• On-Chain-Aktivitäten tokenisierter Aktien auf Robinhood Chain abfragen
• HyperEVM-Logs blockweise nachfüllen
• Wallet-Aktivitäten und Token-Transfers über Webhooks empfangen

Referenz

API-Schlüssel und Guthaben

Vollständige Starter-Vorlage: blockvectra/agent-quickstart

Jeder Schlüssel beginnt mit rgw_, gefolgt von 64 Hex-Zeichen, beispielsweise rgw_1f2e... (gekürzt). Halten Sie ihn geheim — jeder, der diesen Schlüssel besitzt, kann Ihr Guthaben verbrauchen.

# Direkter öffentlicher Endpunkt:
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":[]}'

# Oder mit API-Key-Fallback (fällt auf öffentlich zurück, wenn BLOCKVECTRA_API_KEY nicht gesetzt ist):
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":[]}'

Die folgenden zwei öffentlichen Metadaten-Endpunkte zeigen den Dienststatus und die Konfiguration der einzelnen Chains an; sie erfordern keinen API-Schlüssel und werden nicht abgerechnet.

Dienst- und Chain-Integritätsstatus prüfen

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

Gibt den Prüfzeitstempel checked_at, den Dienstbetriebsstatus gateway.status und für jede unterstützte Chain den Node-Synchronisationsfortschritt sync, die aktuelle Blockhöhe und die Latenz head zurück:

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

Unterstützte Chains und Methodenrichtlinien abfragen

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

Gibt für jede unterstützte Chain die chain_id, Funktions-Flags für JSON-RPC, Data API und WebSocket, Methoden-Erlaubnis- und Verbotsrichtlinien (methods.allow und methods.deny), das Blockbereichslimit für Einzelabfragen von Logs max_logs_block_range und das historische Statusfenster state_window_blocks zurück:

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

Eine Chain auswählen

Jeder BlockVectra-Endpunkt ist einer Chain zugeordnet: JSON-RPC-Anfragen führen den Chain-Namen {chain} im URL-Pfad, und Data-API-Anfragen stellen ihn der Route voran. Siehe Unterstützte Chains für derzeit verfügbare Chains und deren Bezeichner.

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'

Alle Beispiele auf dieser Seite verwenden robinhood_mainnet.

Tipp: Wählen Sie in der obigen Matrix eine Chain, die den Dienst, die Methode und das Verlaufsfenster des Beispiels unterstützt, und ersetzen Sie robinhood_mainnet durch deren {chain}. Derselbe API-Schlüssel funktioniert auf allen unterstützten Chains.

Weitere Authentifizierungsoptionen und Sprachbeispiele

JSON-RPC-Endpunkte sind an eine Chain gebunden: POST /v1/{chain}/{api_key} mit dem Schlüssel im Pfad oder POST /v1/{chain} mit dem Schlüssel im Header x-api-key. {chain} ist der Chain-Name, den auch die Data API verwendet; für Robinhood Chain lautet er robinhood_mainnet, sodass der Endpunkt auf dieser Seite https://api.blockvectra.com/v1/robinhood_mainnet ist. Der Aufruf von eth_subscribe über HTTP gibt -32601 zurück; WebSocket-Abonnements sind für jede Chain unter Unterstützte Chains aufgeführt. Die API sendet Access-Control-Allow-Origin: *, Sie sollten Ihren API-Schlüssel jedoch geheim halten und Anfragen von einem Backend-Dienst statt aus clientseitigem Browser-Code senden.

Sie können den Schlüssel auf drei Arten übergeben: im URL-Pfad (POST /v1/{chain}/{api_key}, was ausschließlich den Schlüssel im Pfad verwendet und beide Header ignoriert), im Header x-api-key oder in einem Header Authorization: Bearer <api_key>.

Schlüssel im URL-Pfad

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

Schlüssel im Anfrage-Header

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

Ein Header Authorization: Bearer <api_key> funktioniert ebenfalls. Bei POST /v1/{chain} hat ein nicht-leerer x-api-key Vorrang vor Bearer, und Bearer wird nur verwendet, wenn x-api-key fehlt oder leer ist. Die Pfadform ignoriert beide Header.

Batch-Aufrufe

Senden Sie ein Array, um mehrere Aufrufe in einer einzigen Anfrage auszuführen (bis zu 100 pro Batch). Beachten Sie, dass jeder API-Schlüssel über einen CU-Bucket verfügt (cu_per_sec Wiederauffüllung, burst_cu Kapazität — Standardwerte sind 400 CU/s und Burst 1,600 CU; pro Schlüssel in der Konsole in der Tabelle Schlüssel aufgeführt); eine einzelne Anfrage — einschließlich eines gesamten JSON-RPC-Batches —, deren gesamte CU die Burst-Kapazität des Schlüssels überschreitet, wird mit -32022 request_exceeds_burst abgewiesen, selbst wenn sie unter dem Limit von 100 Aufrufen pro Batch liegt; teilen Sie diese in kleinere Batches auf. Dieses Beispiel liest die Chain ID und einen Kontostand in einem einzigen Roundtrip aus:

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

Antworten werden als Array in der gleichen Reihenfolge wie die Anfragen zurückgegeben und über die id zugeordnet.

Falls der Server stattdessen den gesamten Batch ablehnt — unzureichendes Guthaben, Rate-Limiting, Burst-Kapazität oder ein zu großer Batch (siehe Häufige Fehler unten) —, gibt er ein einzelnes JSON-RPC-Fehlerobjekt anstelle eines Arrays zurück; der Modus batch: true von viem stellt dies dann als undurchsichtigen UnknownRpcError dar; führen Sie in diesem Fall einen einzelnen Aufruf aus, um den tatsächlichen Fehler einzusehen.

CU-Abrechnung verstehen

Jeder abgerechnete Aufruf verbraucht Compute Units (CU): Günstige Aufrufe wie eth_blockNumber oder eth_chainId kosten am wenigsten, gängige Lesezugriffe wie eth_getBlockByNumber etwas mehr, aufwendigere Aufrufe wie eth_call oder eth_getLogs mehr und Ausführungs-Trace-Methoden (wie debug_traceTransaction) am meisten. Die Nutzung wird pro Konto für jeden stündlichen Zeitraum abgerechnet, abgerundet auf ganze Abrechnungseinheiten (1 Einheit = 1,000 CU), wobei der Rest in den nächsten Zeitraum übertragen wird (über Zeiträume hinweg entspricht der berechnete Gesamtbetrag somit floor(Gesamt-CU / 1,000)); die Abrechnung erfolgt etwa 15 Minuten nach Ende des Zeitraums. Beispiel: 508 übertragene CU + 2557 verbrauchte CU = 3065 CU, was zu 3 berechneten Abrechnungseinheiten und 65 in den nächsten Zeitraum übertragenen CU führt. Siehe Preise für aktuelle Preise.

Die vollständige Tabelle der Methodengewichte und Fehlercodes finden Sie in der API-Referenz → JSON-RPC — diese Seite behandelt lediglich den Aufbau einer Anfrage.

Häufige Fehler

Die obigen Ablehnungen werden niemals abgerechnet. Jeder angenommene Aufruf, der eine Antwort erhält, wird mit dem veröffentlichten CU-Gewicht der Methode verrechnet; die Fehlercode-Tabelle führt die Fälle auf, die nicht abgerechnet werden (siehe die Spalte „Billed“ in Fehlercodes).

Die Data API aufrufen

Die Data API stellt schreibgeschützte Chain-Daten (Blöcke, Transaktionen, Salden, Inhaber, DEX-Aktivitäten und mehr) als REST/JSON bereit. Jeder Pfad außer GET https://api.blockvectra.com/v1/data/chains wird mit einer Chain-Kennung versehen: robinhood_mainnet ist die Chain-Kennung (das Feld chain, das von /chains und in meta zurückgegeben wird), die in jedem nachfolgenden Pfad verwendet wird. GET https://api.blockvectra.com/v1/data/chains listet nur öffentliche Chains auf und gibt ausschließlich {"data": [...]} zurück (kein meta, kein next_cursor). Anfragen werden nach Compute Units (CU) gemessen und abgerechnet; nur erfolgreiche 2xx-Antworten werden berechnet.

Jede Anfrage erfordert denselben API-Schlüssel wie JSON-RPC — übergeben Sie ihn im Header x-api-key. Jede chain-spezifische Erfolgsantwort verwendet denselben Envelope: data (die Nutzlast), next_cursor (ein opaker String, nur vorhanden, wenn eine weitere Seite existiert — andernfalls fehlt der Schlüssel vollständig, niemals null) und meta (chain, chain_slug (Großschreibungsform von chain), chain_external_id, as_of_block, safe_block, finalized_block, coverage, refreshed_at; refreshed_at kann null sein, was bedeutet, dass der Aktualisierungszeitpunkt der Daten unbekannt ist und sie als veraltet behandelt werden sollten — blockbasierte Endpunkte geben stets einen Wert zurück). Fehlerantworten enthalten üblicherweise {"error":{"code","message"}} — 409 not_indexed_yet fügt indexed_through hinzu (den höchsten indizierten Block). Eine unbekannte oder nicht-öffentliche Chain gibt HTTP 404 mit error.code not_found zurück (wird nicht abgerechnet; Chain-Namen müssen exakte Kleinbuchstaben-Slugs sein); ein fehlender, unbekannter oder deaktivierter API-Schlüssel gibt HTTP 401 mit error.code missing_api_key oder invalid_api_key zurück. Durch Rate-Limiting abgewiesene Anfragen geben HTTP 429 zurück (error.code rate_limited, data.reason: "key_rate_limit"), und ein aufgebrauchtes Guthaben gibt HTTP 402 zurück (error.code insufficient_balance); beide werden nicht abgerechnet. Werte, die 2^53 überschreiten können (Salden, Token-Beträge), sind Dezimal-Strings, niemals JSON-Zahlen.

Einen Block nach Nummer abfragen:

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

Eine Nummer über dem indizierten Head (as_of_block) liefert 409 (error.code: "not_indexed_yet"), wobei indexed_through den höchsten indizierten Block angibt — die Daten sind noch nicht verfügbar, versuchen Sie es also später erneut. Eine Blocknummer, die vollständig vor dem abgedeckten Verlauf der Chain liegt (coverage.from_block), gibt 422 (error.code: "no_coverage") zurück. Innerhalb der Abdeckung liefert eine Nummer auf oder unter as_of_block ohne vorhandenen Datensatz (nie indiziert oder durch einen Reorg zurückgerollt) 404 (error.code: "not_found").

Datenaktualität prüfen (wie weit jeder verfolgte Datensatz hinter dem Chain-Head zurückliegt — nützlich für eine Statusseite oder einen Pre-Flight-Check vor Ausführung einer Abfrage):

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

(Gekürzt: Die Antwort enthält eine Zeile pro Datensatz; dargestellt ist nur die Zeile blocks. Die Zeile traces enthält außerdem coverage_from_block, coverage_to_block und coverage_complete.)

Falls Aktualitätsdaten für diese Chain vorübergehend nicht verfügbar sind, wird 503 (error.code: "unavailable") anstelle eines Teilergebnisses zurückgegeben; die Antwort enthält einen Retry-After-Header (in Sekunden) — warten Sie mindestens diese Zeitspanne ab und versuchen Sie es dann erneut.

ERC-20-Salden einer Adresse auflisten (ein Snapshot gefiltert nach Salden ungleich null, sortiert nach 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"
  }
}

Eine Adresse ohne Salden ungleich null gibt weiterhin 200 mit data: [] zurück — niemals 404. Übergeben Sie ?limit= (Standard 50, Maximum 500) und den zurückgegebenen next_cursor, um durch weitere Ergebnisse zu blättern.

Die vollständige Abdeckung der Endpunkte — Blöcke, Transaktionen, Adressen, Token, NFTs, DEX, tokenisierte Aktien — finden Sie in der API-Referenz → Data API.

Weiterführende Dokumentation

• API-Referenz → JSON-RPC — Methoden, CU-Gewichte, Fehlercodes
• Vollständige JSON-RPC-Referenz — Vollständige Spezifikationen, Parameter und Rückgabeschemata für alle unterstützten Methoden
• API-Referenz → Data API — REST-Endpunkte für Chain-Daten
• Datensätze — Abgeleitete Datensätze über alle unterstützten Chains hinweg
• Anleitungen — Praktische Anleitungen zur API-Integration, CU-Verwaltung und für Multi-Chain-Workflows
• Unterstützte Chains — Netzwerk-IDs und Endpunkt-URLs

FAQ