> ## 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 Trade > Point de terminaison de transaction swap construite côté serveur de Raydium : devis, construction, signature, envoi. Le modèle d'intégration pour les applications qui souhaitent le routage Raydium sans expédier le SDK — ce qu'il retourne, comment il diffère du SDK, et comment les agrégateurs le consomment. **Cette page est traduite automatiquement par IA. La version anglaise fait foi.** [Voir la version anglaise →](/sdk-api/trade-api) L'**API Trade** est un ensemble mince de points de terminaison sur `transaction-v1.raydium.io` (et certains chemins en miroir sur `api-v3.raydium.io`) qui quote un swap, construit une transaction Solana signée et prête, et la retourne en un seul aller-retour. C'est la même surface que l'interface Raydium utilise. Utilisez-la quand vous voulez le routage Raydium sans embarquer le TS SDK — backends, gestionnaires Blinks, bots Telegram, applications tierces. ## Quand utiliser l'API Trade par rapport au SDK | Vous voulez… | Utilisez | | -------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- | | Intégrer les swaps dans un backend qui ne peut pas embarquer les paquets npm (par ex. bot Python, service Go, service Rust) | **API Trade** | | Afficher un Blink swap dans une publication sociale | **API Trade** | | Construire une application browser où chaque kilooctet compte | **API Trade** | | Embarquer la logique de routage dans un autre programme Solana (CPI) | Aucun — utilisez [`sdk-api/rust-cpi`](/fr/sdk-api/rust-cpi) | | Construire un client complet de type DEX avec aperçu de route personnalisé, superpositions de graphiques, heuristiques de frais prioritaires | **TS SDK** | | Besoin d'une citation hors ligne déterministe sans aller-retour réseau | **TS SDK** (avec état de pool local) | Le SDK est plus riche ; l'API Trade est plus simple. Les deux enveloppent les mêmes programmes CPMM/CLMM/AMM v4 sous-jacents, donc le swap on-chain résultant est identique. ## Les trois points de terminaison ### 1. `GET /compute/swap-base-in` Étant donné un montant d'entrée, choisissez une route et retournez un devis. ``` GET https://transaction-v1.raydium.io/compute/swap-base-in ?inputMint=So11111111111111111111111111111111111111112 &outputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v &amount=1000000000 &slippageBps=50 &txVersion=V0 ``` Réponse : ```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..." } ] } } ``` Le champ `id` est un handle de devis opaque transmis au point de terminaison suivant. Le devis est stable pendant \~30 secondes ; au-delà, re-cotez. ### 2. `GET /compute/swap-base-out` Forme inversée : « Je veux recevoir exactement N de la sortie ; citez-moi l'entrée requise. » ``` GET /compute/swap-base-out ?inputMint= &outputMint= &amount= &slippageBps=50 &txVersion=V0 ``` Forme de réponse symétrique à `swap-base-in` ; la sémantique du champ `amount` s'inverse. ### 3. `POST /transaction/swap-base-in` et `/transaction/swap-base-out` Prend le devis de l'étape 1 et retourne une transaction versionnée signée et prête : ``` POST https://transaction-v1.raydium.io/transaction/swap-base-in Content-Type: application/json { "computeUnitPriceMicroLamports": "50000", "swapResponse": { ... collez l'objet data de swap-base-in ... }, "txVersion": "V0", "wallet": "", "wrapSol": true, "unwrapSol": false, "inputAccount": "", "outputAccount": "" } ``` Réponse : ```json theme={null} { "id": "9f1c...", "success": true, "version": "V1", "data": [ { "transaction": "" } ] } ``` Plusieurs transactions peuvent être retournées si le swap nécessite une configuration (par ex. créer des ATA, emballer SOL). Signez et envoyez-les dans l'ordre. ## Exemple minimal de bout en bout (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([...])) # your signer 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}") ``` C'est \~20 lignes. L'équivalent avec le TS SDK est \~30 mais vous donne un contrôle plus riche (sélecteur de route personnalisé, budgétisation de l'unité de calcul par pool, métadonnées d'erreur détaillées). ## Routage et sélection du pool L'API Trade route sur **tous** les programmes Raydium (CPMM, CLMM, AMM v4) et choisit la meilleure exécution pour la taille cotée. Caractéristiques : * **Multi-hop supporté.** Un swap SOL→USDC peut router par wSOL→JUP→USDC si c'est moins cher. * **Fractionnement multi-pool au sein du même programme non supporté.** Un seul devis passe par exactement un chemin ; si vous voulez fractionner la taille entre les pools, faites-le côté client (deux devis, deux tx). * **Stable vs concentré.** Le routeur préfère utiliser CLMM quand la liquidité en plage est adéquate, revenant à CPMM pour les paires de queue longue. * **Inclusion d'AMM v4.** Les pools AMM v4 sont inclus dans le routage mais seulement choisis quand ils offrent une meilleure tarification que les alternatives CPMM/CLMM. Pour forcer le routage via un pool spécifique, utilisez le SDK à la place — l'API Trade n'expose pas de paramètre de fixation de pool. ## Paramètre Referrer Ajoutez `&referrer=` au point de terminaison compute pour prendre une réduction de parrainage de 1 % sur le swap. Voir [`user-flows/referrals-and-blinks`](/fr/user-flows/referrals-and-blinks) pour la sémantique. Quand présent : * `referrerAmount` dans la réponse de devis est le montant absolu (en mint d'entrée) qui sera acheminé au parrain. * La transaction finale contient un transfert de jeton SPL supplémentaire vers l'ATA du parrain. ## Frais prioritaires `computeUnitPriceMicroLamports` dans la demande de construction définit les frais prioritaires pour la transaction retournée. Règle générale : * `50_000` (0,00005 lamports/CU × 200k CU ≈ 0,00001 SOL) : minimal, bien pour les moments non congestionnés. * `200_000` : congestion modérée. * `1_000_000` : congestion intense. Pour un ajustement adaptatif, appelez d'abord `getRecentPrioritizationFees` sur votre RPC et transmettez la médiane. Voir [`integration-guides/priority-fee-tuning`](/fr/integration-guides/priority-fee-tuning). ## Versions de transaction * `"V0"` retourne une transaction versionnée (`MessageV0`) avec une table de recherche pour les comptes courants. Plus petit, plus rapide. **Recommandé.** * `"LEGACY"` retourne une transaction héritée. Plus large ; utilisez uniquement si votre portefeuille/infrastructure ne gère pas V0. ## Formes d'erreur L'API retourne HTTP 200 avec `success: false` pour les erreurs logiques, HTTP 4xx/5xx pour les erreurs de transport / infra. Erreurs logiques communes : * `"No route found"` — aucun chemin entre les deux mints à cette taille. Réduisez `amount` ou reconsidérez la paire. * `"Insufficient liquidity"` — une route existe mais dépasserait `slippageBps`. Élargissez le slippage. * `"Quote expired"` — `swapResponse` a plus de 30 secondes. Re-cotez. * `"Unsupported mint"` — le mint n'est pas dans l'univers Raydium (non listé, ou sur un programme obsolète). ## Limites de débit * **Points de terminaison de devis :** 120 req/min par IP. * **Points de terminaison de construction :** 60 req/min par IP (coût plus élevé sur le serveur). * Dépasser les limites retourne HTTP 429 avec l'en-tête `Retry-After`. Pour un débit plus élevé, contactez les relations développeurs de Raydium ; des clés de niveau agrégateur sont disponibles. ## Modèle architectural pour les intégrateurs ``` ┌─────────────┐ quote ┌───────────────┐ build ┌───────────────┐ sign/send ┌──────────┐ │ Votre front │──────────►│ API Trade │──────────►│ API Trade │──────────────►│ Solana │ │ end │◄──────────│ /compute/... │◄──────────│ /transaction/ │ │ RPC │ └─────────────┘ └───────────────┘ └───────────────┘ └──────────┘ (sans état) (sans état) ``` Tout est sans état — la seule chose que vous devez passer entre l'appel de devis et l'appel de construction est le corps de la réponse de devis lui-même. ## Où aller ensuite * [`sdk-api/typescript-sdk`](/fr/sdk-api/typescript-sdk) — interface programmatique plus riche avec les mêmes programmes sous-jacents. * [`sdk-api/rest-api`](/fr/sdk-api/rest-api) — points de terminaison côté lecture (info pool, info mint) pour compléter le côté écriture de l'API Trade. * [`user-flows/swap`](/fr/user-flows/swap) — flux de swap d'interface utilisateur de bout en bout. * [`integration-guides/aggregator`](/fr/integration-guides/aggregator) — modèle pour les agrégateurs qui routent sur de nombreux DEX. Sources : * Points de terminaison live `transaction-v1.raydium.io`. * Inspection de l'onglet réseau de l'interface Raydium (même surface consommée).