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

# RPC cripto para agentes

> Usa Venice como proveedor de modelos y como capa RPC de blockchain para agentes de IA autónomos — una credencial, más de 230 modelos, 11 cadenas, sin MetaMask.

Venice ofrece a tu agente tanto inferencia (230+ modelos) como acceso a blockchain (10 cadenas EVM más Starknet) a través de una única credencial. Tu agente puede pensar, firmar y enviar transacciones sin malabarear cuentas separadas para proveedores de inferencia y RPC.

<CardGroup cols={2}>
  <Card title="Una credencial, dos superpoderes" icon="key">
    Una sola API key (o monedero) tanto para inferencia LLM como para llamadas JSON-RPC.
  </Card>

  <Card title="11 cadenas admitidas" icon="link">
    Ethereum, Base, Arbitrum, Optimism, Polygon, Linea, Avalanche, BSC, Blast, zkSync Era y Starknet (mainnet más testnets).
  </Card>

  <Card title="Staking de VVV para financiación headless" icon="coins">
    Haz staking de VVV en Base para ganar DIEM diario, la única ruta de financiación totalmente headless para una API key acuñada. También hay recargas en USD y cripto a través del dashboard.
  </Card>

  <Card title="Auth sin clave vía x402" icon="wallet">
    Los agentes pueden autenticarse con una firma de monedero y pagar en USDC en Base o Solana.
  </Card>
</CardGroup>

## ¿Por qué Venice para agentes onchain?

| Capacidad         | Lo que obtiene tu agente                                                                               |
| ----------------- | ------------------------------------------------------------------------------------------------------ |
| **Inferencia**    | 230+ modelos de texto, imagen, vídeo, audio y embeddings a través de un endpoint compatible con OpenAI |
| **RPC cripto**    | Proxy JSON-RPC 2.0 a 10 cadenas EVM más Starknet (mainnet y testnets)                                  |
| **Autenticación** | API key estándar o auth de monedero x402 (no se requiere cuenta de Venice)                             |
| **Financiación**  | Autónoma: staking de VVV para DIEM diario. Navegador: recargas en USD o cripto vía el dashboard        |
| **Lotes**         | Hasta 100 llamadas JSON-RPC por solicitud, multicadena en paralelo                                     |
| **Idempotencia**  | Reintentos seguros con la cabecera `Idempotency-Key`                                                   |

## Autenticación

Elige el método de auth que se ajuste a cómo se ejecute tu agente.

