DEX Aggregator

Jupiter Aggregator

Jupiter is Solana's dominant DEX aggregator — routing swaps across all major Solana DEXs (Orca, Raydium, Meteora, Phoenix, and 30+ others) to find the best price for any token swap on Solana, processing billions of dollars in monthly volume and establishing itself as the default swap layer for the entire Solana DeFi ecosystem including wallets and protocols.

Tools · Crypto scanner · Coins · Courses

Jupiter (jup.ag) was built by Meow and WRX, launching in October 2021 as Solana's first DEX aggregator. Jupiter's launch filled a critical gap. Solana had multiple DEXs (Orca, Raydium, Saber, Mercurial), each with different liquidity pools for the same pairs, so a trader manually choosing which DEX to use would often get suboptimal prices. Jupiter automatically queries all available DEXs, computes all possible routes (including multi-hop routes: e.g., BONK → SOL → USDC is sometimes cheaper than BONK → USDC directly), and executes the optimal route in a single atomic transaction.

Jupiter's Beyond-Aggregation Features

Jupiter has expanded significantly beyond basic swap routing:

  • DCA (Dollar-Cost Averaging): Schedule recurring purchases of any token at fixed intervals. For example, buy $50 SOL every day for 30 days, and Jupiter automatically executes each swap at market price with best-route routing.
  • Limit Orders: Place limit orders for any Solana token pair. Jupiter keepers watch the price and execute the order when the target price is reached, so the user doesn't need to stay connected.
  • Jupiter Perpetuals: A native perpetuals trading platform with up to 100x leverage on SOL, ETH and BTC, using JLP (Jupiter Liquidity Pool) as the counterparty. It competes directly with GMX on Solana.
  • Bridge: Cross-chain bridging from Ethereum/EVM chains to Solana via integrated bridge partners.

JUP Token and Governance

JUP is Jupiter's governance token with a total supply of 10 billion. 40% was allocated to the Jupiter DAO treasury, 20% to community airdrops (the January 2024 airdrop of 1 billion JUP to Solana ecosystem users was one of the largest airdrops in crypto history), and 40% to the team/investors with vesting schedules. JUP holders vote on protocol parameters, fee distribution, and development priorities. JUP trades on Binance, Coinbase, OKX, Bybit, and all major exchanges.

Using Jupiter From Your Own Wallet: No API Keys Required

Jupiter is a non-custodial DEX aggregator. Apps reach Jupiter through its Swap API (free, public, rate-limited) or the self-hosted Jupiter Station, and every trade is signed by a Solana wallet.

Jupiter Quote + Swap API Example (Python)

import os
import requests
import base64
from solders.keypair import Keypair
from solders.transaction import VersionedTransaction
from solana.rpc.api import Client

# Wallet from environment variable — NEVER hardcode
PRIVATE_KEY_B58 = os.environ.get("SOLANA_PRIVATE_KEY")
RPC_URL = os.environ.get("SOLANA_RPC_URL", "https://api.mainnet-beta.solana.com")

if not PRIVATE_KEY_B58:
    raise RuntimeError("SOLANA_PRIVATE_KEY environment variable not set")

wallet = Keypair.from_base58_string(PRIVATE_KEY_B58)
client = Client(RPC_URL)

JUPITER_QUOTE_API = "https://quote-api.jup.ag/v6/quote"
JUPITER_SWAP_API = "https://quote-api.jup.ag/v6/swap"

# SOL and USDC mint addresses on Solana mainnet
SOL_MINT = "So11111111111111111111111111111111111111112"
USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"

def get_quote(input_mint: str, output_mint: str, amount_lamports: int) -> dict:
    # Get the best swap quote from Jupiter.
    params = {
        "inputMint": input_mint,
        "outputMint": output_mint,
        "amount": amount_lamports,
        "slippageBps": 50,  # 0.5% slippage tolerance
    }
    resp = requests.get(JUPITER_QUOTE_API, params=params, timeout=10)
    resp.raise_for_status()
    return resp.json()

