# Ein Key, viele Chains: Wechsel eines Beispiels auf eine andere Chain

> Source: https://docs.blockvectra.com/de/guides/one-key-many-chains/

## 1. Ein Key über alle unterstützten Chains hinweg

Derselbe API key funktioniert auf allen unterstützten Chains für JSON-RPC und für die Data API auf Chains, auf denen sie verfügbar ist. Keys gehören zu Ihrem Konto und sind nicht an eine bestimmte Chain gebunden; es ist nicht erforderlich, separate API keys für jedes Netzwerk zu generieren.

Guthaben und Ratenlimits werden über alle Netzwerke sowie über die JSON-RPC-API und die Data API hinweg geteilt; sie werden nicht nach Netzwerken aufgeteilt. Detaillierte Abrechnungsregeln finden Sie auf der [Preisseite](https://blockvectra.com/de/pricing/).

* **Zusammengefasstes Guthaben**: Bezahlte Aufladungen und kostenlose Credits gelten über alle Chains hinweg. Aufrufe auf beliebigen Chains schöpfen aus demselben Kontoguthaben.
* **Zusammengefasste Ratenlimits**: Compute Unit (CU)-Auffüllraten und Burst-Kapazitäten gelten über alle Chains hinweg für einen gegebenen Key. Die Aufruflimits pro Sekunde des kostenlosen Tarifs werden über alle unterstützten Chains zusammengefasst, anstatt pro Chain aufgeteilt zu werden.
* **Upgrade-Pfad**: Nach dem Aufladen unterliegen Sie nicht mehr dem Aufruflimit pro Sekunde des kostenlosen Tarifs; jeder Key unterliegt weiterhin den CU-Raten- und Burst-Limits, wie in der [JSON-RPC-Dokumentation](https://docs.blockvectra.com/de/api/json-rpc/#method-policy) beschrieben.

## 2. URL-Struktur und der Parameter `{chain}`

Jede auf eine Chain bezogene Anfrage gibt ihr Zielnetzwerk im URL-Pfad über `{chain}` an. Der Parameter `{chain}` ist die klein geschriebene Slug-Kennung der Chain (beispielsweise `robinhood_mainnet`).

| Dienst                  | Authentifizierung     | URL-Vorlage                  | Beschreibung                                                                |
| ----------------------- | --------------------- | ---------------------------- | --------------------------------------------------------------------------- |
| JSON-RPC                | Key im URL-Pfad       | `POST /v1/{chain}/{api_key}` | Einfachste Form, geeignet für curl und HTTP-Clients                         |
| JSON-RPC                | Key im Request-Header | `POST /v1/{chain}`           | Key über den Request-Header `x-api-key: {api_key}` übergeben                |
| Data API                | REST-Routen           | `GET /v1/data/{chain}/…`     | Key über den Request-Header `x-api-key: {api_key}` übergeben                |
| Öffentliche Chain-Liste | Unauthentifiziert     | `GET /v1/chains`             | Öffentliche Liste von Chains und statischen Fakten (wird nicht abgerechnet) |
| Öffentlicher Status     | Unauthentifiziert     | `GET /v1/status`             | Aktueller Dienststatus und Chain-Heads (wird nicht abgerechnet)             |

`GET /v1/chains` gibt für jede Chain ein `jsonrpc`- und ein `data`-Flag zurück. Adressieren Sie eine Chain mit den JSON-RPC-URLs, wenn sie JSON-RPC bereitstellt, und mit `GET /v1/data/{chain}/…`, wenn ihr `data`-Flag `true` ist (die Data API bedient nur diese Chains).

> **Tipp**: Wenn Sie Ihren Key über Request-Header übergeben, formatieren Sie die URL so, dass sie mit dem Chain-Namen endet, **ohne** abschließenden Schrägstrich. JSON-RPC wird ausschließlich unter `/v1/{chain}` und `/v1/{chain}/{api_key}` bereitgestellt. Anfragen mit einem abschließenden Schrägstrich (wie `/v1/{chain}/`) oder ohne ein Chain-Segment geben HTTP 404 mit leerem Body zurück. Anfragen an ein unbekanntes `{chain}` geben HTTP 404 mit `error.data.reason: "unknown_chain"` zurück (wird nicht abgerechnet).

## 3. Programmatische Chain-Ermittlung und -Funktionen

Unterstützte Chains und ihre Funktionen werden dynamisch bereitgestellt. Schreiben Sie keine statische Liste von Chains in Ihrer Anwendung fest. Ermitteln Sie stattdessen verfügbare Netzwerke und deren Funktionen zur Laufzeit:

### Statische Fakten über `GET /v1/chains` ermitteln

Dieser öffentliche Endpunkt ist unauthentifiziert und wird nicht abgerechnet. Er gibt alle öffentlich verfügbaren Chains zurück:

```http
GET /v1/chains
```

Beispielantwort:

```json
{
  "chains": [
    {
      "chain": "robinhood_mainnet", "name": "Robinhood Chain", "chain_id": 4663,
      "jsonrpc": true,
      "data": true,
      "methods": {
        "allow": ["eth_blockNumber", "eth_call", "eth_chainId", "debug_traceTransaction"],
        "deny": ["eth_newFilter", "eth_newBlockFilter", "eth_newPendingTransactionFilter", "eth_getFilterLogs", "eth_getFilterChanges", "eth_uninstallFilter", "eth_subscribe", "eth_unsubscribe"]
      },
      "max_logs_block_range": 1000,
      "state_window_blocks": 900
    }
  ]
}
```

Feldbeschreibung:

* `chain`: Slug-Kennung der Chain (wird für `{chain}` in URLs verwendet)
* `name`: Für Menschen lesbarer Anzeigename
* `chain_id`: EIP-155 Chain ID (Dezimalzahl)
* `jsonrpc`: Gibt an, ob JSON-RPC aktiviert ist
* `data`: Gibt an, ob die Data API aktiviert ist
* `methods`: JSON-RPC-Methodenrichtlinie für die Chain, einschließlich `allow` (zulässige Methoden) und `deny` (ausdrücklich verweigerte Methoden)
* `max_logs_block_range`: Maximaler Blockbereich, der in einer einzelnen `eth_getLogs`-Anfrage zulässig ist
* `state_window_blocks`: Historische State-Fenstergröße in Blöcken; `null`, wenn uneingeschränkt

### Betriebsstatus über `GET /v1/status` prüfen

Dieser öffentliche Endpunkt ist unauthentifiziert und wird nicht abgerechnet. Er gibt die Betriebsbereitschaft des Dienstes und Chain-Head-Informationen zurück:

```http
GET /v1/status
```

Beispielantwort:

```json
{
  "checked_at": "2026-09-28T12:00:00Z",
  "gateway": {
    "status": "ok"
  },
  "chains": [
    {
      "chain": "robinhood_mainnet", "name": "Robinhood Chain", "chain_id": 4663,
      "jsonrpc": true,
      "data": true,
      "data_features": ["blocks", "transactions", "address_transactions", "transfers", "token_metadata", "freshness"],
      "status": "ok",
      "head": {
        "block": 73017329,
        "time": "2026-09-28T11:59:58Z",
        "lag_seconds": 2
      }
    }
  ]
}
```

Feldbeschreibung:

* `gateway.status`: Dienststatus (`ok` oder `degraded`)
* `chains[].data_features`: Von der Data API für diese Chain bereitgestellte Funktionen
* `chains[].status`: Node-Betriebsstatus (`ok` oder `unavailable`)
* `chains[].head`: Letzter Block-Head (`block`, `time`, `lag_seconds`)

## 4. Zu beachtende Unterschiede zwischen den Chains

Überprüfen Sie beim Wechsel zwischen Chains die in `GET /v1/chains` bereitgestellten Felder:

1. **Zulässigkeit und Richtlinie von Methoden (`methods.allow` / `methods.deny`)**: Verfügbare JSON-RPC-Methoden variieren je nach Netzwerk gemäß deren Methodenrichtlinie. Das Anfordern einer nicht zulässigen Methode gibt HTTP 200 mit dem JSON-RPC-Fehlercode `-32601` zurück (`method not available`, wird nicht abgerechnet).
2. **Log-Blockbereich (`max_logs_block_range`)**: Maximale Blockspannen für `eth_getLogs`-Abfragen unterscheiden sich je nach Chain. Das Überschreiten des Limits der Chain gibt HTTP 200 mit dem JSON-RPC-Fehlercode `-32602` zurück (`eth_getLogs block range too large`, wird nicht abgerechnet).
3. **Aufbewahrungsfenster für den State (`state_window_blocks`)**: Chains mit vollständiger Historie geben `null` zurück. Auf Chains mit State-Pruning geben historische State-Abfragen außerhalb des Fensters HTTP 200 mit dem JSON-RPC-Fehlercode `-32011` zurück (`historical state is not available beyond the most recent <N> blocks`, wird nicht abgerechnet).
4. **Funktionen und Abdeckung der Data API (`data` / `data_features`)**: Die Chains, die einen Datensatz bereitstellen, sind auf der Seite [Unterstützte Chains](https://docs.blockvectra.com/de/chains/) aufgeführt. Das Abfragen eines Datensatzes, den eine Chain nicht unterstützt, oder eines Blocks vor ihrer indexierten Abdeckung gibt HTTP `422` zurück (`error.code` `no_coverage`, wird nicht abgerechnet). Wenn der Dienst vorübergehend nicht verfügbar ist – beispielsweise wenn eine Chain überlastet ist – geben Anfragen HTTP `503` mit einem `Retry-After`-Header zurück (wird nicht abgerechnet).

## 5. Codebeispiele

Vollständige Starter-Vorlage: [blockvectra/multichain-viem](https://github.com/blockvectra/multichain-viem)

Exakt derselbe Code wird auf verschiedenen Chains ausgeführt, indem die Chain-Variable aktualisiert wird (oder dynamisch aus `GET /v1/chains` ausgelesen wird), wobei `eth_blockNumber` über JSON-RPC und die Aktualität des Datensatzes über die Data API abgefragt werden:

**cURL**

```bash
export BLOCKVECTRA_API_KEY="rgw_your_api_key"

# Change the chain variable to target another chain from Supported Chains
CHAIN="robinhood_mainnet"

# 1. JSON-RPC: Query eth_blockNumber (POST /v1/{chain}, key in the x-api-key header).
RPC_URL="https://api.blockvectra.com/v1/$CHAIN"
curl -s "$RPC_URL" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $BLOCKVECTRA_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'

# 2. Data API: Query dataset freshness (GET /v1/data/{chain}/status/freshness)
curl -s "https://api.blockvectra.com/v1/data/$CHAIN/status/freshness" \
  -H "x-api-key: $BLOCKVECTRA_API_KEY"
```


  **TypeScript**

```ts
// Change this variable to target another chain, or read it dynamically from GET /v1/chains
const chain = "robinhood_mainnet";
const apiKey = process.env.BLOCKVECTRA_API_KEY!;

// 1. JSON-RPC: Call eth_blockNumber (POST /v1/{chain})
const rpcUrl = `https://api.blockvectra.com/v1/${chain}`;
const rpcResponse = await fetch(rpcUrl, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "eth_blockNumber",
    params: [],
  }),
});
const rpcResult = await rpcResponse.json();
console.log(`[${chain}] JSON-RPC blockNumber:`, rpcResult.result);

// 2. Data API: Query freshness (GET /v1/data/{chain}/status/freshness)
const dataUrl = `https://api.blockvectra.com/v1/data/${chain}/status/freshness`;
const dataResponse = await fetch(dataUrl, {
  headers: {
    "x-api-key": apiKey,
  },
});
const dataResult = await dataResponse.json();
console.log(`[${chain}] Data API freshness:`, dataResult.data);
```


  **Python**

```python
import os
import requests

# Change this variable to target another chain, or read it dynamically from GET /v1/chains
chain = "robinhood_mainnet"
api_key = os.environ["BLOCKVECTRA_API_KEY"]

# 1. JSON-RPC: Call eth_blockNumber (POST /v1/{chain})
rpc_url = f"https://api.blockvectra.com/v1/{chain}"
headers = {
    "Content-Type": "application/json",
    "x-api-key": api_key,
}
rpc_payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_blockNumber",
    "params": [],
}
rpc_resp = requests.post(rpc_url, json=rpc_payload, headers=headers)
print(f"[{chain}] JSON-RPC blockNumber:", rpc_resp.json().get("result"))

