Build and send Solana swaps with Raptor

Get a Solana swap quote, build and sign a transaction, submit it with Raptor, and track its status. Includes streaming quote examples.

Raptor finds a route and builds the swap transaction. Your app signs it with the user’s wallet, submits the signed bytes, and checks the result. Use the separate quote and build steps when the user needs to review a price first.

HTTP Base URL: https://raptor-beta.solanatracker.io
WebSocket Base URL: wss://raptor-beta.solanatracker.io
Raptor is currently in public beta.

Supported routing

Raptor routes across venues and pool types including Raydium, Meteora, Orca Whirlpool, Pump.fun, Pumpswap, MoonIt, Boopfun, FluxBeam, PancakeSwap V3, and more.

Use dexes when you want to restrict routing to a subset of supported venues.

1. Get a quote

Request a route with Get swap quote. Supply:

• inputMint
• outputMint
• amount in smallest units, which means blockchain integer amounts with no decimals
• optional slippageBps in basis points, where 50 means 0.5%
• optional routing controls like dexes, pools, and maxHops

cURL

curl "https://raptor-beta.solanatracker.io/quote?inputMint=So11111111111111111111111111111111111111112&outputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&amount=100000000&slippageBps=50"

Restrict routes

curl "https://raptor-beta.solanatracker.io/quote?inputMint=So11111111111111111111111111111111111111112&outputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&amount=100000000&slippageBps=dynamic&dexes=raydium,meteora,pumpfun&maxHops=2"

2. Build a swap transaction

Use Build swap transaction to create a serialized transaction.

Send this request body:

• userPublicKey
• quoteResponse from /quote
• optional transaction tuning like priorityFee, txVersion, computeUnitLimit, tipLamports, and platform fee fields

JavaScript

const quote = await fetch(
  "https://raptor-beta.solanatracker.io/quote?inputMint=So11111111111111111111111111111111111111112&outputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&amount=100000000&slippageBps=50"
).then(r => r.json());

const swap = await fetch("https://raptor-beta.solanatracker.io/swap", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    userPublicKey: "YOUR_WALLET_ADDRESS",
    wrapUnwrapSol: true,
    txVersion: "V0",
    priorityFee: "medium",
    maxPriorityFee: 1000000,
    quoteResponse: quote
  })
}).then(r => r.json());

console.log(`Swap tx: ${swap.swapTransaction}`);
console.log(`Last valid block height: ${swap.lastValidBlockHeight}`);
console.log(`Priority fee: ${swap.prioritizationFeeLamports}`);

Transaction controls

Field	Purpose
txVersion	LEGACY or V0
priorityFee	priority level like medium, high, veryHigh or exact microlamports
maxPriorityFee	cap dynamic priority fees
computeUnitPriceMicroLamports	Priority fee: override compute-unit price directly
computeUnitLimit	override CU limit
tipAccount / tipLamports	add optional SOL tip
feeAccount / feeBps / feeFromInput / chargeBps	platform fee controls

Token accounts and SOL wrapping

The /swap response includes setup and cleanup instructions for the swap:

• Associated Token Accounts (ATAs) — Raptor adds createAssociatedTokenAccountIdempotent instructions to setupInstructions for any input, output, or intermediate mint where the user does not already have an ATA. You do not need to pre-create ATAs for the output token; the rent (~0.00203 SOL per account) is paid by userPublicKey. If you build your own transaction from /swap-instructions, keep the setupInstructions and cleanupInstruction arrays — that is where ATA creation and SOL wrap/unwrap live.
• SOL wrapping — wrapUnwrapSol defaults to true. Raptor wraps SOL into wSOL in setupInstructions when SOL is the input, and unwraps any remaining wSOL back to native SOL in cleanupInstruction when SOL is the output. Set wrapUnwrapSol: false only if you are managing a long-lived wSOL account yourself.

3. Sign in the wallet

Raptor returns swapTransaction as base64. Sign it in the wallet, then send the signed base64 transaction.

import { VersionedTransaction } from "@solana/web3.js";

const txBytes = Uint8Array.from(atob(swap.swapTransaction), c => c.charCodeAt(0));
const tx = VersionedTransaction.deserialize(txBytes);

const signed = await wallet.signTransaction(tx);
const signedBase64 = btoa(String.fromCharCode(...signed.serialize()));

4. Send the signed transaction

Send signed transactions with raptor/transactions: POST /send-transaction.

const sendResult = await fetch("https://raptor-beta.solanatracker.io/send-transaction", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ transaction: signedBase64 })
}).then(r => r.json());

console.log(`Signature: ${sendResult.signature}`);
console.log(`Accepted: ${sendResult.success}`);

Raptor sends through Yellowstone Jet TPU and retries in the background until the transaction confirms or expires.

Track status

const status = await fetch(
  `https://raptor-beta.solanatracker.io/transaction/${sendResult.signature}`
).then(r => r.json());

console.log(`Status: ${status.status}`);
console.log(`Latency: ${status.latency_ms}ms`);
console.log(`Slot: ${status.slot}`);

Valid statuses are pending, confirmed, failed, and expired.

Quote and build in one request

Use Quote and swap in one request if you want a single request instead of separate /quote and /swap calls.

const result = await fetch("https://raptor-beta.solanatracker.io/quote-and-swap", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    userPublicKey: "YOUR_WALLET_ADDRESS",
    inputMint: "So11111111111111111111111111111111111111112",
    outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    amount: 100000000,
    slippageBps: "dynamic",
    txVersion: "V0",
    priorityFee: "high",
    maxHops: 2,
    dexes: "raydium,meteora,whirlpool"
  })
}).then(r => r.json());

