# Blockchain-RPC und Dokumentations-MCP für KI-Agenten

> Source: https://docs.blockvectra.com/de/guides/ai-agents/

Beginnen Sie mit dem schlüssellosen [Docs-MCP-Endpunkt](https://docs.blockvectra.com/mcp), um Blockchain-RPC-Methoden, Data-API-Datensätze, Preise und Dokumentation zu erkunden. KI-Agenten sind First-Class-Nutzer: Entwickler und KI-Agenten nutzen dieselben APIs, Regeln, Limits und Preise.

1. **Erkunden**: Verwenden Sie Docs-MCP, `llms.txt`, OpenAPI und öffentliches JSON, um eine Chain und Methode auszuwählen. Schlüssellose RPC-Aufrufe sind auf die `public.methods` der jeweiligen Chain beschränkt.
2. **Konto über HTTP erstellen**: Folgen Sie der [programmatischen Registrierung](https://docs.blockvectra.com/de/guides/programmatic-signup/), um sich per Wallet-Signatur anzumelden und einen API key zu erstellen. Das MCP-Tool `how_to_get_api_key` liefert Anweisungen für diesen separaten HTTP-Ablauf.
3. **Data APIs aufrufen**: Speichern Sie den Key in `BLOCKVECTRA_API_KEY` und nutzen Sie ihn für authentifizierte RPC- oder Data-API-Anfragen. Konfigurieren Sie für Tools mit Key-Pflicht im MCP-Client den Header `x-api-key`; die zulässigen Operationen der einzelnen Tools sind unten aufgeführt.

## 1. Maschinenlesbarer Kontext und Spezifikationen

BlockVectra veröffentlicht Dateien speziell für LLM-Agenten und Entwickler-Tools:

### llms.txt-Indizes

Gemäß der [llmstxt.org](https://llmstxt.org)-Konvention bieten diese Dateien Agenten eine strukturierte Übersicht über die Website und ihre Endpunkte:

* **Hauptseiten-Index**: [llms.txt der Website](https://blockvectra.com/llms.txt) — Übersicht über die Hauptseite, unterstützte Chains, Preise und öffentliche APIs.
* **Dokumentations-Index**: [llms.txt der Dokumentation](https://docs.blockvectra.com/llms.txt) — Katalog jeder Dokumentationsseite mit Titel und Beschreibung.

### Vollständige Dokumentationsdatei (`llms-full.txt`)

* **Vollständige Dokumentation**: [llms-full.txt](https://docs.blockvectra.com/llms-full.txt) — Der vollständige Text jeder englischen Dokumentationsseite in einer einzigen reinen Markdown-Textdatei, geeignet zum Laden in den System-Prompt eines Agenten oder zum Einpflegen in eine Retrieval-Augmented Generation (RAG)-Pipeline.

### Herunterladbare OpenAPI 3.1-Spezifikationen

Die Dokumentationsseite stellt OpenAPI 3.1-YAML-Dateien bereit, die direkt in Agent-Frameworks, Tool-Generatoren oder API-Clients importiert werden können:

* **JSON-RPC-API-Spezifikation**: [/openapi/json-rpc.yaml](https://docs.blockvectra.com/openapi/json-rpc.yaml) — Unterstützte Methoden, chainspezifische Methodenrichtlinien, Fehlerantworten und Compute Unit-Messung.
* **Data-API-Spezifikation**: [/openapi/data.yaml](https://docs.blockvectra.com/openapi/data.yaml) — REST-Endpunktdefinitionen für indexierte Blöcke, Transaktionen, Transfers, Guthaben, Token-Inhaber und zugehörige Datensätze.
* **Push-API-Spezifikation**: [/openapi/push.yaml](https://docs.blockvectra.com/openapi/push.yaml) — Verwaltung von HTTP-Abonnements, beobachtete Wallet-Adressen, Webhook-Events, Signaturen und Replay.

Für Aktivitäten von Wallet-Adressen folgen Sie dem [Blockchain-Webhook-API-Leitfaden](https://docs.blockvectra.com/de/guides/webhook-push/). Für Benachrichtigungen zu ERC-20 USDT / USDC-Zahlungen nutzen Sie das [Zahlungsempfänger-Beispiel](https://docs.blockvectra.com/de/guides/stablecoin-payments/#receive-payments-with-webhooks). Entwickler und KI-Agenten erstellen und verwalten Abonnements über die HTTP-Push-API mit `x-api-key`; das Docs-MCP ermöglicht das Erkunden und Lesen dieser Leitfäden.

Hinweise zu Pfadversionierung, Abwärtskompatibilitätsregeln und Empfehlungen für Agenten und SDK-Autoren finden Sie unter [API-Versionierung und Kompatibilität](https://docs.blockvectra.com/de/api/versioning/). Vorgefertigte Rezepte für gängige Frameworks (ElizaOS, viem, wagmi, Coinbase AgentKit) finden Sie unter [Rezepte für Agent-Frameworks](https://docs.blockvectra.com/de/guides/agent-frameworks/).

### Model Context Protocol (MCP)-Server

BlockVectra stellt einen zustandslosen, schlüssellosen MCP-Server über Streamable HTTP bereit:

* **Endpunkt**: [MCP-Endpunkt](https://docs.blockvectra.com/mcp) (HTTP POST nimmt JSON-RPC 2.0 entgegen; GET gibt 405 zurück)
* **Transport**: MCP Streamable HTTP (zustandslos, kein API key erforderlich)

#### Verfügbare Tools

1. `read_doc(path, lang?)`: Gibt den rohen Markdown-Inhalt für jede Dokumentationsseite von `/md/{lang}/{path}.md` zurück. Akzeptiert interne relative Pfade (z. B. `quickstart`, `guides/ai-agents`, `api/json-rpc`, `chains`).
2. `search_docs(query, lang?, limit?)`: Durchsucht Dokumentationsseiten nach Titeln, Pfaden und Zusammenfassungen.
3. `list_chains()`: Liest unterstützte Blockchain-Netzwerke, statische Parameter und Methodenrichtlinien aus `GET /v1/chains`.
4. `get_status()`: Liest die Live-Dienstbereitschaft, den Netzwerkstatus, die neuesten Blockhöhen und den Synchronisations-Lag aus `GET /v1/status`.
5. `get_pricing()`: Liest Compute Unit (CU)-Gewichtungen, Parameter des kostenlosen Tarifs und Standard-Key-Limits aus `GET /v1/plans`.
6. `estimate_usage(lines?, method?, calls_per_day?)`: Schätzt Compute Units (CU), Bruttolistenkosten und Nettokosten nach Abzug des kostenlosen Zyklus-Kontingents für eine oder mehrere Methoden (unterstützt mehrzeiliges `lines: [{method, calls_per_day}]` oder einzelne `method` und `calls_per_day`). Gibt zudem Rate-Limits pro Key aus `key_defaults` an und schlägt die Anzahl der benötigten API keys vor, wenn der Datenverkehr die Limits eines einzelnen Keys übersteigt.
7. `how_to_get_api_key(lang?)`: Gibt Schritte zur Übergabe von API keys und Anforderungsauthentifizierungsformate für JSON-RPC und Data API zurück.
8. `get_method_info(method, chain?)`: Gibt die Chain-Verfügbarkeit, die Compute Unit (CU)-Gewichtung, den Preis pro Million Aufrufe und den Dokumentationslink für eine Methode zurück. Die JSON-RPC-Verfügbarkeit folgt `methods.allow` und `deny` in `GET /v1/chains`; die Data-API-Datensatzabdeckung folgt `data_features` in `GET /v1/status` mit `data: true` im Chain-Katalog.
9. `explain_error(reason?, code?, http_status?)`: Sucht Erklärungen zu Fehlern, Auswirkungen auf die Abrechnung, Wiederholbarkeit und Wiederherstellungsmaßnahmen im Fehlerkatalog nach.
10. `list_docs(lang?)`: Listet alle Dokumentationsseiten mit relativen Pfaden und Titeln aus dem Dokumentationsindex auf.
11. `rpc_call(chain, method, params?)`: Führt einen schreibgeschützten JSON-RPC 2.0-Aufruf auf einer unterstützten Chain mit Ihrem API key aus (`readOnlyHint: true`). Schreibmethoden (wie `eth_sendRawTransaction`) werden abgewiesen; verwenden Sie stattdessen `send_raw_transaction`. Erfordert den `x-api-key`-Header in der MCP-Client-Konfiguration für vollen Zugriff oder nutzt den schlüssellosen öffentlichen Endpunkt, sofern verfügbar.
12. `data_api_get(chain, path, query?)`: Führt eine GET-Anfrage an die Data API für eine unterstützte Chain und einen Pfad mit Ihrem API key aus (`readOnlyHint: true`). Erfordert den `x-api-key`-Header in der MCP-Client-Konfiguration.
13. `get_account()`: Fragt Kontoguthaben, Compute Units (CU), Rate-Limits und Key-Parameter aus `GET /v1/account` mit Ihrem API key ab (`readOnlyHint: true`). Erfordert den `x-api-key`-Header in der MCP-Client-Konfiguration.
14. `get_deposit_address()`: Fragt die dedizierte On-Chain-Einzahlungsadresse, offene Netzwerke und Token aus `GET /v1/topup/deposit-address` mit Ihrem API key ab (`readOnlyHint: true`). Transferieren Sie Mittel nur an die aufgeführten Netzwerke und Token. Erfordert den `x-api-key`-Header in der MCP-Client-Konfiguration.
15. `send_raw_transaction(chain, raw_tx)`: Sendet eine signierte Raw-Transaktion über `eth_sendRawTransaction` an eine unterstützte Chain (`destructiveHint: true`). Erfordert den `x-api-key`-Header in der MCP-Client-Konfiguration für vollen Zugriff oder nutzt den schlüssellosen öffentlichen Endpunkt, sofern auf der Chain erlaubt.

#### Tools mit Key-Pflicht

Tools mit Key-Pflicht erfordern einen API key, um On-Chain-Abfragen, Transaktionen, Data-API-Anfragen oder Kontooperationen auszuführen.

**Sicherheit des API keys**:

* **Ausschließlich aus Headern lesen**: Der API key wird ausschließlich aus den HTTP-Request-Headern des MCP-Clients ausgelesen (`x-api-key: rgw_...` oder `Authorization: Bearer rgw_...`).
* **Keys niemals in den Chat einfügen**: Übergeben Sie API keys oder private Schlüssel niemals in Tool-Argumenten und fügen Sie sie keinesfalls in den Chat ein. Tool-Argumente und Chatverläufe gelangen in Konversationsprotokolle und Kontexte; die Übergabe von Keys in Argumenten wird abgewiesen.

Beim Aufruf ohne API-Key-Header geben diese Tools `isError: true` zurück und verweisen den Agenten auf `how_to_get_api_key` und den Leitfaden zur programmatischen Registrierung.

### Verbindung von MCP-Clients

Sie können über gängige Entwicklungsumgebungen und Frameworks eine Verbindung zum BlockVectra-Dokumentations-MCP-Server unter `https://docs.blockvectra.com/mcp` herstellen.

Beginnen Sie ohne API key. Verbinden Sie sich mit dem MCP-Endpunkt, rufen Sie list\_chains auf und lesen Sie anschließend den Schnellstart mit read\_doc. Fügen Sie einen API key in die HTTP-Header Ihres Clients ein, sobald Sie Data API- oder Konto-Tools benötigen. Der schlüssellose RPC-Zugriff folgt den Richtlinien für öffentliche Methoden der jeweiligen Chain.

Der `x-api-key`-Header ist optional. Ohne API key können Clients alle lesenden Dokumentations-Tools (`read_doc`, `search_docs`, `list_docs`), Chain-Erkennung (`list_chains`), Live-Status (`get_status`), Preisschätzung (`get_pricing`, `estimate_usage`), Fehlererklärungen (`explain_error`) und auf öffentlichen Endpunkten erlaubte Methoden nutzen. Bei Verwendung von Tools mit Key-Pflicht (`rpc_call` auf eingeschränkten Methoden, `send_raw_transaction`, `data_api_get`, `get_account` und `get_deposit_address`) konfigurieren Sie den `x-api-key`-Header mit Ihrem API key.

#### Claude Code

Verbinden Sie sich über die CLI mit dem MCP-Server:

```bash
claude mcp add --transport http blockvectra-docs https://docs.blockvectra.com/mcp
```

Um einen optionalen API key für authentifizierte Tools einzubinden, übergeben Sie die Option `--header` (oder `-H`):

```bash
claude mcp add --transport http blockvectra-docs https://docs.blockvectra.com/mcp \
  --header "x-api-key: YOUR_API_KEY"
```

Offizielle Dokumentation: [Claude Code MCP documentation](https://code.claude.com/docs/en/mcp).

#### Cursor

Fügen Sie den Server zur MCP-Konfiguration von Cursor hinzu:

```json
{
  "mcpServers": {
    "blockvectra": {
      "url": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Cursor unterstützt auch die 1-Klick-Installation über Deep Links unter Verwendung der Base64-codierten Konfiguration `eyJ1cmwiOiJodHRwczovL2RvY3MuYmxvY2t2ZWN0cmEuY29tL21jcCJ9` (entspricht `{"url":"https://docs.blockvectra.com/mcp"}`):

```text
cursor://anysphere.cursor-deeplink/mcp/install?name=blockvectra&config=eyJ1cmwiOiJodHRwczovL2RvY3MuYmxvY2t2ZWN0cmEuY29tL21jcCJ9
```

Wenn Sie authentifizierte Tools (Data API oder Kontoverwaltung) benötigen, fügen Sie das `headers`-Objekt mit Ihrem API key hinzu:

```json
{
  "mcpServers": {
    "blockvectra": {
      "url": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

Offizielle Dokumentation: [Cursor MCP documentation](https://cursor.com/docs/context/mcp) und [Cursor install links](https://cursor.com/docs/context/mcp/install-links).

#### VS Code

Konfigurieren Sie den Server in VS Code in `.vscode/mcp.json` unter dem Root-Schlüssel `servers` mit `type: "http"`:

```json
{
  "servers": {
    "blockvectra": {
      "type": "http",
      "url": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Wenn Sie authentifizierte Tools benötigen, fügen Sie das `headers`-Objekt hinzu:

```json
{
  "servers": {
    "blockvectra": {
      "type": "http",
      "url": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

Beim Speichern vertraulicher Zugangsdaten unterstützt VS Code den Verweis auf Eingabevariablen oder Umgebungsdateien, anstatt Keys fest im Code zu hinterlegen. Sie können Server auch über die Befehlspalette mit der Aktion `MCP: Add Server` hinzufügen.

Offizielle Dokumentation: [VS Code MCP servers documentation](https://code.visualstudio.com/docs/copilot/customization/mcp-servers) und [VS Code MCP configuration reference](https://code.visualstudio.com/docs/agents/reference/mcp-configuration).

#### Codex

Fügen Sie den Server über die OpenAI Codex CLI hinzu:

```bash
codex mcp add blockvectra --url https://docs.blockvectra.com/mcp
```

Konfigurieren Sie in `config.toml` die Server-URL:

```toml
[mcp_servers.blockvectra]
url = "https://docs.blockvectra.com/mcp"
```

Wenn Sie authentifizierte Tools benötigen, konfigurieren Sie Request-Header in `config.toml`:

```toml
[mcp_servers.blockvectra]
url = "https://docs.blockvectra.com/mcp"
http_headers = { "x-api-key" = "YOUR_API_KEY" }
```

Alternativ können Sie den Header aus einer Umgebungsvariablen mappen:

```toml
[mcp_servers.blockvectra]
url = "https://docs.blockvectra.com/mcp"
env_http_headers = { "x-api-key" = "BLOCKVECTRA_API_KEY" }
```

Offizielle Dokumentation: [OpenAI Codex CLI MCP documentation](https://learn.chatgpt.com/docs/extend/mcp?surface=cli).

#### Gemini CLI

Fügen Sie den Server in der Konfiguration der Gemini CLI unter `mcpServers` mit `httpUrl` für Streamable HTTP hinzu:

```json
{
  "mcpServers": {
    "blockvectra": {
      "httpUrl": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Wenn Sie authentifizierte Tools benötigen, fügen Sie das `headers`-Objekt mit Ihrem API key hinzu:

```json
{
  "mcpServers": {
    "blockvectra": {
      "httpUrl": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

Offizielle Dokumentation: [Gemini CLI MCP server documentation](https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md).

#### OpenAI Responses API

Wenn Sie die OpenAI Responses API aufrufen, übergeben Sie den MCP-Server im Array `tools` mit `type: "mcp"`:

```bash
OPENAI_API_BASE="https://api.openai.com/v1"
curl "$OPENAI_API_BASE/responses" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<model>",
    "tools": [{
      "type": "mcp",
      "server_label": "blockvectra",
      "server_url": "https://docs.blockvectra.com/mcp",
      "require_approval": "never"
    }],
    "input": "..."
  }'
```

Wenn Sie authentifizierte Tools benötigen, binden Sie das Feld `headers` in die Tool-Definition ein:

```json
{
  "type": "mcp",
  "server_label": "blockvectra",
  "server_url": "https://docs.blockvectra.com/mcp",
  "headers": { "x-api-key": "YOUR_API_KEY" },
  "require_approval": "never"
}
```

Offizielle Dokumentation: [OpenAI MCP tools guide](https://developers.openai.com/api/docs/guides/tools-connectors-mcp) und [OpenAI Responses API reference](https://developers.openai.com/api/reference/resources/responses/methods/create).

#### Windsurf

Konfigurieren Sie den Server in Windsurf unter `mcpServers` über das Feld `serverUrl`:

```json
{
  "mcpServers": {
    "blockvectra": {
      "serverUrl": "https://docs.blockvectra.com/mcp"
    }
  }
}
```

Wenn Sie authentifizierte Tools benötigen, fügen Sie das `headers`-Objekt mit Ihrem API key hinzu:

```json
{
  "mcpServers": {
    "blockvectra": {
      "serverUrl": "https://docs.blockvectra.com/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

Windsurf unterstützt zudem das Verweisen auf Umgebungsvariablen wie `"x-api-key": "${env:BLOCKVECTRA_API_KEY}"`.

Offizielle Dokumentation: [Windsurf MCP documentation](https://docs.devin.ai/desktop/cascade/mcp).

#### Claude Desktop und claude.ai

Benutzerdefinierte Connectors werden über die Benutzeroberfläche konfiguriert:

* **claude.ai**: Navigieren Sie zu **Customize** > **Connectors**, klicken Sie auf **+ Add**, wählen Sie **Add custom connector** und geben Sie die URL ein:
  ```text
  https://docs.blockvectra.com/mcp
  ```
* **Claude Desktop**: Öffnen Sie das Kontoeinstellungsmenü und konfigurieren Sie benutzerdefinierte Connectors über die Connectors-Oberfläche.

Die Verbindung mit der URL ermöglicht es Claude, Anleitungen zu durchsuchen, Markdown-Dokumentationen zu lesen, unterstützte Chains zu prüfen, den Netzwerkstatus einzusehen und Preisschätzungen ohne Anmeldedaten zu berechnen.

Offizielle Dokumentation: [Claude custom connectors guide](https://support.claude.com/en/articles/11175166-getting-started-with-custom-connectors-using-remote-mcp).

## 2. Öffentliche JSON-Endpunkte (kein Key erforderlich)

Ein Agent kann verfügbare Chains, den Live-Status und Tarifparameter prüfen, bevor er eine abgerechnete Anfrage sendet. Keiner dieser Endpunkte benötigt einen API key:

* `GET /v1/status` und `GET /v1/chains` sind unauthentifiziert und kostenlos.
* `GET /v1/plans` ist öffentlich und unauthentifiziert.

Alle drei senden `Access-Control-Allow-Origin: *`.

### Dienststatus (`GET /v1/status`)

Gibt die Bereitschaft des Dienstes und den Synchronisationsstatus jeder öffentlichen Chain zurück:

```bash
curl -s "https://api.blockvectra.com/v1/status"
```

Antwortfelder:

* `checked_at`: Zeitpunkt, zu dem der Snapshot erstellt wurde (RFC 3339 / ISO 8601 UTC).
* `gateway.status`: Betriebsbereitschaft des Dienstes. `ok` bedeutet, dass der Dienst bereit ist; `degraded` bedeutet, dass kostenpflichtige Anfragen abgelehnt werden, bis er sich erholt hat. Dieser Wert ist unabhängig vom Node-Status einzelner Chains.
* `chains[]`: Öffentlich bereitgestellte Chains:
  * `chain`: Chain-Slug (z. B. `robinhood_mainnet`).
  * `name`: Lesbarer Anzeigename.
  * `chain_id`: EIP-155 Chain-ID (Dezimal-Integer).
  * `jsonrpc`: Ob JSON-RPC bereitgestellt wird.
  * `data`: Ob die Data API bereitgestellt wird.
  * `data_features`: Für diese Chain verfügbare Data-API-Funktionen (leeres Array, wenn `data` auf `false` steht).
  * `data_status`: Betriebsbereitschaft der Data API (`ok`, `syncing` oder `unavailable`; nur vorhanden, wenn `data` auf `true` steht).
  * `status`: Node-Status der Chain (`ok` oder `unavailable`).
  * `head`: Neueste Blockinformationen — `block` (neueste Blockhöhe), `time` (Block-Zeitstempel) und `lag_seconds` (wie weit die Blockzeit hinter der aktuellen Zeit zurückliegt) — oder `null`, falls unbekannt.

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

### Chain-Parameter (`GET /v1/chains`)

Gibt die statischen Parameter und Methodenrichtlinien jeder öffentlichen Chain zurück:

```bash
curl -s "https://api.blockvectra.com/v1/chains"
```

Antwortfelder:

* `chains[]`: Öffentliche Chains und ihre statischen Parameter:
  * `chain`: Chain-Slug.
  * `name`: Lesbarer Anzeigename.
  * `chain_id`: EIP-155 Chain-ID.
  * `jsonrpc`: Ob JSON-RPC bereitgestellt wird.
  * `data`: Ob die Data API bereitgestellt wird.
  * `ws`: Ob WebSocket-Verbindungen unterstützt werden.
  * `subscriptions`: Unterstützte WebSocket-Abonnementtypen (z. B. `newHeads`, `logs`).
  * `methods`: Methodenrichtlinie:
    * `allow`: Erlaubte Methodennamen (z. B. `eth_call`, `debug_traceTransaction`).
    * `deny`: Untersagte Methoden oder Präfix-Wildcard-Muster (z. B. `eth_newFilter`). Untersagte Methoden haben Vorrang vor erlaubten.
  * `max_logs_block_range`: Maximale Blockspanne, die in einer einzelnen `eth_getLogs`-Anfrage zulässig ist.
  * `state_window_blocks`: Historisches State-Fenster in Blöcken; `null`, wenn die vollständige Historie verfügbar ist.
  * `info`: Chainspezifische öffentliche Erweiterungsdaten (reserviert; derzeit ein leeres Objekt `{}`).
  * `public`: Konfiguration des unauthentifizierten öffentlichen Endpunkts (oder `null`):
    * `url`: Basis-URL für öffentliche Anfragen.
    * `methods`: Auf dem öffentlichen Endpunkt zulässige Methoden.
    * `rate_limit`: Rate-Limits (`per_ip_rps`, `burst`, `batch_max`).
    * `history_blocks`: Über den öffentlichen Endpunkt zugängliche Blockhistorie.
    * `send_raw_rate_limit`: Rate-Limits für das Übertragen von Transaktionen über `eth_sendRawTransaction`.

Beispielantwort:

```json
{
  "chains": [
    {
      "chain": "robinhood_mainnet", "name": "Robinhood Chain", "chain_id": 4663,
      "jsonrpc": true,
      "data": true,
      "ws": true,
      "subscriptions": [
        "newHeads",
        "logs"
      ],
      "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,
      "info": {},
      "public": {
        "url": "https://api.blockvectra.com/v1/robinhood_mainnet/public",
        "methods": [
          "eth_chainId",
          "net_version",
          "eth_blockNumber",
          "eth_call"
        ],
        "rate_limit": {
          "per_ip_rps": 3,
          "burst": 20,
          "batch_max": 10
        },
        "history_blocks": 128,
        "send_raw_rate_limit": {
          "per_ip_rps": 1,
          "burst": 3
        }
      }
    }
  ]
}
```

### Tarife und Methodengewichte (`GET /v1/plans`)

Tarifparameter werden unter `GET https://console-api.blockvectra.com/v1/plans` bereitgestellt. Ein Agent kann diesen Endpunkt zur Laufzeit abfragen, um die aktiven Limits des kostenlosen Tarifs und das Compute Unit (CU)-Gewicht jeder Methode auszulesen:

* `free`: Parameter des kostenlosen Tarifs — `signup_units` (Registrierungsguthaben in Einheiten), `monthly_units` (Zyklus-Auffüllgrenze in Einheiten), `window_days` (Nutzungszykluslänge in Tagen) und `max_calls_per_sec` (sekündliches Aufruflimit im Free-Tarif).
* `pricing`: Parameter für kostenpflichtige Tarife — `units_per_usd` (Einheiten pro 1 USD), `cu_per_unit` (CU pro Einheit) und `min_topup_usd` (Mindestaufladung in USD).
* `method_weights`: CU-Gewichte pro Aufruf, jeweils `{ "method": string, "cu_weight": number }`. `method` gibt den JSON-RPC-Methodennamen oder ein Muster an, Standardgewichte für nicht aufgeführte Methoden oder eine Data-API-Operation wie `data.<op>`. Die Gewichte gelten pro Methode und werden nicht nach Chains aufgeteilt.

## 3. Authentifizierung und Key-Sicherheit

Agenten, die RPC-Aufrufe absetzen, müssen folgende Regeln einhalten:

* **Authentifizierung**: Übergeben Sie den API key auf eine von drei Arten: Im Pfad: `POST /v1/{chain}/{api_key}` — die Pfadform verwendet ausschließlich den Key im Pfad und ignoriert beide Header. Im `x-api-key`-Header: `POST /v1/{chain}` mit `x-api-key: $BLOCKVECTRA_API_KEY`. Im `Authorization`-Header: `POST /v1/{chain}` mit `Authorization: Bearer $BLOCKVECTRA_API_KEY`. Wenn beide Header vorhanden sind, hat ein nicht-leerer `x-api-key` Vorrang; Bearer wird nur verwendet, wenn `x-api-key` fehlt oder leer ist. Derselbe Key funktioniert auf jeder unterstützten Chain und auf der Data API (die den Key ausschließlich im `x-api-key`-Header akzeptiert).
* **Key-Sicherheit**: Speichern Sie API keys in serverseitigen Umgebungsvariablen (z. B. `BLOCKVECTRA_API_KEY`) oder einem Secrets Manager. Betten Sie einen Key niemals in Browser-Code oder clientseitige Bundles ein. Die Endpunkte geben zwar `Access-Control-Allow-Origin: *` zurück, sind jedoch für den Aufruf durch Backend-Dienste und nicht aus dem Browser gedacht.
* **Messung und Upgrades**: Die Nutzung wird in Compute Units (CU) gemessen: Jede Methode verbraucht CU entsprechend ihrem Gewicht, und Guthaben, CU-Buckets sowie Ratenbegrenzungen des Free-Plans werden über alle Chains hinweg geteilt. Nach einer bezahlten Aufladung gilt die Obergrenze für Aufrufe pro Sekunde des Free-Plans nicht mehr; jeder Key behält weiterhin ein CU-Ratenlimit und Burst-Kapazität. Nicht genutzte kostenlose Credits verbleiben in Ihrem Guthaben und können weiter verwendet werden. Details finden Sie auf der [Preisseite](https://blockvectra.com/de/pricing/).

> **Noch kein API key?**
>
> Wenn Sie eine Ethereum-Wallet haben: Folgen Sie dem [Leitfaden zur programmatischen Registrierung](https://docs.blockvectra.com/de/guides/programmatic-signup/), um sich ohne Browser über eine Ethereum-Wallet-Signatur zu registrieren und einen API key zu erstellen. Die Identität eines Agenten ist seine Wallet: Falls ein Session-Token oder Key verloren geht, [authentifizieren Sie sich erneut mit derselben Wallet zur Wiederherstellung](https://docs.blockvectra.com/de/guides/programmatic-signup/#lost-your-session-or-api-key). Wenn Sie keine Wallet haben: Bitten Sie den Benutzer, sich unter [console.blockvectra.com](https://console.blockvectra.com/login/?next=%2Fkeys%2F) anzumelden, einen Key zu erstellen und diesen als Umgebungsvariable `BLOCKVECTRA_API_KEY` festzulegen. Bitten Sie den Benutzer nicht, den Key in den Chat einzufügen.


### Guthaben abfragen (`GET /v1/account`)

Ein Agent kann den aktuellen Kontostand seines Keys, CU-Limits und Key-Parameter direkt prüfen, ohne Compute Units (CU) zu verbrauchen. Das Anfrageformat, Rate-Limits und vollständige Definitionen der Antwortfelder finden Sie unter [Guthaben abfragen: GET /v1/account](https://docs.blockvectra.com/de/guides/billing-rules/#query-balance-get-v1account).

## 4. Chain-Auswahl-Workflow für Agenten

Bevor ein Agent Aufrufe absendet, kann er folgende Schritte durchführen:

1. **Chain und Methodenrichtlinie prüfen**: Rufen Sie `GET /v1/chains` auf, vergewissern Sie sich, dass die Ziel-Chain existiert und `jsonrpc: true` hat und dass die gewünschte Methode in `methods.allow` erlaubt und nicht durch `methods.deny` untersagt ist (Deny hat Vorrang).
2. **Live-Status prüfen**: Rufen Sie `GET /v1/status` auf und vergewissern Sie sich, dass `gateway.status` den Status `ok` hat und der `status` der Ziel-Chain ebenfalls `ok` ist; nutzen Sie `head.lag_seconds`, um zu entscheiden, ob die Chain-Daten für Ihren Anwendungsfall aktuell genug sind. Wenn ein Node einer Chain nicht synchronisiert ist, gibt jede Methode außer `eth_chainId` den JSON-RPC-Fehler `-32010` zurück (HTTP 200, nicht abgerechnet), sodass der Agent warten und es erneut versuchen oder eine andere Chain wählen kann.
3. **Anfrage senden**: `POST /v1/{chain}` mit dem Header `x-api-key` und einem standardmäßigen JSON-RPC-Body.

## 5. Minimales funktionierendes Beispiel

Das folgende Beispiel liest `/v1/chains` aus, um eine Chain zu wählen, die `eth_blockNumber` erlaubt, prüft `/v1/status` und ruft anschließend einmal `eth_blockNumber` auf.

**cURL**

```bash
export BLOCKVECTRA_API_KEY="rgw_your_api_key"

# 1. List public chains and their method policy
curl -s "https://api.blockvectra.com/v1/chains"

# 2. Check the service and per-chain status
curl -s "https://api.blockvectra.com/v1/status"

# 3. Call eth_blockNumber on the chain you selected (e.g. robinhood_mainnet)
curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \
  -H "x-api-key: $BLOCKVECTRA_API_KEY" \
  -H "x-bv-meter: 1" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
```


  **TypeScript**

```typescript
const apiKey = process.env.BLOCKVECTRA_API_KEY;

if (!apiKey) {
  throw new Error("Missing BLOCKVECTRA_API_KEY");
}

type ChainFacts = {
  chain: string;
  jsonrpc: boolean;
  methods: { allow: string[]; deny: string[] };
};

function matches(pattern: string, method: string): boolean {
  if (pattern === "*") return true;
  if (pattern.endsWith("*")) return method.startsWith(pattern.slice(0, -1));
  return pattern === method;
}

// 1. Fetch the public chain directory
const chainsRes = await fetch("https://api.blockvectra.com/v1/chains");
const { chains } = (await chainsRes.json()) as { chains: ChainFacts[] };

// 2. Select a chain that serves JSON-RPC and allows eth_blockNumber
const selected = chains.find(
  (chain) =>
    chain.jsonrpc &&
    !chain.methods.deny.some((pattern) => matches(pattern, "eth_blockNumber")) &&
    chain.methods.allow.some((pattern) => matches(pattern, "eth_blockNumber")),
);

if (!selected) {
  throw new Error("No chain found that allows eth_blockNumber");
}

// 3. Confirm the service and the selected chain are ready
const statusRes = await fetch("https://api.blockvectra.com/v1/status");
const status = await statusRes.json();
const chainStatus = status.chains?.find(
  (chain: { chain: string }) => chain.chain === selected.chain,
);

if (status.gateway?.status !== "ok" || chainStatus?.status !== "ok") {
  throw new Error(`Chain ${selected.chain} is currently unavailable`);
}

// 4. Call eth_blockNumber on the selected chain
const defaultEndpoint = "https://api.blockvectra.com/v1/robinhood_mainnet";
const rpcUrl = `${defaultEndpoint.slice(0, defaultEndpoint.lastIndexOf("/"))}/${selected.chain}`;
const rpcRes = await fetch(rpcUrl, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
    "x-bv-meter": "1",
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "eth_blockNumber",
    params: [],
  }),
});

console.log("Response:", await rpcRes.json());
```


  **Python**

```python
import os
import requests

api_key = os.environ["BLOCKVECTRA_API_KEY"]


def matches(pattern: str, method: str) -> bool:
    if pattern == "*":
        return True
    if pattern.endswith("*"):
        return method.startswith(pattern[:-1])
    return pattern == method


# 1. Fetch the public chain directory
chains = requests.get("https://api.blockvectra.com/v1/chains").json()["chains"]

# 2. Select a chain that serves JSON-RPC and allows eth_blockNumber
selected = next(
    (
        chain
        for chain in chains
        if chain["jsonrpc"]
        and not any(matches(p, "eth_blockNumber") for p in chain["methods"]["deny"])
        and any(matches(p, "eth_blockNumber") for p in chain["methods"]["allow"])
    ),
    None,
)

if selected is None:
    raise RuntimeError("No chain found that allows eth_blockNumber")

# 3. Confirm the service and the selected chain are ready
status = requests.get("https://api.blockvectra.com/v1/status").json()
chain_status = next(
    (c for c in status["chains"] if c["chain"] == selected["chain"]),
    None,
)

if (
    status["gateway"]["status"] != "ok"
    or chain_status is None
    or chain_status["status"] != "ok"
):
    raise RuntimeError(f"Chain {selected['chain']} is currently unavailable")

# 4. Call eth_blockNumber on the selected chain
default_endpoint = "https://api.blockvectra.com/v1/robinhood_mainnet"
rpc_url = f"{default_endpoint.rsplit('/', 1)[0]}/{selected['chain']}"
rpc_response = requests.post(
    rpc_url,
    headers={
        "Content-Type": "application/json",
        "x-api-key": api_key,
        "x-bv-meter": "1",
    },
    json={"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []},
).json()

print("Response:", rpc_response)
```


Eine erfolgreiche Antwort liefert ein standardmäßiges JSON-RPC-Antwortobjekt:

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

Um die CU-Abrechnung pro Anfrage und verbleibende Kontoeinheiten in den Antwort-Headern einzusehen, fügen Sie `x-bv-meter: 1` hinzu. Details zum Header-Verhalten und zu Fehlerfällen finden Sie unter [Antwort-Header für Abrechnung und Guthaben](https://docs.blockvectra.com/de/guides/billing-rules/#http-status-codes-and-billing-rules).

## Nächste Schritte

* [Datensatzverzeichnis durchsuchen](https://blockvectra.com/de/data/), um jeden von BlockVectra indizierten Datensatz einzusehen.
* [Kostenlosen Tarif und Preise ansehen](https://blockvectra.com/de/pricing/#free), um zu prüfen, was Ihr Konto beinhaltet.
* [Leitfaden zur programmatischen Registrierung befolgen](https://docs.blockvectra.com/de/guides/programmatic-signup/), um sich mit einer Wallet-Signatur zu registrieren und einen API key zu erstellen, oder [in der Konsole anmelden](https://console.blockvectra.com/login/?next=%2Fkeys%2F), um einen Key zu erstellen.