> ## 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 pour les agents > Utilisez Venice comme fournisseur de modèles et couche RPC blockchain pour vos agents IA autonomes : un identifiant, 230+ modèles, 11 chaînes. Venice donne à votre agent à la fois l'inférence (230+ modèles) et l'accès à la blockchain (10 chaînes EVM plus Starknet) via un identifiant unique. Votre agent peut penser, signer et envoyer des transactions sans jongler entre des comptes séparés pour les fournisseurs d'inférence et de RPC. Une seule clé API (ou wallet) pour l'inférence LLM et les appels JSON-RPC. Ethereum, Base, Arbitrum, Optimism, Polygon, Linea, Avalanche, BSC, Blast, zkSync Era et Starknet (mainnet et testnets). Stakez VVV sur Base pour gagner quotidiennement du DIEM, le seul moyen de financement entièrement headless pour une clé API frappée. Les rechargements en USD et en crypto sont également disponibles via le dashboard. Les agents peuvent s'authentifier avec une signature de wallet et payer en USDC sur Base ou Solana. ## Pourquoi Venice pour les agents on-chain ? | Capacité | Ce que votre agent obtient | | -------------------- | ---------------------------------------------------------------------------------------------------------- | | **Inférence** | 230+ modèles texte, image, vidéo, audio et embedding via un seul endpoint compatible OpenAI | | **Crypto RPC** | Proxy JSON-RPC 2.0 vers 10 chaînes EVM plus Starknet (mainnet et testnets) | | **Authentification** | Clé API standard ou auth wallet x402 (pas de compte Venice requis) | | **Financement** | Autonome : staking VVV pour du DIEM quotidien. Navigateur : rechargement en USD ou crypto via le dashboard | | **Batching** | Jusqu'à 100 appels JSON-RPC par requête, multi-chaînes en parallèle | | **Idempotence** | Retries sécurisés avec l'en-tête `Idempotency-Key` | ## Authentification Choisissez la méthode d'authentification qui correspond à la façon dont votre agent s'exécute. | Méthode | Idéal pour | Comment ça fonctionne | | --------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Clé API** | Agents côté serveur, déploiements fixes | En-tête `Authorization: Bearer `. Obtenez une clé sur [venice.ai/settings/api](https://venice.ai/settings/api). | | **Wallet x402** | Agents autonomes, crypto-natifs ou éphémères | Le wallet signe un message Sign-In-With-X et paie chaque requête en USDC sur Base ou Solana. Pas de compte Venice requis. Voir le [guide x402](/guides/integrations/x402-venice-api). | Les deux méthodes partagent les mêmes limites de débit et la même facturation en crédits Venice. Les agents véritablement autonomes peuvent frapper leur propre clé API en stakant VVV sur Base. Voir [Création de clé API pour agent autonome](/guides/getting-started/generating-api-key-agent). ## Démarrage rapide Crypto RPC Envoyez n'importe quelle méthode JSON-RPC 2.0 à `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 }' ``` Réponse : ```json theme={"system"} { "jsonrpc": "2.0", "id": 1, "result": "0x1" } ``` Les en-têtes de réponse incluent `X-Venice-RPC-Credits` (crédits facturés), `X-Venice-RPC-Cost-USD` (coût en dollars) et `X-Request-ID` (ID de corrélation). ### Réseaux pris en charge | Famille | 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` | Utilisez [`GET /crypto/rpc/networks`](/api-reference/endpoint/crypto/networks) pour obtenir la liste en direct faisant autorité. ### Tiers de méthodes Les méthodes sont regroupées en trois tiers de crédits. Coût total = `baseCredits[chain] × methodTier`. | Tier | Multiplicateur | Exemples | | ------------ | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | | **Standard** | 1x | `eth_call`, `eth_getBalance`, `eth_blockNumber`, `eth_sendRawTransaction`, `eth_getLogs`, `eth_getTransactionReceipt`, `eth_estimateGas` | | **Avancé** | 2x | `trace_block`, `trace_call`, `trace_transaction`, `debug_traceCall`, `debug_traceTransaction` | | **Large** | 4x | `trace_replayBlockTransactions`, `trace_replayTransaction`, `txpool_content` | Liste complète et détails de tarification dans la [référence API Crypto RPC](/api-reference/endpoint/crypto/rpc). ## Recettes pour agents Patterns courants pour les agents IA qui ont besoin de lire et d'écrire on-chain. ### Lire le solde natif d'un wallet ```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 }' ``` ### Lire le solde d'un token ERC-20 Appelez le sélecteur `balanceOf(address)` avec `eth_call`. Le champ `data` est le sélecteur de 4 octets (`0x70a08231`) suivi de l'adresse du wallet remplie à gauche jusqu'à 32 octets. Le plus simple est de laisser une bibliothèque l'encoder : ```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, }), }) ``` L'adresse de contrat ci-dessus correspond à VVV sur Base. Remplacez-la par n'importe quel contrat ERC-20. ### Envoyer une transaction signée (cycle de vie complet) Venice ne détient jamais vos clés privées. L'agent collecte les paramètres de transaction via des lectures RPC, signe localement avec une bibliothèque comme [viem](https://viem.sh) ou [ethers](https://docs.ethers.org), puis relaie le hex brut via Venice. ```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}' ``` Utilisez `"pending"` pour que les envois successifs ne se chevauchent pas. ```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}' ``` Pour les chaînes EIP-1559, préférez `eth_feeHistory` pour calculer `maxFeePerGas` et `maxPriorityFeePerGas`. ```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, // depuis l'étape 1 gas, // depuis l'étape 3 maxFeePerGas, // depuis l'étape 2 (fee history) maxPriorityFeePerGas, // depuis l'étape 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}' ``` Définissez toujours `Idempotency-Key` sur les relais afin qu'un incident réseau ne puisse pas provoquer une double diffusion. ```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}' ``` Sondez toutes les quelques secondes jusqu'à ce que `result` soit non-null. Vérifiez `result.status` (`"0x1"` = succès). Chaque appel `eth_sendRawTransaction` est journalisé côté serveur avec le hash de tx, le réseau, l'ID de requête et l'ID d'utilisateur appelant. Le payload signé lui-même n'est pas conservé. Cette piste d'audit existe pour que des clés compromises utilisées pour des relais illicites puissent être tracées jusqu'au compte responsable. ### Batcher plusieurs appels (vérification de portefeuille multi-chaînes) Envoyez jusqu'à 100 objets JSON-RPC dans une seule requête. Chacun est validé et facturé indépendamment. ```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 } ]' ``` Pour des lectures multi-chaînes (un appel par chaîne), émettez des requêtes parallèles vers différents endpoints `{network}`. ### Retries sécurisés avec idempotence Définissez l'en-tête `Idempotency-Key` à n'importe quelle chaîne correspondant à `[A-Za-z0-9_-]{1,255}`. Venice met la réponse en cache pendant 24 heures, indexée sur `(user, key)`. Les rejeux renvoient le résultat en cache avec `Idempotent-Replayed: true` et ne facturent rien. ```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 }' ``` C'est essentiel pour les relais de transactions, où un incident réseau pourrait sinon amener votre agent à diffuser deux fois la même tx. ## Financer la clé API de l'agent Une fois que l'agent dispose d'une clé API Venice, il a besoin d'un solde dépensable sur le compte sous-jacent avant que les endpoints payants n'acceptent la clé. Il existe deux façons d'y placer du solde : | Voie | Autonome ? | Comment ça fonctionne | | ------------------------------------------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **DIEM via staking VVV** | Oui | Stakez VVV dans le [Venice Staking Smart Contract](https://basescan.org/address/0x321b7ff75154472B18EDb199033fF4D116F340Ff#code) sur Base. L'allocation quotidienne de DIEM du wallet est proportionnelle à sa part dans le pool de staking. Le compte doit avoir accumulé au moins 0,1 DIEM avant que tout DIEM ne soit dépensable. Le DIEM se rafraîchit à 00:00 UTC. Pour augmenter la dépense quotidienne, stakez plus de VVV. | | **Recharge USD ou crypto via le dashboard** | Non (navigateur) | Connectez-vous à [venice.ai](https://venice.ai) avec le même wallet (Sign-In-With-Ethereum), puis ajoutez des crédits dans Settings, API. Stripe (carte) et Coinbase (crypto) sont accessibles via cette page et nécessitent un navigateur. Les crédits n'expirent jamais. | Pour un agent qui s'exécute sans surveillance, **le DIEM via staking VVV est aujourd'hui la seule voie de financement entièrement headless pour une clé API frappée**. Si la dépense quotidienne de l'agent dépasse son allocation DIEM, les options réalistes sont : staker plus de VVV, ou qu'un opérateur se connecte et recharge en USD ou en crypto. ### Staking VVV autonome et génération de clé Un agent véritablement autonome peut gérer son propre wallet VVV sur Base, le staker et frapper sa propre clé API Venice sans intervention humaine. Le flux complet : Envoyez du VVV au wallet de l'agent (ou faites en sorte que l'agent swap sur [Aerodrome](https://aerodrome.finance) ou [Uniswap](https://app.uniswap.org)), plus une petite quantité d'ETH sur Base pour les deux transactions de staking. `approve` le contrat de staking sur le token VVV, puis `stake(amount)` sur `0x321b7ff75154472B18EDb199033fF4D116F340Ff`. Le solde sVVV du wallet est mis à jour atomiquement avec le stake. `GET /api/v1/api_keys/generate_web3_key` renvoie un JWT qui expire 15 minutes après émission. Signez le token brut avec le wallet de staking, puis `POST` l'adresse, la signature et le token en retour. Venice renvoie une clé API liée au compte utilisateur dérivé de ce wallet. Le mintage ne nécessite qu'un solde sVVV non nul, donc 1 VVV staké suffit pour recevoir une clé. **Dépenser** avec la clé est une question distincte, régie par le tableau de financement ci-dessus. Voir [Création de clé API pour agent autonome](/guides/getting-started/generating-api-key-agent) pour la marche à suivre complète avec du code et la référence d'erreurs exhaustive. ## Auth wallet x402 en 30 secondes Si votre agent dispose déjà d'un wallet Base ou Solana, sautez complètement la clé API. Le SDK [`venice-x402-client`](https://github.com/veniceai/x402-client) gère la signature Sign-In-With-X, les recharges et le suivi de solde. ```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) // ignorer si le wallet a déjà un solde const response = await venice.chat({ model: 'kimi-k2-6', messages: [{ role: 'user', content: 'What is the latest block on Base?' }] }) ``` La même authentification wallet fonctionne contre `/crypto/rpc/{network}` pour les lectures et écritures blockchain. Détails complets du protocole dans le [guide x402](/guides/integrations/x402-venice-api). ## Tarification Crypto RPC est facturé en crédits Venice. Chaque réponse inclut `X-Venice-RPC-Credits` (crédits facturés) et `X-Venice-RPC-Cost-USD` (coût en dollars) pour que votre agent puisse suivre ses dépenses par requête. ### Crédits de base par chaîne | Crédits de base | Chaînes | | --------------- | ----------------------------------------------------------------------------------- | | **20** | Ethereum, Base, Optimism, Arbitrum, Polygon, Linea, Avalanche, BSC, Blast, Starknet | | **30** | zkSync Era | ### Exemples de coût Tarification observée pour les tiers de méthodes standard, avancé et large : | Appel | Crédits | Coût USD | | ------------------------------------------------ | ------- | -------------- | | `eth_call` sur Ethereum (20 × 1x) | 20 | \~0,0000140 \$ | | `trace_transaction` sur Ethereum (20 × 2x) | 40 | \~0,0000280 \$ | | `trace_replayTransaction` sur Ethereum (20 × 4x) | 80 | \~0,0000560 \$ | | `eth_call` sur zkSync (30 × 1x) | 30 | \~0,0000210 \$ | Fiez-vous toujours à l'en-tête de réponse `X-Venice-RPC-Cost-USD` pour le coût faisant autorité. Les éléments en erreur dans les requêtes batch sont facturés à un forfait de 5 crédits chacun. ### Limites de débit | Tier | Requêtes par minute | | -------- | ------------------- | | Standard | 100 | | Staff | 1 000 | En cas de dépassement, l'endpoint renvoie `429` avec les en-têtes de réponse standards `X-RateLimit-*`. ## Gestion des erreurs Réponses HTTP courantes que votre agent doit gérer : | Statut | Signification | Que faire | | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `400` | Méthode JSON-RPC non supportée ou non mappée, ou batch malformé | Vérifiez la méthode par rapport à la [liste autorisée](/api-reference/endpoint/crypto/rpc). Le corps d'erreur nomme la méthode fautive. | | `400` | Rejeu d'une `Idempotency-Key` avec un corps différent | Utilisez une clé fraîche pour des requêtes distinctes. | | `402` | Aucun en-tête d'auth (le corps de réponse inclut `authOptions` listant les deux voies d'auth supportées), ou plus de crédits avec un en-tête d'auth valide | Si pas d'auth : attachez `Authorization: Bearer ...` ou l'en-tête x402 `X-Sign-In-With-X`. Si plus de crédits : avec une clé Bearer, financez le compte (DIEM, USD ou recharge dashboard) ; avec auth x402, appelez directement `POST /api/v1/x402/top-up`. | | `429` | Limite de débit atteinte (100 req/min standard, 1 000 req/min staff) | Respectez `X-RateLimit-Reset` et reculez. Batchez jusqu'à 100 appels par requête pour amortir la limite. | | `5xx` | Hoquet de nœud RPC en amont | Réessayez avec la même `Idempotency-Key` pour éviter de payer deux fois. | Les erreurs par élément en batch (par ex. des params invalides sur l'un des N appels) reviennent dans une réponse `200 OK` avec un champ `error` JSON-RPC sur l'élément fautif. Ces éléments sont facturés à un forfait de 5 crédits chacun. ## Non pris en charge Ces catégories de méthodes sont intentionnellement rejetées : * **WebSocket uniquement** (`eth_subscribe`, `eth_unsubscribe`) : le proxy est uniquement HTTP. Faites du polling à la place. * **Filtres avec état** (`eth_newFilter`, `eth_getFilterChanges`, etc.) : l'état des filtres est lié à un seul backend et casse sur un proxy à load balancing. Utilisez `eth_getLogs` à la place. * **Méthodes détenant des clés** (`eth_sign`, `eth_accounts`, `eth_mining`) : les fournisseurs hébergés ne détiennent pas les clés des utilisateurs. Signez côté client et soumettez via `eth_sendRawTransaction`. * **Méthodes non mappées** : tout ce qui n'est pas dans la liste autorisée renvoie `400`. Contactez le support pour demander des ajouts. ## Ressources Liste complète des méthodes, tarification et en-têtes de réponse Liste en direct des slugs de réseau pris en charge Authentifiez-vous et payez avec un wallet Base ou Solana Frappez votre propre clé en stakant VVV 27 exemples Crypto RPC prêts à l'emploi DIEM, tarification des crédits et options de paiement