console.log(result.quote.amountOut);
console.log(result.swapTransaction);

Build instructions only

Use Build swap instructions when you want instructions without a transaction wrapper.

const instructions = await fetch("https://raptor-beta.solanatracker.io/swap-instructions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    userPublicKey: "YOUR_WALLET_ADDRESS",
    quoteResponse: quote,
    txVersion: "V0"
  })
}).then(r => r.json());

console.log(instructions.swapInstruction.programId);
console.log(instructions.addressLookupTableAddresses);

Atomic buy → sell in one transaction (token ledger)

For a buy followed by a sell in one transaction, the second leg may need the first leg’s actual output. A token ledger records that amount during execution so the next instruction can read it.

The flow is:

1. Call /swap-instructions for the buy leg (e.g. SOL → TOKEN on pool 1). Use the returned tokenLedgerInstruction to capture the on-chain output amount.
2. Call /swap-instructions for the sell leg (e.g. TOKEN → SOL on pool 2). The sell instruction reads its input amount from the token ledger written by the buy leg.
3. Assemble both calls’ computeBudgetInstructions, setupInstructions, tokenLedgerInstruction, swapInstruction, and cleanupInstruction into a single VersionedTransaction. Deduplicate setup/cleanup instructions and combine the addressLookupTableAddresses from both responses.
4. Sign once and submit through /send-transaction.

// 1. Buy leg: SOL -> TOKEN on pool 1
const buy = await fetch("https://raptor-beta.solanatracker.io/swap-instructions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    userPublicKey: WALLET,
    quoteResponse: buyQuote,     // from /quote restricted to pool 1
    txVersion: "V0"
  })
}).then(r => r.json());

// 2. Sell leg: TOKEN -> SOL on pool 2.
//    amountIn in sellQuote is a placeholder — the ledger overrides it at runtime.
const sell = await fetch("https://raptor-beta.solanatracker.io/swap-instructions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    userPublicKey: WALLET,
    quoteResponse: sellQuote,    // from /quote restricted to pool 2
    txVersion: "V0"
  })
}).then(r => r.json());

// 3. Assemble: compute budget + setup + tokenLedger + buy swap + sell swap + cleanup
const instructions = [
  ...buy.computeBudgetInstructions,
  ...dedupe([...buy.setupInstructions, ...sell.setupInstructions]),
  buy.tokenLedgerInstruction,    // present when the sell leg needs it
  buy.swapInstruction,
  sell.swapInstruction,
  sell.cleanupInstruction
].filter(Boolean);

const lookupTables = [
  ...buy.addressLookupTableAddresses,
  ...sell.addressLookupTableAddresses
];

Notes

• tokenLedgerInstruction is null for ordinary single-swap responses — that is expected. It is populated when the swap is part of a chain where a later instruction needs to read the runtime output of an earlier one.
• amountOut in a quote is the expected output and cannot be set to auto. The token ledger is the supported way to chain “sell whatever the buy produced” without knowing the amount ahead of time.
• Keep both legs inside the compute unit budget. You may need to raise computeUnitLimit and computeUnitPriceMicroLamports when combining two swaps.

Stream live quotes

Use the Raptor WebSocket /stream endpoint for quote updates.

const ws = new WebSocket("wss://raptor-beta.solanatracker.io/stream");

ws.onopen = () => {
  ws.send(JSON.stringify({
    type: "subscribe",
    id: "sol-usdc-quote",
    inputMint: "So11111111111111111111111111111111111111112",
    outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    amount: 100000000,
    slippageBps: "50",
    maxHops: 2,
    dexes: "raydium,meteora,whirlpool"
  }));
};

ws.onmessage = (event) => {
  const msg = JSON.parse(event.data);

  if (msg.type === "subscribed") {
    console.log(`Subscribed: ${msg.id}`);
  }

  if (msg.type === "quote") {
    console.log(`Quote update: ${msg.data.amountOut}`);
  }
};

Stream ready-to-sign swap transactions

Use /stream/swap when you want live quote updates plus a fresh prebuilt transaction.

This stream requires userPublicKey because Raptor builds the transaction for that wallet.

const ws = new WebSocket("wss://raptor-beta.solanatracker.io/stream/swap");

ws.onopen = () => {
  ws.send(JSON.stringify({
    type: "subscribe",
    id: "sol-usdc-swap",
    inputMint: "So11111111111111111111111111111111111111112",
    outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    amount: 100000000,
    userPublicKey: "YOUR_WALLET_ADDRESS",
    slippageBps: "50",
    txVersion: "V0",
    priorityFee: "medium",
    wrapUnwrapSol: true,
    maxHops: 2
  }));
};

ws.onmessage = (event) => {
  const msg = JSON.parse(event.data);

  if (msg.type === "swap") {
    console.log(`Updated quote: ${msg.quote.amountOut}`);
    console.log(`Swap tx: ${msg.swapTransaction}`);
    console.log(`Last valid block height: ${msg.lastValidBlockHeight}`);
  }
};

/stream/swap re-sends the latest transaction after 10 slots without an update to help avoid transaction expiry.

Raptor Overview

Full endpoint reference, supported DEXs, routing controls, and WebSocket details.

Raptor Transactions

Send signed transactions and track confirmation status through Raptor.