Crypto RPC für Agenten | Venice API Docs

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 Credential, zwei Superkräfte

Ein einziger API-Schlüssel (oder eine Wallet) für LLM-Inferenz und JSON-RPC-Aufrufe.

11 Chains unterstützt

Ethereum, Base, Arbitrum, Optimism, Polygon, Linea, Avalanche, BSC, Blast, zkSync Era und Starknet (Mainnet plus Testnets).

VVV staken für Headless-Funding

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.

Keyless-Auth via x402

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 <key>`. Schlüssel unter 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.

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.

Crypto RPC – Schnellstart

Sende eine beliebige JSON-RPC-2.0-Methode an POST /crypto/rpc/{network}.

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:

{ "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 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.

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

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:

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 oder ethers und leitet die Raw-Hex über Venice weiter.

Nächste Nonce holen

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.

Gas-Preis holen

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.

Gas schätzen

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

Lokal signieren

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...',
})

Über Venice senden

curl https://api.venice.ai/api/v1/crypto/rpc/base-mainnet \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Idempotency-Key: agent-tx-<id>" \
  -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.

Receipt pollen

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.

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.

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 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 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:

VVV und ETH für Gas besorgen

Sende VVV an die Wallet des Agents (oder lass den Agent auf Aerodrome oder Uniswap swappen), plus eine kleine Menge ETH auf Base für die zwei Staking-Transaktionen.

VVV staken

Den Staking-Contract auf dem VVV-Token approve, dann stake(amount) auf 0x321b7ff75154472B18EDb199033fF4D116F340Ff. Die sVVV-Balance der Wallet aktualisiert sich atomar mit dem Stake.

API-Schlüssel ausstellen

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 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 übernimmt Sign-In-With-X-Signing, Top-ups und Balance-Tracking.

npm install venice-x402-client

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.

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

Crypto RPC API-Referenz

Vollständige Methodenliste, Preise und Response-Header

Unterstützte Netzwerke

Aktuelle Liste der unterstützten Netzwerk-Slugs

x402 Wallet-Auth

Mit einer Base- oder Solana-Wallet authentifizieren und zahlen

Autonomer Agent-API-Schlüssel

Eigenen Schlüssel durch VVV-Staking ausstellen lassen

Postman-Collection

27 sofort lauffähige Crypto-RPC-Beispiele

Preise

DIEM, Credit-Pricing und Zahlungsoptionen

Ein Credential, zwei Superkräfte

11 Chains unterstützt

VVV staken für Headless-Funding

Keyless-Auth via x402

​Warum Venice für On-Chain-Agenten?

​Authentifizierung

​Crypto RPC – Schnellstart

​Unterstützte Netzwerke

​Method-Tiers

​Rezepte für Agenten

​Native-Token-Balance einer Wallet lesen

​ERC-20-Token-Balance lesen

​Signierte Transaktion senden (kompletter Lifecycle)

​Mehrere Aufrufe batchen (Multi-Chain-Portfolio-Check)

​Sichere Retries mit Idempotenz

​Den API-Schlüssel des Agents finanzieren

​Autonomes VVV-Staking und Key-Generierung

​x402-Wallet-Auth in 30 Sekunden

​Preise

​Base-Credits pro Chain

​Kostenbeispiele

​Rate-Limits

​Fehlerbehandlung

​Nicht unterstützt

​Ressourcen

Crypto RPC API-Referenz

Unterstützte Netzwerke

x402 Wallet-Auth

Autonomer Agent-API-Schlüssel

Postman-Collection

Preise

Warum Venice für On-Chain-Agenten?

Authentifizierung

Crypto RPC – Schnellstart

Unterstützte Netzwerke

Method-Tiers

Rezepte für Agenten

Native-Token-Balance einer Wallet lesen

ERC-20-Token-Balance lesen

Signierte Transaktion senden (kompletter Lifecycle)

Mehrere Aufrufe batchen (Multi-Chain-Portfolio-Check)

Sichere Retries mit Idempotenz

Den API-Schlüssel des Agents finanzieren

Autonomes VVV-Staking und Key-Generierung

x402-Wallet-Auth in 30 Sekunden

Preise

Base-Credits pro Chain

Kostenbeispiele

Rate-Limits

Fehlerbehandlung

Nicht unterstützt

Ressourcen