> ## 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. # API de Trading > Endpoint de transacción de swap construida en servidor de Raydium: cotización, construcción, firma, envío. El patrón de integración para aplicaciones que desean enrutamiento de Raydium sin incluir el SDK — qué devuelve, cómo difiere del SDK y cómo lo consumen los agregadores. **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 →](/sdk-api/trade-api) El **API de Trading** es un conjunto delgado de endpoints en `transaction-v1.raydium.io` (y algunas rutas espejadas en `api-v3.raydium.io`) que cotizan un swap, construyen una transacción de Solana lista para firmar y la devuelven en un viaje redondo. Es la misma superficie que usa la interfaz de Raydium. Úsalo cuando quieras enrutamiento de Raydium sin incluir el SDK de TypeScript — backends, manejadores de Blinks, bots de Telegram, aplicaciones de terceros. ## Cuándo usar el API de Trading frente al SDK | Quieres… | Usa | | ------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------- | | Integrar swaps en un backend que no puede empaquetar paquetes npm (p. ej., bot Python, servicio Go, servicio Rust) | **API de Trading** | | Renderizar un Blink de swap en una publicación social | **API de Trading** | | Construir una aplicación de navegador donde ahorrar kilobytes importa | **API de Trading** | | Integrar lógica de enrutamiento dentro de otro programa de Solana (CPI) | Ninguno — usa [`sdk-api/rust-cpi`](/es/sdk-api/rust-cpi) | | Construir un cliente similar a un DEX completo con vista previa de ruta personalizada, superposiciones de gráficos, heurísticas de tarifa de prioridad | **SDK de TS** | | Necesitas cotización determinista sin conexión sin viaje de red | **SDK de TS** (con estado de pool local) | El SDK es más rico; el API de Trading es más simple. Ambos envuelven los mismos programas CPMM/CLMM/AMM v4 subyacentes, por lo que el swap en cadena resultante es idéntico. ## Los tres endpoints ### 1. `GET /compute/swap-base-in` Dado un monto de entrada, selecciona una ruta y devuelve una cotización. ``` GET https://transaction-v1.raydium.io/compute/swap-base-in ?inputMint=So11111111111111111111111111111111111111112 &outputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v &amount=1000000000 &slippageBps=50 &txVersion=V0 ``` Respuesta: ```json theme={null} { "id": "b2e4...", "success": true, "version": "V1", "data": { "swapType": "BaseIn", "inputMint": "So11111111111111111111111111111111111111112", "inputAmount": "1000000000", "outputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "outputAmount": "165234567", "otherAmountThreshold": "164408394", "slippageBps": 50, "priceImpactPct": 0.0012, "referrerAmount": "0", "routePlan": [ { "poolId": "58oQ...", "inputMint": "So11...", "outputMint": "USDC...", "feeAmount": "2500000", "feeMint": "So11..." } ] } } ``` El campo `id` es un manejador de cotización opaco pasado al siguiente endpoint. La cotización es estable durante \~30 segundos; después de eso, vuelve a cotizar. ### 2. `GET /compute/swap-base-out` Forma invertida: "Quiero recibir exactamente N de la salida; cótame la entrada requerida". ``` GET /compute/swap-base-out ?inputMint= &outputMint= &amount= &slippageBps=50 &txVersion=V0 ``` Forma de respuesta simétrica a `swap-base-in`; la semántica del campo `amount` se invierte. ### 3. `POST /transaction/swap-base-in` y `/transaction/swap-base-out` Toma la cotización del paso 1 y devuelve una transacción con versión lista para firmar: ``` POST https://transaction-v1.raydium.io/transaction/swap-base-in Content-Type: application/json { "computeUnitPriceMicroLamports": "50000", "swapResponse": { ... pega el objeto de datos de swap-base-in ... }, "txVersion": "V0", "wallet": "", "wrapSol": true, "unwrapSol": false, "inputAccount": "", "outputAccount": "" } ``` Respuesta: ```json theme={null} { "id": "9f1c...", "success": true, "version": "V1", "data": [ { "transaction": "" } ] } ``` Se pueden devolver múltiples transacciones si el swap requiere configuración (p. ej., crear ATAs, envolver SOL). Firma y envía en orden. ## Ejemplo mínimo de extremo a extremo (Python) ```python theme={null} import base64, requests from solders.transaction import VersionedTransaction from solders.keypair import Keypair from solana.rpc.api import Client rpc = Client("https://api.mainnet-beta.solana.com") kp = Keypair.from_bytes(bytes([...])) # tu firmante SOL = "So11111111111111111111111111111111111111112" USDC = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" quote = requests.get( "https://transaction-v1.raydium.io/compute/swap-base-in", params={ "inputMint": SOL, "outputMint": USDC, "amount": 1_000_000_000, "slippageBps": 50, "txVersion": "V0", }, ).json() built = requests.post( "https://transaction-v1.raydium.io/transaction/swap-base-in", json={ "computeUnitPriceMicroLamports": "50000", "swapResponse": quote, "txVersion": "V0", "wallet": str(kp.pubkey()), "wrapSol": True, "unwrapSol": False, }, ).json() for entry in built["data"]: raw = base64.b64decode(entry["transaction"]) tx = VersionedTransaction.from_bytes(raw) tx.sign([kp]) sig = rpc.send_raw_transaction(bytes(tx)).value print(f"Sent: {sig}") ``` Son \~20 líneas. Lo equivalente con el SDK de TS son \~30 pero te da un control más rico (selector de ruta personalizado, presupuesto de unidad de cómputo por pool, metadatos de error detallados). ## Enrutamiento y selección de pool El API de Trading enruta a través de **todos** los programas de Raydium (CPMM, CLMM, AMM v4) y elige la mejor ejecución para el tamaño cotizado. Características: * **Saltos múltiples soportados.** Un swap SOL→USDC puede enrutarse a través de wSOL→JUP→USDC si eso es más barato. * **División de múltiples pools del mismo programa no soportada.** Una única cotización va a través de exactamente un camino; si deseas dividir tamaño entre pools, hazlo del lado del cliente (dos cotizaciones, dos txs). * **Estable vs concentrado.** El enrutador prefiere usar CLMM cuando la liquidez en rango es adecuada, recurriendo a CPMM para pares de cola larga. * **Inclusión de AMM v4.** Los pools de AMM v4 se incluyen en el enrutamiento pero solo se eligen cuando ofrecen mejor precio que las alternativas CPMM/CLMM. Para forzar el enrutamiento a través de un pool específico, usa el SDK en su lugar — el API de Trading no expone un parámetro de fijación de pool. ## Parámetro de referidor Añade `&referrer=` al endpoint de cómputo para tomar un corte de referencia del 1% en el swap. Consulta [`user-flows/referrals-and-blinks`](/es/user-flows/referrals-and-blinks) para la semántica. Cuando está presente: * `referrerAmount` en la respuesta de cotización es la cantidad absoluta (en mint de entrada) que se enrutará al referidor. * La transacción final contiene una transferencia extra de token SPL a la ATA del referidor. ## Tarifas de prioridad `computeUnitPriceMicroLamports` en la solicitud de construcción establece la tarifa de prioridad para la transacción devuelta. Regla general: * `50_000` (0.00005 lamports/CU × 200k CU ≈ 0.00001 SOL): mínimo, bien para momentos sin congestión. * `200_000`: congestión moderada. * `1_000_000`: congestión pesada. Para ajuste adaptativo, llama a `getRecentPrioritizationFees` en tu RPC primero y pasa la mediana. Consulta [`integration-guides/priority-fee-tuning`](/es/integration-guides/priority-fee-tuning). ## Versiones de transacción * `"V0"` devuelve una transacción con versión (`MessageV0`) con una tabla de búsqueda para cuentas comunes. Más pequeña, más rápida. **Recomendada.** * `"LEGACY"` devuelve una transacción heredada. Más grande; solo úsala si tu cartera/infraestructura no maneja V0. ## Formas de error El API devuelve HTTP 200 con `success: false` para errores lógicos, HTTP 4xx/5xx para errores de transporte / infraestructura. Errores lógicos comunes: * `"No route found"` — sin camino entre los dos mints en este tamaño. Reduce `amount` o reconsideran el par. * `"Insufficient liquidity"` — existe una ruta pero rebasaría `slippageBps`. Amplía el slippage. * `"Quote expired"` — `swapResponse` tiene >30s. Vuelve a cotizar. * `"Unsupported mint"` — mint no está en el universo de Raydium (sin listar, o en un programa deprecado). ## Límites de velocidad * **Endpoints de cotización:** 120 req/min por IP. * **Endpoints de construcción:** 60 req/min por IP (costo más alto en el servidor). * Exceder límites devuelve HTTP 429 con encabezado `Retry-After`. Para mayor rendimiento, contacta a las relaciones de desarrolladores de Raydium; hay claves de nivel agregador disponibles. ## Patrón arquitectónico para integradores ``` ┌─────────────┐ cotización ┌───────────────┐ construcción ┌───────────────┐ firma/envío ┌──────────┐ │ Tu interfaz │──────────────►│ API de Trading│──────────────►│ API de Trading│──────────────────►│ Solana │ │ frontal │◄──────────────│ /compute/... │◄──────────────│ /transaction/ │ │ RPC │ └─────────────┘ └───────────────┘ └───────────────┘ └──────────┘ (sin estado) (sin estado) ``` Todo es sin estado — la única cosa que necesitas enhebrar entre la llamada de cotización y la llamada de construcción es el cuerpo de respuesta de la cotización. ## Dónde ir a continuación * [`sdk-api/typescript-sdk`](/es/sdk-api/typescript-sdk) — interfaz programática más rica con los mismos programas subyacentes. * [`sdk-api/rest-api`](/es/sdk-api/rest-api) — endpoints del lado de lectura (información de pool, información de mint) para complementar el lado de escritura del API de Trading. * [`user-flows/swap`](/es/user-flows/swap) — flujo de swap de interfaz de extremo a extremo. * [`integration-guides/aggregator`](/es/integration-guides/aggregator) — patrón para agregadores que enrutan a través de muchos DEXes. Fuentes: * Endpoints en vivo de `transaction-v1.raydium.io`. * Inspección de pestaña de red de la interfaz de Raydium (misma superficie consumida).