def execute_swap(quote_response: dict) -> str:
    # Execute the Jupiter swap and return the transaction signature.
    payload = {
        "quoteResponse": quote_response,
        "userPublicKey": str(wallet.pubkey()),
        "wrapAndUnwrapSol": True,
    }
    resp = requests.post(JUPITER_SWAP_API, json=payload, timeout=10)
    resp.raise_for_status()
    swap_data = resp.json()

    # Deserialise, sign, and submit the transaction
    tx_bytes = base64.b64decode(swap_data["swapTransaction"])
    tx = VersionedTransaction.from_bytes(tx_bytes)
    signed_tx = wallet.sign_message(bytes(tx.message))
    # Submit to Solana RPC
    result = client.send_raw_transaction(bytes(tx))
    return str(result.value)

if __name__ == "__main__":
    # Example: swap 0.01 SOL to USDC
    amount_lamports = int(0.01 * 1e9)  # 0.01 SOL in lamports
    print(f"Getting quote for {amount_lamports} lamports SOL → USDC...")
    quote = get_quote(SOL_MINT, USDC_MINT, amount_lamports)
    out_amount = int(quote["outAmount"]) / 1e6
    print(f"Expected USDC output: {out_amount:.4f} USDC")
    print(f"Price impact: {quote.get('priceImpactPct', '0')}%")

Security notes for using Jupiter:

  • Store SOLANA_PRIVATE_KEY in OS environment variables only, and never in code or config files committed to version control.
  • Keep a separate wallet holding only the funds you mean to trade.
  • Jupiter's public Quote API is rate-limited. Heavier use needs a paid QuickNode/Helius endpoint with the self-hosted Jupiter station.
  • Always check priceImpactPct in the quote response before executing. High price impact means low liquidity and potential for significant losses.
  • Set appropriate slippage tolerance (50–100 bps for stable pairs, 100–300 bps for volatile tokens).

Jupiter's Ecosystem Expansion Beyond Aggregation

Jupiter Aggregator has grown far beyond its original swap aggregation role. It now hosts a whole ecosystem of financial products, including Jupiter Perps (on-chain perpetuals powered by JLP liquidity pools), dollar-cost averaging automation (Jupiter DCA), limit orders and Jupiter Start (launchpad for new Solana tokens). Jupiter Perps uses a GMX-inspired liquidity pool model (JLP, the Jupiter Liquidity Pool) where depositors provide multi-asset liquidity and earn fees from the positions of traders using leverage. Jupiter routes perp orders against this pool for a CEX-grade trading experience on Solana.

Jupiter's Metropolis upgrade introduced advanced trading tools such as conditional orders, recurring buys and portfolio rebalancing. They compete with centralized portfolio management tools in a fully on-chain context. The JUP token distributes a portion of protocol fees to stakers and governs Jupiter DAO decisions including fee parameters, new product launches, and grants from Jupiter's substantial ecosystem treasury. Jupiter's position as Solana's default swap infrastructure (used by virtually every Solana DeFi application for optimal routing) provides structural volume dominance regardless of individual competitor DEX performance. Compare Solana DEX options including Raydium, Orca, and Drift Protocol for perps. Use our crypto tools and DennTech blog for Solana ecosystem updates.

Virtually every Solana DeFi application uses Jupiter's quote API for swap routing. Wallets, aggregators and protocols embed Jupiter's routing directly and skip building their own DEX integration logic, which makes Jupiter's liquidity access work like infrastructure on Solana. Jupiter handles the complexity of routing through 20+ Solana DEXes simultaneously, comparing routes and executing the optimal path in a single transaction. The JUP token distribution (the airdrop was one of the largest in Solana history) created one of the most broadly distributed governance communities in DeFi, with hundreds of thousands of wallets holding JUP after the airdrop, creating a large active governance participant base for Jupiter DAO votes.

Jupiter's ape mode lets high-risk traders swap newly launched tokens immediately upon pool creation, without waiting for liquidity depth to fully develop. That helps traders seeking early exposure to new token launches, but low-liquidity early-stage positions call for careful risk management. Jupiter's portfolio tracker provides a unified view of all token holdings, LP positions, and pending orders across a connected Solana wallet, so traders can see where they stand without opening each protocol's own interface. Jupiter's influence on Solana DeFi extends to price discovery: because Jupiter aggregates so much swap volume, Jupiter's weighted average prices are the de facto market prices referenced by on-chain oracle providers, creating a symbiotic relationship between Jupiter's trading infrastructure and Solana's price oracle ecosystem.