# Schnellstart > Source: https://docs.blockvectra.com/de/quickstart/ 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: ```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":[]}' ``` 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](https://blockvectra.com/de/free/#public-rpc) für öffentliche Methoden, Verlaufsbereiche und Limits pro IP. ## 2. Einen API-Schlüssel erstellen Rufen Sie die [Konsole](https://console.blockvectra.com/login/?next=%2Fkeys%2F) 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. > **Noch kein API-Schlüssel?** > > Wenn Sie ein Ethereum-Wallet haben: Folgen Sie dem [Leitfaden zur programmatischen Registrierung](https://docs.blockvectra.com/de/guides/programmatic-signup/), um sich ohne Browser über eine Signatur Ihres Ethereum-Wallets zu registrieren und einen API-Schlüssel zu erstellen. Wenn Sie kein Wallet haben: Bitten Sie den Benutzer, sich unter [console.blockvectra.com](https://console.blockvectra.com/login/?next=%2Fkeys%2F) anzumelden, einen Schlüssel zu erstellen und diesen als Umgebungsvariable `BLOCKVECTRA_API_KEY` zu setzen. Bitten Sie den Benutzer nicht, den Schlüssel in den Chat einzufügen. ## 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: ```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` ist wiederum eine hexadezimale Blockhöhe. Diese Anfrage verbraucht CU; siehe die [JSON-RPC-Referenz](https://docs.blockvectra.com/de/api/json-rpc/) für Methodengewichte und Fehlercodes sowie [Preise](https://blockvectra.com/de/pricing/) 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](#common-errors) unten für sonstige Fehlerfälle. ## 4. Mit einer Geschäftsaufgabe fortfahren * [On-Chain-Aktivitäten tokenisierter Aktien auf Robinhood Chain abfragen](https://docs.blockvectra.com/de/guides/stocks/) * [HyperEVM-Logs blockweise nachfüllen](https://docs.blockvectra.com/de/guides/hyperevm-backfill/) * [Wallet-Aktivitäten und Token-Transfers über Webhooks empfangen](https://docs.blockvectra.com/de/guides/webhook-push/) ## Referenz ### API-Schlüssel und Guthaben Vollständige Starter-Vorlage: [blockvectra/agent-quickstart](https://github.com/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. > Wenn Ihr Guthaben nicht ausreicht, gibt der Server HTTP 402 zurück (JSON-RPC-Fehlercode `-32020`; Data API `error.code` `insufficient_balance`). Öffnen Sie die [Abrechnungsseite](https://console.blockvectra.com/billing/) in der Konsole, um Ihr Guthaben und Auflademethoden zu prüfen. ### Ohne API-Key testen Sie können den öffentlichen JSON-RPC-Endpunkt sofort aufrufen, ohne ein Konto zu erstellen oder einen API-Key anzugeben. Der Endpunkt im folgenden Beispiel ist pro IP ratenbegrenzt (3 Anfr./s, Burst 20, maximale Batch-Größe 10). Anfragen, die die Ratenbegrenzung überschreiten, geben HTTP 429 mit dem Grund `public_rate_limit` oder `public_pool_busy` zurück (zusammen mit einem `Retry-After`-Header); nicht unterstützte Methoden geben den JSON-RPC-Fehler `-32601` (`method_not_public`) zurück. ```bash # 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":[]}' ``` #### Öffentliche Endpunkte nach Chain - Arbitrum One: https://api.blockvectra.com/v1/arb_mainnet/public — Lesen und signierte Transaktionen übertragen (eth_sendRawTransaction) - Base: https://api.blockvectra.com/v1/base_mainnet/public — Lesen und signierte Transaktionen übertragen (eth_sendRawTransaction) - BNB Smart Chain: https://api.blockvectra.com/v1/bsc_mainnet/public — Lesen und signierte Transaktionen übertragen (eth_sendRawTransaction) - Ethereum: https://api.blockvectra.com/v1/eth_mainnet/public — Lesen und signierte Transaktionen übertragen (eth_sendRawTransaction) - Ethereum Sepolia: https://api.blockvectra.com/v1/eth_sepolia/public — Lesen und signierte Transaktionen übertragen (eth_sendRawTransaction) - HyperEVM: https://api.blockvectra.com/v1/hyperevm_mainnet/public — Schreibgeschützt - Polygon: https://api.blockvectra.com/v1/polygon_mainnet/public — Lesen und signierte Transaktionen übertragen (eth_sendRawTransaction) - Robinhood Chain: https://api.blockvectra.com/v1/robinhood_mainnet/public — Lesen und signierte Transaktionen übertragen (eth_sendRawTransaction) - Robinhood Chain Testnet: https://api.blockvectra.com/v1/robinhood_testnet/public — Lesen und signierte Transaktionen übertragen (eth_sendRawTransaction) 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 ```bash 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: ```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 } } ] } ``` ### Unterstützte Chains und Methodenrichtlinien abfragen ```bash 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: ```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": {} } ] } ``` ### 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](https://docs.blockvectra.com/de/chains/) für derzeit verfügbare Chains und deren Bezeichner. | Chain | {chain} | Chain-ID | Tracing | Öffentlicher Endpunkt | WebSocket | Data API | Methoden mit API-Schlüssel | Webhook-Push | Transaktionen senden | Transaktionen senden (öffentlicher Endpunkt ohne Key) | Fenster der Zustandshistorie | eth_getLogs maximaler Blockbereich | Data API Datensätze | Zugehörige Testnetze | Zugehörige Anleitungen | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | [arb_mainnet RPC und Data API](https://blockvectra.com/de/chains/arb_mainnet/) | arb_mainnet | 42161 | ✓ | `https://api.blockvectra.com/v1/arb_mainnet/public` | Nicht unterstützt | Verfügbar | 43 | [Unterstützt · Bestätigungen 1–1 (Standard 1)](https://blockvectra.com/de/webhooks/), [Webhook-Push-Anleitung](https://docs.blockvectra.com/de/guides/webhook-push/) | Unterstützt | Unterstützt | Historischer Zustand für die letzten 6,000 Blöcke | 1,000 Blöcke | Blöcke, Transaktionen, Adresstransaktionen, Token-Transfers, Token-Metadaten, Datenaktualität | Unbekannt | Unbekannt | | [base_mainnet RPC und Data API](https://blockvectra.com/de/chains/base_mainnet/) | base_mainnet | 8453 | — | `https://api.blockvectra.com/v1/base_mainnet/public` | Nicht unterstützt | Verfügbar | 39 | [Unterstützt · Bestätigungen 1–1 (Standard 1)](https://blockvectra.com/de/webhooks/), [Webhook-Push-Anleitung](https://docs.blockvectra.com/de/guides/webhook-push/) | Unterstützt | Unterstützt | Historischer Zustand für die letzten 10,000 Blöcke | 1,000 Blöcke | Blöcke, Transaktionen, Adresstransaktionen, Token-Transfers, Token-Metadaten, Datenaktualität | Unbekannt | [Base](https://docs.blockvectra.com/de/guides/base/) | | [bsc_mainnet RPC und Data API](https://blockvectra.com/de/chains/bsc_mainnet/) | bsc_mainnet | 56 | — | `https://api.blockvectra.com/v1/bsc_mainnet/public` | Nicht unterstützt | Verfügbar | 25 | [Unterstützt · Bestätigungen 1–1 (Standard 1)](https://blockvectra.com/de/webhooks/), [Webhook-Push-Anleitung](https://docs.blockvectra.com/de/guides/webhook-push/) | Unterstützt | Unterstützt | Historischer Zustand für die letzten 100 Blöcke | 1,000 Blöcke | Blöcke, Transaktionen, Adresstransaktionen, Token-Transfers, Token-Metadaten, Datenaktualität | Unbekannt | Unbekannt | | [Ethereum RPC und Data API](https://blockvectra.com/de/chains/eth_mainnet/) | eth_mainnet | 1 | ✓ | `https://api.blockvectra.com/v1/eth_mainnet/public` | Nicht unterstützt | Verfügbar | 38 | [Unterstützt · Bestätigungen 1–1 (Standard 1)](https://blockvectra.com/de/webhooks/), [Webhook-Push-Anleitung](https://docs.blockvectra.com/de/guides/webhook-push/) | Unterstützt | Unterstützt | Historischer Zustand für die letzten 250,000 Blöcke | 1,000 Blöcke | Blöcke, Transaktionen, Adresstransaktionen, Token-Transfers, Token-Metadaten, Datenaktualität | Unbekannt | Unbekannt | | [eth_sepolia RPC und Data API](https://blockvectra.com/de/chains/eth_sepolia/) | eth_sepolia | 11155111 | — | `https://api.blockvectra.com/v1/eth_sepolia/public` | Nicht unterstützt | Verfügbar | 29 | [Unterstützt · Bestätigungen 1–1 (Standard 1)](https://blockvectra.com/de/webhooks/), [Webhook-Push-Anleitung](https://docs.blockvectra.com/de/guides/webhook-push/) | Unterstützt | Unterstützt | Unbekannt | 1,000 Blöcke | Blöcke, Transaktionen, Adresstransaktionen, Token-Transfers, Token-Metadaten, Datenaktualität | Unbekannt | Unbekannt | | [HyperEVM RPC und Data API](https://blockvectra.com/de/chains/hyperevm_mainnet/) | hyperevm_mainnet | 999 | — | `https://api.blockvectra.com/v1/hyperevm_mainnet/public` | Nicht unterstützt | Verfügbar | 24 | [Unterstützt · Bestätigungen 1–1 (Standard 1)](https://blockvectra.com/de/webhooks/), [Webhook-Push-Anleitung](https://docs.blockvectra.com/de/guides/webhook-push/) | Nicht unterstützt | Nicht unterstützt | Unbekannt | 1,000 Blöcke | Blöcke, Transaktionen, Adresstransaktionen, Token-Transfers, Token-Metadaten, Salden, Inhaber, NFT-Bestände, Datenaktualität | Unbekannt | [HyperEVM backfill and polling](https://docs.blockvectra.com/de/guides/hyperevm-backfill/) | | [polygon_mainnet RPC und Data API](https://blockvectra.com/de/chains/polygon_mainnet/) | polygon_mainnet | 137 | ✓ | `https://api.blockvectra.com/v1/polygon_mainnet/public` | Nicht unterstützt | Verfügbar | 43 | [Unterstützt · Bestätigungen 1–1 (Standard 1)](https://blockvectra.com/de/webhooks/), [Webhook-Push-Anleitung](https://docs.blockvectra.com/de/guides/webhook-push/) | Unterstützt | Unterstützt | Historischer Zustand für die letzten 126 Blöcke | 1,000 Blöcke | Blöcke, Transaktionen, Adresstransaktionen, Token-Transfers, Token-Metadaten, Datenaktualität | Unbekannt | Unbekannt | | [Robinhood Chain RPC und Data API](https://blockvectra.com/de/chains/robinhood_mainnet/) | robinhood_mainnet | 4663 | ✓ | `https://api.blockvectra.com/v1/robinhood_mainnet/public` | Unterstützt (newHeads, logs) | Verfügbar | 43 | [Unterstützt · Bestätigungen 1–1 (Standard 1)](https://blockvectra.com/de/webhooks/), [Webhook-Push-Anleitung](https://docs.blockvectra.com/de/guides/webhook-push/) | Unterstützt | Unterstützt | Historischer Zustand für die letzten 900 Blöcke | 1,000 Blöcke | Blöcke, Transaktionen, Adresstransaktionen, Token-Transfers, Token-Metadaten, Salden, Inhaber, NFT-Bestände, DEX-Swaps, DEX-Preise, Tokenisierte Aktien, Transaktions-Traces, Datenaktualität | Unbekannt | [Robinhood Chain](https://docs.blockvectra.com/de/guides/robinhood-chain/), [Stock token multiplier](https://docs.blockvectra.com/de/guides/stock-token-multiplier/), [Tokenized stocks](https://docs.blockvectra.com/de/guides/stocks/) | | [robinhood_testnet RPC](https://blockvectra.com/de/chains/robinhood_testnet/) | robinhood_testnet | 46630 | ✓ | `https://api.blockvectra.com/v1/robinhood_testnet/public` | Unterstützt (newHeads, logs) | Noch nicht verfügbar | 43 | [Unterstützt · Bestätigungen 1–1 (Standard 1)](https://blockvectra.com/de/webhooks/), [Webhook-Push-Anleitung](https://docs.blockvectra.com/de/guides/webhook-push/) | Unterstützt | Unterstützt | Historischer Zustand für die letzten 1,023 Blöcke | 1,000 Blöcke | Nicht unterstützt | Unbekannt | [Testnet faucet](https://docs.blockvectra.com/de/guides/robinhood-testnet-faucet/), [Robinhood Chain Testnet starter](https://docs.blockvectra.com/de/guides/robinhood-testnet-starter/) | ## Nächste Schritte mit einem API-Schlüssel ### 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/de/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/de/api/data/) [Webhook-Abonnement erstellen](https://blockvectra.com/de/webhooks/) · [Webhook-Abonnement erstellen](https://docs.blockvectra.com/de/guides/webhook-push/) · [Nutzung und CU](https://console.blockvectra.com/usage/) · [Guthaben aufladen](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/de/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/de/api/data/) [Webhook-Abonnement erstellen](https://blockvectra.com/de/webhooks/) · [Webhook-Abonnement erstellen](https://docs.blockvectra.com/de/guides/webhook-push/) · [Nutzung und CU](https://console.blockvectra.com/usage/) · [Guthaben aufladen](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/de/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/de/api/data/) [Webhook-Abonnement erstellen](https://blockvectra.com/de/webhooks/) · [Webhook-Abonnement erstellen](https://docs.blockvectra.com/de/guides/webhook-push/) · [Nutzung und CU](https://console.blockvectra.com/usage/) · [Guthaben aufladen](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/de/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/de/api/data/) [Webhook-Abonnement erstellen](https://blockvectra.com/de/webhooks/) · [Webhook-Abonnement erstellen](https://docs.blockvectra.com/de/guides/webhook-push/) · [Nutzung und CU](https://console.blockvectra.com/usage/) · [Guthaben aufladen](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/de/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/de/api/data/) [Webhook-Abonnement erstellen](https://blockvectra.com/de/webhooks/) · [Webhook-Abonnement erstellen](https://docs.blockvectra.com/de/guides/webhook-push/) · [Nutzung und CU](https://console.blockvectra.com/usage/) · [Guthaben aufladen](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/de/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/de/api/data/) [Webhook-Abonnement erstellen](https://blockvectra.com/de/webhooks/) · [Webhook-Abonnement erstellen](https://docs.blockvectra.com/de/guides/webhook-push/) · [Nutzung und CU](https://console.blockvectra.com/usage/) · [Guthaben aufladen](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/de/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/de/api/data/) [Webhook-Abonnement erstellen](https://blockvectra.com/de/webhooks/) · [Webhook-Abonnement erstellen](https://docs.blockvectra.com/de/guides/webhook-push/) · [Nutzung und CU](https://console.blockvectra.com/usage/) · [Guthaben aufladen](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/de/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/de/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/de/guides/websocket-subscriptions/) [Webhook-Abonnement erstellen](https://blockvectra.com/de/webhooks/) · [Webhook-Abonnement erstellen](https://docs.blockvectra.com/de/guides/webhook-push/) · [Nutzung und CU](https://console.blockvectra.com/usage/) · [Guthaben aufladen](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/de/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/de/guides/websocket-subscriptions/) [Webhook-Abonnement erstellen](https://blockvectra.com/de/webhooks/) · [Webhook-Abonnement erstellen](https://docs.blockvectra.com/de/guides/webhook-push/) · [Nutzung und CU](https://console.blockvectra.com/usage/) · [Guthaben aufladen](https://console.blockvectra.com/billing/) **HyperEVM** HyperEVM-Blöcke enthalten HyperCore-Systemtransaktionen (von Adresse 0x2222…2222 oder 0x20…, gasPrice 0). Das Senden von Transaktionen wird auf dieser Chain noch nicht unterstützt (`eth_sendRawTransaction` gibt `-32601` `method_not_allowed` zurück); Lesemethoden funktionieren normal. [Live-Status ansehen →](https://blockvectra.com/de/status/) 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](https://docs.blockvectra.com/de/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 `. #### Schlüssel im URL-Pfad **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()); // Ausführen mit: npx tsx example.mts ``` Vollständige Starter-Vorlage: [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 // Ausführen mit: 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> { 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(()) } ``` #### Schlüssel im Anfrage-Header **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()); // Ausführen mit: npx tsx example.mts ``` **Python** ```python import os from web3 import Web3 key = os.environ["BLOCKVECTRA_API_KEY"] # request_kwargs ersetzt die Standard-Header des Providers vollständig, daher # muss Content-Type hier wiederholt werden, damit der Server den Body parsen kann. 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 // Ausführen mit: 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> { 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(()) } ``` > **Kein abschließender Schrägstrich** > > Wenn Sie den Schlüssel in einem Header übergeben, rufen Sie `https://api.blockvectra.com/v1/robinhood_mainnet` exakt wie dargestellt auf: Die URL endet mit dem Chain-Namen, **ohne** abschließenden Schrägstrich. JSON-RPC wird ausschließlich unter `/v1/{chain}` und `/v1/{chain}/{api_key}` bereitgestellt. Ein abschließender Schrägstrich (wie `/v1/{chain}/`) oder eine Anfrage ohne Chain-Segment (wie `/v1` oder `/v1/`) gibt `404` mit leerem Body zurück. Ein Header `Authorization: Bearer ` 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** ```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 fasst gleichzeitige Anfragen zu einem einzigen JSON-RPC-Batch zusammen. const [chainId, balance] = await Promise.all([ client.getChainId(), client.getBalance({ address: "0x1111111111111111111111111111111111111111" }), ]); console.log(chainId, balance); // Ausführen mit: 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 // Ausführen mit: 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> { 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(()) } ``` 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](#common-errors) 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](https://blockvectra.com/de/pricing/) für aktuelle Preise. Die vollständige Tabelle der Methodengewichte und Fehlercodes finden Sie in der [API-Referenz → JSON-RPC](https://docs.blockvectra.com/de/api/json-rpc/) — diese Seite behandelt lediglich den Aufbau einer Anfrage. #### Häufige Fehler | Ihre Aktion | Rückmeldung | Maßnahme | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | Unbekannte oder noch nicht öffentliche Chain | HTTP `404` mit JSON-Body `error.data.reason: "unknown_chain"` | Chain-Namen in der URL prüfen | | Anfrage ohne Chain-Segment (z. B. `/v1` oder `/v1/`) | HTTP `404` mit leerem Body | Chain-Namen in die URL einfügen (`/v1/{chain}`) | | API-Schlüssel fehlt, ist unbekannt oder deaktiviert | HTTP `401`, JSON-RPC-Code `-32024` (`missing_api_key` oder `invalid_api_key`) | Gültigen, aktiven API-Schlüssel verwenden (neu erstellte oder rotierte Schlüssel werden innerhalb von ca. 5 Sekunden auf allen Instanzen wirksam; während dieser Zeit können sie 401 `invalid_api_key` zurückgeben oder 503 `-32021` (mit `Retry-After`), wenn der Abrechnungsstatus vorübergehend nicht bestätigt werden kann; warten Sie einen Moment und versuchen Sie es erneut) | | Guthaben ist null oder negativ | HTTP `402`, JSON-RPC-Code `-32020` | Guthaben aufladen oder auf das kostenlose Auffüllen warten | | Anfragen zu schnell gesendet (Rate Limit oder temporäre Überlastung) | HTTP `429` (oder `200`), JSON-RPC-Code `-32005` | Später erneut versuchen (`Retry-After` beachten, sofern vorhanden) | | Einzelne Anfrage oder Batch überschreitet Schlüssel-Burst-Kapazität (`burst_cu`, Standard 1,600 CU; Standardrate 400 CU/s) oder Batch im kostenlosen Tarif überschreitet Aufrufe/s (25 Aufrufe/s) | HTTP `429`, JSON-RPC-Code `-32022` (`request_exceeds_burst`) | Anfrage in kleinere Batches aufteilen (kann in der gesendeten Form niemals erfolgreich sein) | | Upstream-Node ist vorübergehend nicht verfügbar | HTTP `200`, JSON-RPC-Code `-32603` (`upstream unavailable`), wird nicht abgerechnet | Anfrage wiederholen | | Historischer Status außerhalb des Statusfensters dieser Chain (siehe `state_window_blocks` in `GET /v1/chains`) | HTTP `200`, JSON-RPC-Code `-32011`, wird nicht abgerechnet | Einen neueren Block abfragen | | Transaktion oder Block nicht gefunden, oder Antwort zu groß; auf Ethereum geben Abfragen von Blöcken / Receipts / Logs außerhalb des aktuellen Fensters ebenfalls -32000 "old data not available due to pruning" zurück (wird nicht abgerechnet; siehe [Unterstützte Chains → Ethereum](https://docs.blockvectra.com/de/chains/#ethereum)) | HTTP `200`, JSON-RPC-Code `-32000` | Anfrage anpassen (Hash oder Blocknummer überprüfen; fehlerhafte Trace-Hashes geben „Transaktion nicht gefunden“ zurück) | | Tracer nicht zulässig oder Trace-Timeout nicht zulässig (`debug_trace`-Aufrufe) | HTTP `200`, JSON-RPC-Code `-32602`, wird nicht abgerechnet | Zulässigen nativen Tracer (`callTracer`, `flatCallTracer`, `prestateTracer`, `4byteTracer`, `noopTracer` oder weglassen) und Timeout ≤ 30s verwenden | | Eine Methode, die von der Methodenliste der Chain nicht zugelassen ist (siehe [Unterstützte Chains](https://docs.blockvectra.com/de/chains/)) | HTTP `200`, JSON-RPC-Code `-32601`, wird nicht abgerechnet | Nur Methoden aufrufen, die die Chain erlaubt | | Ungültiger JSON-Body | HTTP `200`, JSON-RPC-Code `-32700`, wird nicht abgerechnet | JSON-Syntax der Anfrage korrigieren | | Mehr als 100 Aufrufe in einem Batch | HTTP `200`, JSON-RPC-Code `-32600` (`batch too large`), wird nicht abgerechnet | Den Batch auf maximal 100 Aufrufe aufteilen | 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](https://docs.blockvectra.com/de/api/json-rpc/#error-codes)). ### 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** ```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); // Ausführen mit: 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" } } ``` 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** ```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); // Ausführen mit: 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" } } ``` *(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** ```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); // Ausführen mit: 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" } } ``` 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](https://docs.blockvectra.com/de/api/data/). ### Weiterführende Dokumentation * [API-Referenz → JSON-RPC](https://docs.blockvectra.com/de/api/json-rpc/) — Methoden, CU-Gewichte, Fehlercodes * [Vollständige JSON-RPC-Referenz](https://docs.blockvectra.com/de/api/json-rpc/reference/) — Vollständige Spezifikationen, Parameter und Rückgabeschemata für alle unterstützten Methoden * [API-Referenz → Data API](https://docs.blockvectra.com/de/api/data/) — REST-Endpunkte für Chain-Daten * [Datensätze](https://docs.blockvectra.com/de/datasets/) — Abgeleitete Datensätze über alle unterstützten Chains hinweg * [Anleitungen](https://docs.blockvectra.com/de/guides/) — Praktische Anleitungen zur API-Integration, CU-Verwaltung und für Multi-Chain-Workflows * [Unterstützte Chains](https://docs.blockvectra.com/de/chains/) — Netzwerk-IDs und Endpunkt-URLs ## FAQ ### Welche Chains werden unterstützt? 9 Chains werden unterstützt: Arbitrum One, Base, BNB Smart Chain, Ethereum, Ethereum Sepolia, HyperEVM, Polygon, Robinhood Chain, Robinhood Chain Testnet. Die Liste folgt GET /v1/chains und wird aktualisiert, sobald neue Chains verfügbar sind. Den aktuellen Status finden Sie auf der [Statusseite](https://blockvectra.com/de/status/). [Unterstützte Chains ansehen](https://blockvectra.com/de/chains/) ### Wird WebSocket unterstützt? Der Aufruf von eth_subscribe über HTTP liefert -32601; auf Chains, bei denen ws in /v1/chains true ist, ist eth_subscribe über WebSocket verfügbar. Andernfalls fragen Sie eth_getLogs per Polling ab. [Unterstützte Chains ansehen](https://blockvectra.com/de/chains/) ### Kann ich historische Zustände und Traces abfragen? Ja, dies variiert jedoch je nach Chain. Das Fenster für historische Zustände entspricht dem Feld state_window_blocks von /v1/chains (null bedeutet vollständige Historie); ob Traces verfügbar sind, hängt davon ab, ob methods.allow für diese Chain debug_trace-Methoden (wie debug_traceTransaction) enthält; die maximale Blockspanne für eine einzelne eth_getLogs-Anfrage ist max_logs_block_range. [Das Chain-Verzeichnis und Parameter pro Chain ansehen](https://blockvectra.com/de/chains/) ### Kann ein API-Schlüssel für alle Chains verwendet werden? Ja. Ein API-Schlüssel funktioniert für JSON-RPC auf jeder unterstützten Chain und für die Data API auf Chains, die diese anbieten; ein Schlüssel gehört zum Konto, nicht zu einer bestimmten Chain. [Leitfaden „Ein Schlüssel, viele Chains“ lesen](https://docs.blockvectra.com/en/guides/one-key-many-chains/)