| Método            | Mejor para                                       | Cómo funciona                                                                                                                                                                                 |
| ----------------- | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **API key**       | Agentes del lado del servidor, despliegues fijos | Cabecera `Authorization: Bearer <key>`. Obtén una clave en [venice.ai/settings/api](https://venice.ai/settings/api).                                                                          |
| **Monedero x402** | Agentes autónomos, nativos de cripto o efímeros  | El monedero firma un mensaje Sign-In-With-X y paga por solicitud en USDC en Base o Solana. No se necesita cuenta de Venice. Consulta la [guía de x402](/guides/integrations/x402-venice-api). |

Ambos métodos comparten los mismos límites de velocidad y facturación en créditos de Venice.

<Tip>
  Los agentes verdaderamente autónomos pueden acuñar su propia API key haciendo staking de VVV en Base. Consulta [Creación autónoma de API Key por agente](/guides/getting-started/generating-api-key-agent).
</Tip>

## Inicio rápido de RPC cripto

Envía cualquier método JSON-RPC 2.0 a `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
  }'
```

Respuesta:

```json theme={"system"}
{ "jsonrpc": "2.0", "id": 1, "result": "0x1" }
```

Las cabeceras de respuesta incluyen `X-Venice-RPC-Credits` (créditos cobrados), `X-Venice-RPC-Cost-USD` (coste en dólares) y `X-Request-ID` (ID de correlación).

### Redes admitidas

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

Usa [`GET /crypto/rpc/networks`](/api-reference/endpoint/crypto/networks) para la lista autoritativa en vivo.

### Niveles de método

Los métodos se agrupan en tres niveles de créditos. Coste total = `baseCredits[chain] × methodTier`.

| Nivel        | Multiplicador | Ejemplos                                                                                                                                 |
| ------------ | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| **Standard** | 1x            | `eth_call`, `eth_getBalance`, `eth_blockNumber`, `eth_sendRawTransaction`, `eth_getLogs`, `eth_getTransactionReceipt`, `eth_estimateGas` |
| **Advanced** | 2x            | `trace_block`, `trace_call`, `trace_transaction`, `debug_traceCall`, `debug_traceTransaction`                                            |
| **Large**    | 4x            | `trace_replayBlockTransactions`, `trace_replayTransaction`, `txpool_content`                                                             |

Lista completa y detalle de precios en la [referencia de la API Crypto RPC](/api-reference/endpoint/crypto/rpc).

## Recetas de agente

Patrones comunes para agentes de IA que necesitan leer y escribir onchain.

### Lee el saldo nativo de un monedero

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

### Lee saldo de token ERC-20

Llama al selector `balanceOf(address)` con `eth_call`. El campo `data` es el selector de 4 bytes (`0x70a08231`) seguido de la dirección del monedero rellena a 32 bytes a la izquierda. Lo más fácil es dejar que una librería lo codifique:

```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,
  }),
})
```

La dirección de contrato anterior es VVV en Base. Sustitúyela por cualquier contrato ERC-20.

### Enviar una transacción firmada (ciclo completo)

Venice nunca guarda tus claves privadas. El agente recoge los parámetros de tx mediante lecturas RPC, firma localmente con una librería como [viem](https://viem.sh) o [ethers](https://docs.ethers.org) y luego retransmite el hex en bruto a través de Venice.

<Steps>
  <Step title="Obtén el siguiente nonce">
    ```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}'
    ```

    Usa `"pending"` para que los envíos consecutivos no colisionen.
  </Step>

  <Step title="Obtén el precio de gas">
    ```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}'
    ```

    Para cadenas EIP-1559, prefiere `eth_feeHistory` para calcular `maxFeePerGas` y `maxPriorityFeePerGas`.
  </Step>

  <Step title="Estima el gas">
    ```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}'
    ```
  </Step>

  <Step title="Firma localmente">
    ```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,                  // del paso 1
      gas,                    // del paso 3
      maxFeePerGas,           // del paso 2 (fee history)
      maxPriorityFeePerGas,   // del paso 2 (fee history)
      to: '0xRecipient',
      value: 0n,
      data: '0x...',
    })
    ```
  </Step>

  <Step title="Envía a través de Venice">
    ```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-<id>" \
      -H "Content-Type: application/json" \
      -d '{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":["0xSignedHex"],"id":1}'
    ```

    Establece siempre `Idempotency-Key` en las retransmisiones para que un corte de red no provoque doble emisión.
  </Step>

  <Step title="Polling del receipt">
    ```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}'
    ```

    Haz polling cada pocos segundos hasta que `result` no sea null. Comprueba `result.status` (`"0x1"` = éxito).
  </Step>
</Steps>

<Note>
  Cada llamada `eth_sendRawTransaction` se registra en el servidor con el hash de la tx, la red, el ID de solicitud y el ID del usuario que llama. El propio payload firmado no se retiene. Este registro de auditoría existe para que las claves comprometidas usadas para retransmisiones ilícitas puedan rastrearse hasta la cuenta responsable.
</Note>

### Agrupa varias llamadas (portfolio multicadena)

Envía hasta 100 objetos JSON-RPC en una solicitud. Cada uno se valida y factura de forma independiente.

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

Para lecturas multicadena (una llamada por cadena), emite solicitudes en paralelo a distintos endpoints `{network}`.

### Reintentos seguros con idempotencia

Establece la cabecera `Idempotency-Key` con cualquier cadena que coincida con `[A-Za-z0-9_-]{1,255}`. Venice cachea la respuesta durante 24 horas con clave `(user, key)`. Los replays devuelven el resultado en caché con `Idempotent-Replayed: true` y no cobran nada.

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

Esto es crítico para retransmisiones de transacciones donde un corte de red podría hacer que tu agente difundiera la misma tx dos veces.

## Financiar la API key del agente

Una vez que el agente tiene una API key de Venice, necesita saldo gastable en la cuenta subyacente antes de que los endpoints de pago acepten la clave. Hay dos formas de poner saldo ahí:

| Ruta                                         | ¿Autónoma?     | Cómo funciona                                                                                                                                                                                                                                                                                                                                                                                                                     |
| -------------------------------------------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **DIEM por staking de VVV**                  | Sí             | Haz staking de VVV en el [Smart Contract de staking de Venice](https://basescan.org/address/0x321b7ff75154472B18EDb199033fF4D116F340Ff#code) en Base. La asignación diaria de DIEM del monedero es proporcional a su parte en la piscina de staking. La cuenta necesita al menos 0,1 DIEM acumulado para que cualquier DIEM sea gastable. DIEM se renueva a las 00:00 UTC. Para aumentar el gasto diario, haz más staking de VVV. |
| **Recarga en USD o cripto vía el dashboard** | No (navegador) | Inicia sesión en [venice.ai](https://venice.ai) con el mismo monedero (Sign-In-With-Ethereum) y añade créditos en Settings, API. Tanto Stripe (tarjeta) como Coinbase (cripto) están detrás de esa página y requieren un navegador. Los créditos no caducan.                                                                                                                                                                      |

Para un agente que se ejecuta sin supervisión, **DIEM vía staking de VVV es la única ruta de financiación totalmente headless para una API key acuñada hoy**. Si el gasto diario del agente excede su asignación de DIEM, las opciones realistas son: hacer más staking de VVV, o que un operador inicie sesión y recargue en USD o cripto.

### Staking autónomo de VVV y generación de clave

Un agente verdaderamente autónomo puede gestionar su propio monedero de VVV en Base, hacer staking y acuñar su propia API key de Venice sin intervención humana. El flujo completo:

<Steps>
  <Step title="Adquiere VVV y ETH para gas">
    Envía VVV al monedero del agente (o haz que el agente realice un swap en [Aerodrome](https://aerodrome.finance) o [Uniswap](https://app.uniswap.org)), más una pequeña cantidad de ETH en Base para las dos transacciones de staking.
  </Step>

  <Step title="Haz staking de VVV">
    `approve` al contrato de staking en el token VVV, después `stake(amount)` en `0x321b7ff75154472B18EDb199033fF4D116F340Ff`. El saldo de sVVV del monedero se actualiza atómicamente con el staking.
  </Step>

  <Step title="Acuña una API key">
    `GET /api/v1/api_keys/generate_web3_key` devuelve un JWT que expira 15 minutos después de su emisión. Firma el token sin procesar con el monedero de staking y luego `POST` la dirección, la firma y el token. Venice devuelve una API key vinculada a la cuenta de usuario derivada de ese monedero.
  </Step>
</Steps>

El minteo solo requiere un saldo de sVVV no nulo, así que 1 VVV en staking es suficiente para recibir una clave. **Gastar** con la clave es una cuestión separada, regida por la tabla de financiación anterior.

Consulta [Creación autónoma de API Key por agente](/guides/getting-started/generating-api-key-agent) para el recorrido completo con código y la referencia completa de errores.

## Auth de monedero x402 en 30 segundos

Si tu agente ya tiene un monedero en Base o Solana, sáltate la API key por completo. El SDK [`venice-x402-client`](https://github.com/veniceai/x402-client) gestiona la firma Sign-In-With-X, recargas y seguimiento de saldo.

```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) // sáltatelo si el monedero ya tiene saldo

const response = await venice.chat({
  model: 'kimi-k2-6',
  messages: [{ role: 'user', content: 'What is the latest block on Base?' }]
})
```

La misma auth de monedero funciona contra `/crypto/rpc/{network}` para lecturas y escrituras blockchain. Detalles completos del protocolo en la [guía de x402](/guides/integrations/x402-venice-api).

## Precios

El RPC cripto se factura en créditos de Venice. Cada respuesta incluye `X-Venice-RPC-Credits` (créditos cobrados) y `X-Venice-RPC-Cost-USD` (coste en dólares) para que tu agente pueda rastrear el gasto por solicitud.

### Créditos base por cadena

| Créditos base | Cadenas                                                                             |
| ------------- | ----------------------------------------------------------------------------------- |
| **20**        | Ethereum, Base, Optimism, Arbitrum, Polygon, Linea, Avalanche, BSC, Blast, Starknet |
| **30**        | zkSync Era                                                                          |

### Ejemplos de coste

Precios observados para niveles standard, advanced y large:

| Llamada                                         | Créditos | Coste en USD  |
| ----------------------------------------------- | -------- | ------------- |
| `eth_call` en Ethereum (20 × 1x)                | 20       | \~\$0.0000140 |
| `trace_transaction` en Ethereum (20 × 2x)       | 40       | \~\$0.0000280 |
| `trace_replayTransaction` en Ethereum (20 × 4x) | 80       | \~\$0.0000560 |
| `eth_call` en zkSync (30 × 1x)                  | 30       | \~\$0.0000210 |

Confía siempre en la cabecera de respuesta `X-Venice-RPC-Cost-USD` para el coste autoritativo. Los elementos con error en solicitudes por lote se facturan a una tarifa plana de 5 créditos cada uno.

### Límites de velocidad

| Nivel    | Solicitudes por minuto |
| -------- | ---------------------- |
| Standard | 100                    |
| Staff    | 1.000                  |

Al superarse, el endpoint devuelve `429` con las cabeceras de respuesta estándar `X-RateLimit-*`.

## Gestión de errores

Respuestas HTTP comunes que tu agente debería gestionar:

| Estado | Significado                                                                                                                                              | Qué hacer                                                                                                                                                                                                                                                    |
| ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `400`  | Método JSON-RPC no admitido o sin mapear, o lote mal formado                                                                                             | Verifica el método contra la [allowlist](/api-reference/endpoint/crypto/rpc). El cuerpo de error nombra el método infractor.                                                                                                                                 |
| `400`  | Replay de un `Idempotency-Key` con un cuerpo diferente                                                                                                   | Usa una clave nueva para solicitudes distintas.                                                                                                                                                                                                              |
| `402`  | Sin cabecera de auth (el cuerpo de la respuesta incluye `authOptions` con ambas rutas de auth admitidas), o sin créditos con una cabecera de auth válida | Si no hay auth: adjunta `Authorization: Bearer ...` o la cabecera x402 `X-Sign-In-With-X`. Si no hay créditos: con una clave Bearer, financia la cuenta (DIEM, USD o recarga vía dashboard); con auth x402, llama directamente a `POST /api/v1/x402/top-up`. |
| `429`  | Límite de velocidad alcanzado (100 req/min standard, 1.000 req/min staff)                                                                                | Respeta `X-RateLimit-Reset` y haz backoff. Agrupa hasta 100 llamadas por solicitud para amortizar el límite.                                                                                                                                                 |
| `5xx`  | Fallo del nodo RPC upstream                                                                                                                              | Reintenta con el mismo `Idempotency-Key` para evitar doble cobro.                                                                                                                                                                                            |

Los errores por elemento en lote (p. ej., parámetros inválidos en una de N llamadas) vuelven dentro de una respuesta `200 OK` con un campo `error` JSON-RPC en el elemento infractor. Esos elementos se facturan a una tarifa plana de 5 créditos cada uno.

## No admitido

Estas categorías de métodos se rechazan intencionadamente:

* **Solo WebSocket** (`eth_subscribe`, `eth_unsubscribe`): el proxy es solo HTTP. Usa polling en su lugar.
* **Filtros con estado** (`eth_newFilter`, `eth_getFilterChanges`, etc.): el estado del filtro está anclado a un único backend y falla en un proxy con balanceo de carga. Usa `eth_getLogs` en su lugar.
* **Métodos con clave** (`eth_sign`, `eth_accounts`, `eth_mining`): los proveedores alojados no guardan claves de usuario. Firma en el cliente y envía vía `eth_sendRawTransaction`.
* **Métodos no mapeados**: cualquier cosa no permitida explícitamente devuelve `400`. Contacta con soporte para solicitar adiciones.

## Recursos

<CardGroup cols={2}>
  <Card title="Referencia de la API Crypto RPC" icon="code" href="/api-reference/endpoint/crypto/rpc">
    Lista completa de métodos, precios y cabeceras de respuesta
  </Card>

  <Card title="Redes admitidas" icon="link" href="/api-reference/endpoint/crypto/networks">
    Lista en vivo de slugs de red admitidos
  </Card>

  <Card title="Auth de monedero x402" icon="wallet" href="/guides/integrations/x402-venice-api">
    Autentica y paga con un monedero de Base o Solana
  </Card>

  <Card title="API Key de agente autónomo" icon="robot" href="/guides/getting-started/generating-api-key-agent">
    Acuña tu propia clave haciendo staking de VVV
  </Card>

  <Card title="Colección de Postman" icon="play" href="https://www.postman.com/veniceai/workspace/venice-ai-workspace/folder/38652128-2cf5a817-41cd-438b-ad37-5d07c3f13005?action=share&creator=48156591&active-environment=38652128-ef110f4e-d3e1-43b5-8029-4d6877e62041">
    27 ejemplos de Crypto RPC listos para ejecutar
  </Card>

  <Card title="Precios" icon="coins" href="/overview/pricing">
    DIEM, precios de créditos y opciones de pago
  </Card>
</CardGroup>