> ## Documentation Index
> Fetch the complete documentation index at: https://docs.raydium.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Descripción General de la API de Transacciones

> Constructor de transacciones de intercambio del lado del servidor para Solana.

<Info>
  **Esta página fue traducida automáticamente por IA. La versión en inglés es la fuente autorizada.**

  [Ver versión en inglés →](/api-reference/route-api-v2/overview)
</Info>

## ¿Qué es la API de Transacciones?

La API de Transacciones de Raydium (Route V2) es un servicio del lado del servidor que construye transacciones de intercambio de Solana serializadas sin requerir que los clientes mantengan una conexión RPC o incluyan el SDK completo de Raydium. Esto simplifica drásticamente la integración para:

* Interfaces web que no pueden ejecutar un cliente RPC local
* Aplicaciones móviles con recursos limitados
* Bots de trading sin interfaz
* Agregadores y proveedores de monederos

En lugar de realizar enrutamiento complejo de pools y construcción de transacciones en el cliente, solicitas cotizaciones de intercambio y construcción de transacciones a nuestra API, luego firmas y transmites el resultado usando cualquier RPC de Solana.

## Descripción General del Flujo de Trabajo

La API de Transacciones separa las responsabilidades en dos fases:

### 1. Fase de Cálculo: Obtener una Cotización

Llama a `/compute/swap-base-in` o `/compute/swap-base-out` para recibir el resultado esperado del intercambio (o entrada requerida) basado en los estados actuales de los pools. Este endpoint es **de solo lectura** y no requiere ninguna firma:

```bash theme={null}
GET /compute/swap-base-in?inputMint=EPjF...&outputMint=So111...&amount=1000000&slippageBps=50&txVersion=V0
```

La respuesta incluye:

* Cantidad de salida esperada
* Desglose de ruta (qué pools y fuentes de liquidez se utilizan)
* Impacto de precio

### 2. Fase de Transacción: Construir y Firmar

Una vez que tengas la respuesta de cálculo, pásala (junto con la cartera y la configuración) a `/transaction/swap-base-in` o `/transaction/swap-base-out`:

```bash theme={null}
POST /transaction/swap-base-in
Content-Type: application/json

{
  "wallet": "YourWalletAddress",
  "swapResponse": { ...response from /compute/swap-base-in },
  "txVersion": "V0",
  "computeUnitPriceMicroLamports": "1000",
  "wrapSol": false,
  "unwrapSol": false,
  "inputAccount": "TokenAccount1...",
  "outputAccount": "TokenAccount2..."
}
```

La respuesta contiene:

* Una transacción versionada codificada en base64 lista para firmar
* Direcciones de tabla de búsqueda de direcciones (si txVersion=V0)

Tu cliente entonces:

1. Decodifica la transacción
2. La firma con la clave privada del usuario
3. La transmite a través de cualquier RPC de Solana
4. Aguarda la confirmación

## Endpoints de Cálculo

### `GET /compute/swap-base-in`

**Caso de uso**: El usuario especifica la cantidad de entrada, calculamos la salida.

**Parámetros de consulta requeridos**:

* `inputMint` – Dirección mint del token que envías
* `outputMint` – Dirección mint del token que deseas
* `amount` – Cantidad de entrada en lamports (unidad más pequeña)
* `slippageBps` – Deslizamiento máximo aceptable en puntos base (0–10000)
* `txVersion` – `V0` o `LEGACY`

**Opcional**:

* `referrerBps` – Si tienes una autoridad de referidor, puntos base de la salida a recaudar como tarifa de referidor

### `GET /compute/swap-base-out`

**Caso de uso**: El usuario especifica la salida deseada, calculamos la entrada requerida.

**Parámetros de consulta requeridos**:

* `inputMint`, `outputMint`, `amount` (salida deseada), `slippageBps`, `txVersion`

**Nota**: Sin puntos base de referidor para base-out (aún no implementado).

## Endpoints de Transacción

### `POST /transaction/swap-base-in`

Construye una transacción para una cantidad de entrada fija.

**Cuerpo requerido**:

* `wallet` – Tu dirección de cartera de firma
* `swapResponse` – El objeto de respuesta de cálculo completo
* `txVersion` – Versión de transacción
* `computeUnitPriceMicroLamports` – Tarifa de prioridad en micro-lamports

**Opcional**:

* `wrapSol` – Si es verdadero, envuelve SOL nativo para entrada
* `unwrapSol` – Si es verdadero, desenvuelve WSOL a SOL en salida
* `inputAccount` – Cuenta de token para entrada (requerida si no envuelves SOL)
* `outputAccount` – Cuenta de token para salida
* `nonceInfo` – Nonce duradero para firma sin conexión
* `jitoInfo` – Parámetros de paquete de protección MEV de Jito
* `referrerWallet` – Cartera de referidor para recaudación de tarifas

### `POST /transaction/swap-base-out`

Construye una transacción para una cantidad de salida fija.

**Los mismos parámetros que base-in**, excepto:

* El campo `referrerInfo` está comentado actualmente (aún no implementado)

## Envoltorio de Respuesta

Todos los endpoints devuelven un envoltorio estándar:

```json theme={null}
{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "success": true,
  "version": "V1",
  "data": { ... }
}
```

En caso de error, `success` es `false` y `msg` contiene el código de error (por ejemplo, `REQ_WALLET_ERROR`, `REQ_SLIPPAGE_BPS_ERROR`).

## Forma de Respuesta de Transacción

Una respuesta de transacción exitosa se ve así:

```json theme={null}
{
  "id": "...",
  "success": true,
  "version": "V1",
  "data": {
    "transaction": "AgABB...",  // Base64-encoded transaction
    "addressLookupTableAddresses": ["Address1...", "Address2..."]  // For V0 only
  }
}
```

## Ejemplo de Integración

Aquí hay un flujo típico en pseudocódigo:

```typescript theme={null}
// 1. Get quote
const quote = await fetch(
  'https://transaction-v1.raydium.io/compute/swap-base-in?' +
  'inputMint=EPjF...&outputMint=So111...&amount=1000000&slippageBps=50&txVersion=V0'
).then(r => r.json());

// 2. Validate quote
if (!quote.success) {
  throw new Error(quote.msg);
}

// 3. Build transaction
const tx = await fetch(
  'https://transaction-v1.raydium.io/transaction/swap-base-in',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      wallet: userWalletAddress,
      swapResponse: quote,
      txVersion: 'V0',
      computeUnitPriceMicroLamports: '1000',
      inputAccount: userInputTokenAccount,
      outputAccount: userOutputTokenAccount,
    }),
  }
).then(r => r.json());

// 4. Decode and sign
const transaction = VersionedTransaction.deserialize(
  Buffer.from(tx.data.transaction, 'base64')
);
transaction.sign([userKeypair]);

// 5. Send via RPC
const rpc = new Connection('https://api.mainnet-beta.solana.com');
const sig = await rpc.sendTransaction(transaction);
await rpc.confirmTransaction(sig);
```

## Parámetros Clave Explicados

### `txVersion`

* **V0**: Transacción moderna de Solana con Tablas de Búsqueda de Direcciones (ALTs). Tamaño de serialización más pequeño, tarifas más bajas.
* **LEGACY**: Formato de transacción anterior a ALT. Más grande, pero funciona con todos los endpoints RPC.

Elige **V0** cuando sea posible; retrocede a **LEGACY** si tu RPC o cartera no admite ALTs.

### `computeUnitPriceMicroLamports`

Tarifa de prioridad para inclusión más rápida en bloques. Establece en `0` sin tarifa de prioridad, o valores más altos (por ejemplo, `1000`) para competir en redes congestionadas. Las unidades son micro-lamports por unidad de computación.

### `slippageBps`

Tolerancia de deslizamiento máximo en puntos base. `100` = 1%, `50` = 0.5%.

* Usa valores más bajos (por ejemplo, 25–50 bps) para intercambios más estables
* Aumenta para pares volátiles o de baja liquidez

### `wrapSol` y `unwrapSol`

* **wrapSol**: Si es `true`, la API envuelve tu SOL nativo en WSOL. No se necesita `inputAccount`.
* **unwrapSol**: Si es `true`, la API desenvuelve el WSOL de salida nuevamente a SOL nativo. No se necesita `outputAccount`.

Si ambos son `false`, debes proporcionar cuentas de token explícitas.

## Endpoints de Red

| Red       | Mainnet                     | Devnet                             |
| --------- | --------------------------- | ---------------------------------- |
| Host      | `transaction-v1.raydium.io` | `transaction-v1-devnet.raydium.io` |
| Protocolo | HTTPS                       | HTTPS                              |

## Códigos de Error

Mensajes de error comunes:

| Código                    | Significado                                                          |
| ------------------------- | -------------------------------------------------------------------- |
| `REQ_SLIPPAGE_BPS_ERROR`  | El deslizamiento es inválido o está fuera de rango                   |
| `REQ_INPUT_MINT_ERROR`    | La dirección mint de entrada es inválida                             |
| `REQ_OUTPUT_MINT_ERROR`   | La dirección mint de salida es inválida                              |
| `REQ_AMOUNT_ERROR`        | La cantidad no es un número válido                                   |
| `REQ_TX_VERSION_ERROR`    | txVersion debe ser V0 o LEGACY                                       |
| `REQ_WALLET_ERROR`        | La dirección de cartera es inválida                                  |
| `REQ_INPUT_ACCOUT_ERROR`  | Cuenta de token de entrada faltante o inválida                       |
| `REQ_OUTPUT_ACCOUT_ERROR` | Cuenta de token de salida faltante o inválida                        |
| `UNKNOWN_ERROR`           | Error del lado del servidor; verifica los parámetros de tu solicitud |

## Ver También

* [Especificación OpenAPI](/es/api-reference/openapi/route-api-v2.yaml)
* [Guía de Integración de Agregadores](/es/integration-guides/aggregator)