> ## Documentation Index > Fetch the complete documentation index at: https://docs.venice.ai/llms.txt > Use this file to discover all available pages before exploring further. # Crypto RPC für Agenten > Nutzen Sie Venice sowohl als Modellanbieter als auch als Blockchain-RPC-Layer für autonome KI-Agenten — ein Credential, 230+ Modelle, 11 Chains, kein MetaMask. Venice liefert deinem Agenten Inferenz (230+ Modelle) und Blockchain-Zugriff (10 EVM-Chains plus Starknet) über ein einziges Credential. Dein Agent kann denken, signieren und Transaktionen senden, ohne separate Accounts für Inferenz- und RPC-Provider zu jonglieren. Ein einziger API-Schlüssel (oder eine Wallet) für LLM-Inferenz und JSON-RPC-Aufrufe. Ethereum, Base, Arbitrum, Optimism, Polygon, Linea, Avalanche, BSC, Blast, zkSync Era und Starknet (Mainnet plus Testnets). Stake VVV auf Base, um täglich DIEM zu verdienen – der einzige vollständig headless-fähige Funding-Pfad für einen ausgestellten API-Schlüssel. USD- und Crypto-Top-ups stehen ebenfalls über das Dashboard zur Verfügung. Agenten können sich per Wallet-Signatur authentifizieren und in USDC auf Base oder Solana zahlen. ## Warum Venice für On-Chain-Agenten? | Fähigkeit | Was dein Agent bekommt | | --------------------- | ----------------------------------------------------------------------------------------------- | | **Inferenz** | 230+ Text-, Image-, Video-, Audio- und Embedding-Modelle über einen OpenAI-kompatiblen Endpoint | | **Crypto RPC** | JSON-RPC-2.0-Proxy zu 10 EVM-Chains plus Starknet (Mainnet und Testnets) | | **Authentifizierung** | Standard-API-Schlüssel oder x402-Wallet-Auth (kein Venice-Konto erforderlich) | | **Funding** | Autonom: VVV-Staking für täglich DIEM. Browser: USD- oder Crypto-Top-ups über das Dashboard | | **Batching** | Bis zu 100 JSON-RPC-Aufrufe pro Anfrage, Multi-Chain parallel | | **Idempotenz** | Sichere Retries mit `Idempotency-Key`-Header | ## Authentifizierung Wähle die Auth-Methode, die zu deinem Agent-Betrieb passt. | Methode | Geeignet für | Wie es funktioniert | | ----------------- | ----------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **API-Schlüssel** | Serverseitige Agenten, feste Deployments | Header `Authorization: Bearer `. Schlüssel unter [venice.ai/settings/api](https://venice.ai/settings/api) erhalten. | | **x402-Wallet** | Autonome, Krypto-native oder kurzlebige Agenten | Wallet signiert eine Sign-In-With-X-Nachricht und zahlt pro Anfrage in USDC auf Base oder Solana. Kein Venice-Konto nötig. Siehe den [x402-Guide](/guides/integrations/x402-venice-api). | Beide Methoden teilen sich dieselben Rate-Limits und werden in Venice-Credits abgerechnet. Wirklich autonome Agenten können sich durch Staking von VVV auf Base ihren eigenen API-Schlüssel ausstellen lassen. Siehe [Autonomous Agent API Key Creation](/guides/getting-started/generating-api-key-agent). ## Crypto RPC – Schnellstart Sende eine beliebige JSON-RPC-2.0-Methode an `POST /crypto/rpc/{network}`. ```bash theme={"system"} curl https://api.venice.ai/api/v1/crypto/rpc/ethereum-mainnet \ -H "Authorization: Bearer $VENICE_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "jsonrpc": "2.0", "method": "eth_chainId", "params": [], "id": 1 }' ``` Antwort: ```json theme={"system"} { "jsonrpc": "2.0", "id": 1, "result": "0x1" } ``` Response-Header enthalten `X-Venice-RPC-Credits` (berechnete Credits), `X-Venice-RPC-Cost-USD` (Dollar-Kosten) und `X-Request-ID` (Correlation-ID). ### Unterstützte Netzwerke | Familie | Mainnet | Testnets | | ----------------- | ------------------- | -------------------------------------- | | Ethereum | `ethereum-mainnet` | `ethereum-sepolia`, `ethereum-holesky` | | Base | `base-mainnet` | `base-sepolia` | | Arbitrum | `arbitrum-mainnet` | `arbitrum-sepolia` | | Optimism | `optimism-mainnet` | `optimism-sepolia` | | Polygon | `polygon-mainnet` | `polygon-amoy` | | Linea | `linea-mainnet` | `linea-sepolia` | | Avalanche C-Chain | `avalanche-mainnet` | `avalanche-fuji` | | BNB Smart Chain | `bsc-mainnet` | `bsc-testnet` | | Blast | `blast-mainnet` | `blast-sepolia` | | zkSync Era | `zksync-mainnet` | `zksync-sepolia` | | Starknet | `starknet-mainnet` | `starknet-sepolia` | Nutze [`GET /crypto/rpc/networks`](/api-reference/endpoint/crypto/networks) für die aktuelle, maßgebliche Liste. ### Method-Tiers Methoden sind in drei Credit-Tiers gruppiert. Gesamtkosten = `baseCredits[chain] × methodTier`. | Tier | Multiplikator | Beispiele | | ------------ | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | | **Standard** | 1× | `eth_call`, `eth_getBalance`, `eth_blockNumber`, `eth_sendRawTransaction`, `eth_getLogs`, `eth_getTransactionReceipt`, `eth_estimateGas` | | **Advanced** | 2× | `trace_block`, `trace_call`, `trace_transaction`, `debug_traceCall`, `debug_traceTransaction` | | **Large** | 4× | `trace_replayBlockTransactions`, `trace_replayTransaction`, `txpool_content` | Vollständige Liste und Preise in der [Crypto-RPC-API-Referenz](/api-reference/endpoint/crypto/rpc). ## Rezepte für Agenten Gängige Muster für KI-Agenten, die On-Chain lesen und schreiben müssen. ### Native-Token-Balance einer Wallet lesen ```bash theme={"system"} curl https://api.venice.ai/api/v1/crypto/rpc/base-mainnet \ -H "Authorization: Bearer $VENICE_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "jsonrpc": "2.0", "method": "eth_getBalance", "params": ["0xYourWalletAddress", "latest"], "id": 1 }' ``` ### ERC-20-Token-Balance lesen Rufe den `balanceOf(address)`-Selector mit `eth_call` auf. Das `data`-Feld ist der 4-Byte-Selector (`0x70a08231`) gefolgt von der Wallet-Adresse, links auf 32 Byte aufgefüllt. Am einfachsten lässt man das eine Library erledigen: ```typescript theme={"system"} import { encodeFunctionData, parseAbi } from 'viem' const data = encodeFunctionData({ abi: parseAbi(['function balanceOf(address) view returns (uint256)']), args: ['0xWalletAddress'], }) const response = await fetch('https://api.venice.ai/api/v1/crypto/rpc/base-mainnet', { method: 'POST', headers: { Authorization: `Bearer ${process.env.VENICE_API_KEY}`, 'Content-Type': 'application/json', }, body: JSON.stringify({ jsonrpc: '2.0', method: 'eth_call', params: [{ to: '0xacfE6019Ed1A7Dc6f7B508C02d1b04ec88cC21bf', data }, 'latest'], id: 1, }), }) ``` Die Vertragsadresse oben ist VVV auf Base. Tausche sie gegen einen beliebigen ERC-20-Vertrag aus. ### Signierte Transaktion senden (kompletter Lifecycle) Venice hält niemals deine Private Keys. Der Agent sammelt Tx-Parameter per RPC-Reads, signiert lokal mit einer Library wie [viem](https://viem.sh) oder [ethers](https://docs.ethers.org) und leitet die Raw-Hex über Venice weiter. ```bash theme={"system"} curl https://api.venice.ai/api/v1/crypto/rpc/base-mainnet \ -H "Authorization: Bearer $VENICE_API_KEY" \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","method":"eth_getTransactionCount","params":["0xAgentWallet","pending"],"id":1}' ``` Verwende `"pending"`, damit aufeinanderfolgende Sends nicht kollidieren. ```bash theme={"system"} curl https://api.venice.ai/api/v1/crypto/rpc/base-mainnet \ -H "Authorization: Bearer $VENICE_API_KEY" \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":1}' ``` Für EIP-1559-Chains bevorzugt `eth_feeHistory`, um `maxFeePerGas` und `maxPriorityFeePerGas` zu berechnen. ```bash theme={"system"} curl https://api.venice.ai/api/v1/crypto/rpc/base-mainnet \ -H "Authorization: Bearer $VENICE_API_KEY" \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","method":"eth_estimateGas","params":[{"from":"0xAgentWallet","to":"0xRecipient","value":"0x0","data":"0x..."}],"id":1}' ``` ```typescript theme={"system"} import { privateKeyToAccount } from 'viem/accounts' import { base } from 'viem/chains' const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY) const signed = await account.signTransaction({ chainId: base.id, nonce, // aus Schritt 1 gas, // aus Schritt 3 maxFeePerGas, // aus Schritt 2 (Fee History) maxPriorityFeePerGas, // aus Schritt 2 (Fee History) to: '0xRecipient', value: 0n, data: '0x...', }) ``` ```bash theme={"system"} curl https://api.venice.ai/api/v1/crypto/rpc/base-mainnet \ -H "Authorization: Bearer $VENICE_API_KEY" \ -H "Idempotency-Key: agent-tx-" \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":["0xSignedHex"],"id":1}' ``` Setze bei Relays immer `Idempotency-Key`, damit ein Netzwerk-Hänger kein Double-Broadcast verursacht. ```bash theme={"system"} curl https://api.venice.ai/api/v1/crypto/rpc/base-mainnet \ -H "Authorization: Bearer $VENICE_API_KEY" \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","params":["0xTxHash"],"id":1}' ``` Alle paar Sekunden pollen, bis `result` nicht null ist. Prüfe `result.status` (`"0x1"` = Erfolg). Jeder `eth_sendRawTransaction`-Aufruf wird serverseitig mit Tx-Hash, Netzwerk, Request-ID und aufrufender User-ID protokolliert. Der signierte Payload selbst wird nicht aufbewahrt. Dieser Audit-Trail existiert, damit kompromittierte Schlüssel, die für illegale Relays missbraucht werden, zum verantwortlichen Account zurückverfolgt werden können. ### Mehrere Aufrufe batchen (Multi-Chain-Portfolio-Check) Sende bis zu 100 JSON-RPC-Objekte in einer Anfrage. Jedes wird unabhängig validiert und abgerechnet. ```bash theme={"system"} curl https://api.venice.ai/api/v1/crypto/rpc/ethereum-mainnet \ -H "Authorization: Bearer $VENICE_API_KEY" \ -H "Content-Type: application/json" \ -d '[ { "jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": 1 }, { "jsonrpc": "2.0", "method": "eth_getBalance", "params": ["0xWallet", "latest"], "id": 2 }, { "jsonrpc": "2.0", "method": "eth_gasPrice", "params": [], "id": 3 } ]' ``` Für Multi-Chain-Reads (ein Aufruf pro Chain) parallele Anfragen an verschiedene `{network}`-Endpoints schicken. ### Sichere Retries mit Idempotenz Setze den Header `Idempotency-Key` auf einen beliebigen String passend zu `[A-Za-z0-9_-]{1,255}`. Venice cached die Antwort 24 Stunden lang anhand von `(user, key)`. Replays liefern das gecachte Ergebnis mit `Idempotent-Replayed: true` und sind kostenfrei. ```bash theme={"system"} curl https://api.venice.ai/api/v1/crypto/rpc/base-mainnet \ -H "Authorization: Bearer $VENICE_API_KEY" \ -H "Idempotency-Key: agent-tx-2026-04-21-001" \ -H "Content-Type: application/json" \ -d '{ "jsonrpc": "2.0", "method": "eth_sendRawTransaction", "params": ["0xSignedRawTxHex"], "id": 1 }' ``` Das ist bei Transaktions-Relays kritisch, wo ein Netzwerk-Hänger sonst dazu führen könnte, dass dein Agent dieselbe Tx zweimal broadcastet. ## Den API-Schlüssel des Agents finanzieren Sobald der Agent einen Venice API-Schlüssel hat, braucht er auf dem zugrunde liegenden Konto ausgabefähiges Guthaben, bevor bezahlte Endpoints den Schlüssel akzeptieren. Es gibt zwei Wege, dort Guthaben hinzubekommen: | Pfad | Autonom? | Wie es funktioniert | | ----------------------------------------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **DIEM aus VVV-Staking** | Ja | Stake VVV im [Venice Staking Smart Contract](https://basescan.org/address/0x321b7ff75154472B18EDb199033fF4D116F340Ff#code) auf Base. Die tägliche DIEM-Zuteilung der Wallet ist proportional zu ihrem Anteil am Staking-Pool. Das Konto braucht mindestens 0,1 angesammelte DIEM, bevor DIEM ausgegeben werden kann. DIEM erneuert sich um 00:00 UTC. Um den täglichen Spend zu erhöhen, mehr VVV staken. | | **USD- oder Crypto-Top-up via Dashboard** | Nein (Browser) | Mit derselben Wallet bei [venice.ai](https://venice.ai) einloggen (Sign-In-With-Ethereum) und in „Settings", „API" Credits hinzufügen. Sowohl Stripe (Karte) als auch Coinbase (Crypto) liegen hinter dieser Seite und benötigen einen Browser. Credits verfallen nicht. | Für einen Agenten, der unbeaufsichtigt läuft, ist **DIEM via VVV-Staking heute der einzige vollständig headless-fähige Funding-Pfad für einen ausgestellten API-Schlüssel**. Übersteigt der tägliche Spend des Agenten seine DIEM-Zuteilung, sind die realistischen Optionen: mehr VVV staken oder ein Operator meldet sich an und lädt in USD oder Crypto auf. ### Autonomes VVV-Staking und Key-Generierung Ein wirklich autonomer Agent kann seine eigene VVV-Wallet auf Base verwalten, staken und seinen eigenen Venice API-Schlüssel ausstellen lassen – ohne menschliches Eingreifen. Der vollständige Flow: Sende VVV an die Wallet des Agents (oder lass den Agent auf [Aerodrome](https://aerodrome.finance) oder [Uniswap](https://app.uniswap.org) swappen), plus eine kleine Menge ETH auf Base für die zwei Staking-Transaktionen. Den Staking-Contract auf dem VVV-Token `approve`, dann `stake(amount)` auf `0x321b7ff75154472B18EDb199033fF4D116F340Ff`. Die sVVV-Balance der Wallet aktualisiert sich atomar mit dem Stake. `GET /api/v1/api_keys/generate_web3_key` liefert ein JWT, das 15 Minuten nach Ausstellung abläuft. Den Roh-Token mit der Staking-Wallet signieren, dann Adresse, Signatur und Token per `POST` zurücksenden. Venice gibt einen API-Schlüssel zurück, der an das von dieser Wallet abgeleitete User-Konto gebunden ist. Das Ausstellen erfordert lediglich eine sVVV-Balance ungleich null – 1 gestaktes VVV genügt also, um einen Schlüssel zu erhalten. Das **Ausgeben** mit dem Schlüssel ist eine separate Frage und wird durch die Funding-Tabelle oben geregelt. Siehe [Autonomous Agent API Key Creation](/guides/getting-started/generating-api-key-agent) für die vollständige Anleitung mit Code und der ausführlichen Fehler-Referenz. ## x402-Wallet-Auth in 30 Sekunden Wenn dein Agent bereits eine Base- oder Solana-Wallet hat, kannst du den API-Schlüssel komplett auslassen. Das SDK [`venice-x402-client`](https://github.com/veniceai/x402-client) übernimmt Sign-In-With-X-Signing, Top-ups und Balance-Tracking. ```bash theme={"system"} npm install venice-x402-client ``` ```typescript theme={"system"} import { VeniceClient } from 'venice-x402-client' const venice = new VeniceClient(process.env.WALLET_KEY) await venice.topUp(10) // überspringen, wenn die Wallet bereits Guthaben hat const response = await venice.chat({ model: 'kimi-k2-6', messages: [{ role: 'user', content: 'What is the latest block on Base?' }] }) ``` Dieselbe Wallet-Auth funktioniert gegen `/crypto/rpc/{network}` für Blockchain-Reads und -Writes. Vollständige Protokoll-Details im [x402-Guide](/guides/integrations/x402-venice-api). ## Preise Crypto RPC wird in Venice-Credits abgerechnet. Jede Antwort enthält `X-Venice-RPC-Credits` (berechnete Credits) und `X-Venice-RPC-Cost-USD` (Dollar-Kosten), sodass dein Agent die Ausgaben pro Anfrage tracken kann. ### Base-Credits pro Chain | Base-Credits | Chains | | ------------ | ----------------------------------------------------------------------------------- | | **20** | Ethereum, Base, Optimism, Arbitrum, Polygon, Linea, Avalanche, BSC, Blast, Starknet | | **30** | zkSync Era | ### Kostenbeispiele Beobachtete Preise für Standard-, Advanced- und Large-Method-Tiers: | Aufruf | Credits | USD-Kosten | | ------------------------------------------------ | ------- | ------------- | | `eth_call` auf Ethereum (20 × 1×) | 20 | \~\$0,0000140 | | `trace_transaction` auf Ethereum (20 × 2×) | 40 | \~\$0,0000280 | | `trace_replayTransaction` auf Ethereum (20 × 4×) | 80 | \~\$0,0000560 | | `eth_call` auf zkSync (30 × 1×) | 30 | \~\$0,0000210 | Für die maßgeblichen Kosten immer dem Response-Header `X-Venice-RPC-Cost-USD` vertrauen. Fehlerhafte Items in Batch-Anfragen werden pauschal mit 5 Credits pro Item abgerechnet. ### Rate-Limits | Tier | Requests pro Minute | | -------- | ------------------- | | Standard | 100 | | Staff | 1.000 | Bei Überschreitung gibt der Endpoint `429` mit den Standard-`X-RateLimit-*`-Response-Headern zurück. ## Fehlerbehandlung Häufige HTTP-Antworten, die dein Agent behandeln sollte: | Status | Bedeutung | Was tun | | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `400` | Nicht unterstützte oder nicht gemappte JSON-RPC-Methode oder fehlerhaftes Batch | Methode gegen die [Allowlist](/api-reference/endpoint/crypto/rpc) prüfen. Der Fehler-Body nennt die fehlerhafte Methode. | | `400` | Replay eines `Idempotency-Key` mit anderem Body | Für unterschiedliche Requests einen frischen Key verwenden. | | `402` | Kein Auth-Header vorhanden (Response-Body enthält `authOptions` mit beiden unterstützten Auth-Pfaden) oder keine Credits trotz gültigem Auth-Header | Wenn keine Auth: `Authorization: Bearer ...` oder den x402-`X-Sign-In-With-X`-Header setzen. Wenn keine Credits: Mit Bearer-Key das Konto aufladen (DIEM, USD oder Dashboard-Top-up); mit x402-Auth direkt `POST /api/v1/x402/top-up` aufrufen. | | `429` | Rate-Limit erreicht (100 Req/min Standard, 1.000 Req/min Staff) | `X-RateLimit-Reset` respektieren und backoffen. Bis zu 100 Aufrufe pro Request batchen, um das Limit zu amortisieren. | | `5xx` | Upstream-RPC-Node-Hänger | Mit demselben `Idempotency-Key` erneut versuchen, um Doppel-Belastung zu vermeiden. | Per-Item-Batch-Fehler (z. B. ungültige Params bei einem von N Calls) kommen in einer `200 OK`-Antwort mit einem JSON-RPC-`error`-Feld auf dem betroffenen Item zurück. Diese Items werden pauschal mit 5 Credits abgerechnet. ## Nicht unterstützt Diese Methodenklassen werden absichtlich abgelehnt: * **Nur-WebSocket** (`eth_subscribe`, `eth_unsubscribe`): Der Proxy ist HTTP-only. Stattdessen pollen. * **Stateful Filter** (`eth_newFilter`, `eth_getFilterChanges` usw.): Filter-State ist an einen einzelnen Backend-Node gebunden und bricht hinter einem load-balanced Proxy. Verwende stattdessen `eth_getLogs`. * **Key-haltende Methoden** (`eth_sign`, `eth_accounts`, `eth_mining`): Hosted Provider halten keine User-Keys. Client-seitig signieren und per `eth_sendRawTransaction` einreichen. * **Nicht gemappte Methoden**: Alles außerhalb der Allowlist gibt `400` zurück. Support kontaktieren, um Methoden anzufordern. ## Ressourcen Vollständige Methodenliste, Preise und Response-Header Aktuelle Liste der unterstützten Netzwerk-Slugs Mit einer Base- oder Solana-Wallet authentifizieren und zahlen Eigenen Schlüssel durch VVV-Staking ausstellen lassen 27 sofort lauffähige Crypto-RPC-Beispiele DIEM, Credit-Pricing und Zahlungsoptionen