# 2. Data API: Query freshness (GET /v1/data/{chain}/status/freshness)
data_url = f"https://api.blockvectra.com/v1/data/{chain}/status/freshness"
data_resp = requests.get(data_url, headers={"x-api-key": api_key})
print(f"[{chain}] Data API freshness:", data_resp.json().get("data"))
```


### Beispielantworten

JSON-RPC `eth_blockNumber`-Erfolgsantwort (wird mit dem CU-Gewicht der Methode abgerechnet):

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x45a27f1"
}
```

Data API `GET /v1/data/{chain}/status/freshness`-Erfolgsantwort (wird in CU abgerechnet, nur erfolgreiche 2xx-Antworten werden abgerechnet):

```json
{
  "data": [
    {
      "dataset": "blocks",
      "category": "raw",
      "max_block_number": 72313256,
      "max_day": null,
      "max_time": "2026-09-28T03:41:07Z",
      "seconds_behind": 0,
      "blocks_behind": null,
      "days_behind": null,
      "checked_at": "2026-09-28T03:41:10Z"
    },
    {
      "dataset": "traces",
      "category": "raw",
      "max_block_number": 72313256,
      "max_day": null,
      "max_time": "2026-09-28T03:41:07Z",
      "seconds_behind": 0,
      "blocks_behind": null,
      "days_behind": null,
      "coverage_from_block": 72050949,
      "coverage_to_block": 72313256,
      "coverage_complete": true,
      "checked_at": "2026-09-28T03:41:10Z"
    },
    {
      "dataset": "dex_prices",
      "category": "derived",
      "max_block_number": null,
      "max_day": "2026-09-27",
      "max_time": "2026-09-27T00:00:00Z",
      "seconds_behind": 99667,
      "blocks_behind": null,
      "days_behind": 1,
      "checked_at": "2026-09-28T03:41:10Z"
    }
  ],
  "meta": {
    "chain": "robinhood_mainnet",
    "chain_slug": "ROBINHOOD_MAINNET",
    "chain_external_id": "eip155:4663",
    "as_of_block": 72313256,
    "safe_block": 72313100,
    "finalized_block": 72313000,
    "coverage": "full",
    "refreshed_at": "2026-09-28T03:41:10Z"
  }
}
```

## Nächste Schritte

* [Datensatzverzeichnis durchsuchen](https://blockvectra.com/de/data/), um alle von BlockVectra indexierten Datensätze zu sehen.
* [Kostenlosen Tarif und Preise ansehen](https://blockvectra.com/de/pricing/#free), um zu prüfen, was Ihr Konto beinhaltet.
* [In der Konsole anmelden](https://console.blockvectra.com/login/?next=%2Fkeys%2F), um einen API key zu erstellen.