Passer au contenu principal

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.

Cette page est traduite automatiquement par IA. La version anglaise fait foi.Voir la version anglaise →
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 socialeAPI Trade
Construire une application browser où chaque kilooctet compteAPI Trade
Embarquer la logique de routage dans un autre programme Solana (CPI)Aucun — utilisez sdk-api/rust-cpi
Construire un client complet de type DEX avec aperçu de route personnalisé, superpositions de graphiques, heuristiques de frais prioritairesTS SDK
Besoin d’une citation hors ligne déterministe sans aller-retour réseauTS 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 : 
{
  "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=<MINT_IN>
  &outputMint=<MINT_OUT>
  &amount=<DESIRED_OUTPUT_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": "<user_pubkey>",
  "wrapSol": true,
  "unwrapSol": false,
  "inputAccount": "<optional_token_account>",
  "outputAccount": "<optional_token_account>"
}
Réponse : 
{
  "id": "9f1c...",
  "success": true,
  "version": "V1",
  "data": [
    { "transaction": "<base64-encoded-versioned-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)

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=<wallet_pubkey> au point de terminaison compute pour prendre une réduction de parrainage de 1 % sur le swap. Voir 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.

​
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 — interface programmatique plus riche avec les mêmes programmes sous-jacents.
  • 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 — flux de swap d’interface utilisateur de bout en bout.
  • 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).