Get a swap quote and unsigned transaction from Jupiter Ultra API.

This function is FREE to call and does not execute any transactions. Use this to get price quotes and prepare transactions for execution.

Args: input_mint: The input token mint address (e.g., SOL: "So11111111111111111111111111111111111111112") output_mint: The output token mint address (e.g., USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v") amount: The amount of input token to swap in smallest unit (e.g., "1000000" = 0.001 SOL)

Returns: Dictionary containing: - success: Boolean indicating if the request was successful - data: Contains 'transaction' (unsigned) and 'requestId' for execution - error: Error message if request failed

Example: >>> result = await api.get_swap_quote( ... input_mint="So11111111111111111111111111111111111111112", # SOL ... output_mint="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", # USDC ... amount="1000000" # 0.001 SOL ... ) >>> if result["success"]: ... transaction = result["data"]["transaction"] ... request_id = result["data"]["requestId"]

🚨 WARNING: THIS WILL EXECUTE A REAL TRADE AND SPEND ACTUAL SOL! 🚨

Sign and execute a swap transaction via Jupiter Ultra API.

This is a PAID operation that executes real trades on the Solana blockchain. Only call this function when you want to actually execute a trade.

This method will:

1. Sign the provided unsigned transaction with your configured private key

2. Execute the signed transaction on the Solana blockchain

3. SPEND REAL SOL/TOKENS - THIS IS NOT REVERSIBLE!

Args: transaction: The base64 encoded UNSIGNED transaction from get_swap_quote request_id: The request ID from the swap quote response

Returns: Dictionary containing: - success: Boolean indicating if the execution was successful - data: Contains 'signature' and transaction details if successful - error: Error message if execution failed

Example: >>> # First get a quote >>> quote = await api.get_swap_quote(input_mint, output_mint, amount) >>> if quote["success"]: ... # Then execute the trade ... result = await api.execute_swap_transaction( ... transaction=quote["data"]["transaction"], ... request_id=quote["data"]["requestId"] ... ) ... if result["success"]: ... print(f"Trade executed! Signature: {result['data']['signature']}")

Get token balances for a wallet address via Jupiter Ultra API.

This function is FREE to call and does not execute any transactions. Use this to check wallet holdings before making trades.

Args: wallet_address: The wallet address to get balances for (optional, will use configured wallet if not provided)

Returns: Dictionary containing: - success: Boolean indicating if the request was successful - wallet_address: The wallet address that was queried - data: Array of token balances with mint addresses, amounts, and decimals - error: Error message if request failed

Example: >>> # Get balances for configured wallet >>> result = await api.get_balances() >>> if result["success"]: ... balances = result["data"] ... for balance in balances: ... print(f"Token: {balance['mint']}, Amount: {balance['amount']}") >>> >>> # Get balances for specific wallet >>> result = await api.get_balances(wallet_address="11111111111111111111111111111112")

    Get token security information via Jupiter Ultra Shield API.

    This function is FREE to call and does not execute any transactions.
    Use this to check token security before making trades. Essential for avoiding scam tokens.

    IMPORTANT: You can check MULTIPLE tokens in a single request by comma-separating mints!
    This is much more efficient than making multiple individual requests.

    Args:
        mints: Comma-separated list of token mint addresses to check
               Example: "mint1,mint2,mint3" (no spaces between commas)
               No specific limit mentioned in API docs

    Returns:
        Dictionary containing:
        - success: Boolean indicating if the request was successful
        - data: A "warnings" object with mint addresses as keys, each containing an array of warnings
        - error: Error message if request failed

    Warning Types and Severities:
        Info level warnings:
        - NOT_VERIFIED: Token is not verified, double-check mint address
        - LOW_ORGANIC_ACTIVITY: Token has low organic trading activity
        - NEW_LISTING: Token is newly listed
        - HAS_MINT_AUTHORITY: Owner can mint more tokens (dilution risk)

        Warning level warnings:
        - HAS_FREEZE_AUTHORITY: Owner can freeze your tokens (high risk!)
        - Transfer tax tokens are disabled on Jupiter frontend

    Example:
        >>> # Check security for multiple tokens at once
        >>> mints = "So11111111111111111111111111111111111111112,EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v,someTokenMint"
        >>> result = await api.get_shield(mints=mints)
        >>> if result["success"]:
        ...     warnings = result["data"]["warnings"]
        ...     for mint, mint_warnings in warnings.items():
        ...         if mint_warnings:
        ...             print(f"

⚠️ Warnings for {mint}:") ... for warning in mint_warnings: ... severity_icon = "🔴" if warning["severity"] == "warning" else "🟡" ... print(f" {severity_icon} {warning['type']}: {warning['message']}") ... else: ... print(f"✅ {mint}: No warnings found")

Search for tokens via Jupiter Ultra API.

This function is FREE to call and does not execute any transactions. Use this to find token mint addresses when you only know the symbol or name.

IMPORTANT: You can search for MULTIPLE tokens in a single request by comma-separating queries! This is much more efficient than making multiple individual requests.

Args: query: Search query - can be: - Single token: symbol ("SOL"), name ("Solana"), or mint address - Multiple tokens: comma-separated queries (e.g., "SOL,USDC,RAY") - Limit: Up to 100 mint addresses when searching by address - Response limit: Returns up to 20 tokens per symbol/name search

Returns: Dictionary containing: - success: Boolean indicating if the request was successful - query: The original search query - data: Array of ALL matching tokens from ALL queries combined - error: Error message if request failed

Example: >>> # Search for a single token >>> result = await api.search_token(query="SOL") >>> if result["success"]: ... for token in result["data"]: ... print(f"Symbol: {token['symbol']}, Mint: {token['mint']}") >>> >>> # Search for MULTIPLE tokens at once (RECOMMENDED for efficiency!) >>> result = await api.search_token(query="SOL,USDC,RAY,BONK") >>> if result["success"]: ... # Returns all matching tokens for all queries in one response ... for token in result["data"]: ... print(f"{token['symbol']}: {token['mint']}") >>> >>> # Search by multiple mint addresses >>> mints = "So11111111111111111111111111111111111111112,EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" >>> result = await api.search_token(query=mints) >>> if result["success"]: ... # Returns detailed info for all specified mints ... for token in result["data"]: ... print(f"{token['symbol']}: ${token.get('usdPrice', 'N/A')}")

Create a limit order that executes when target price is reached.

This function is FREE to call and does not execute any transactions. It returns an unsigned transaction that must be signed and executed.

⚠️ IMPORTANT WARNINGS:

1. MINIMUM ORDER SIZE: Jupiter frontend enforces $5 USD minimum to ensure keeper profitability. Programmatically, smaller orders are accepted but may never execute!

2. PRICE VALIDATION: The program does NOT check if your price makes sense!

   • Buying above market price? Order executes immediately at a LOSS

   • Setting wrong rate (e.g., 1000 USDC for 1 SOL)? You LOSE the difference!

   • Jupiter frontend warns/blocks orders >5% above market - API does NOT!

3. TRANSFER TAX: Tokens with transfer tax extensions are disabled on frontend but API will accept them - be careful!

4. SLIPPAGE: By default, trigger orders execute with 0 slippage (exact price). Add slippage for better fill probability but at worse price.

Args: input_mint: Input token mint address (token to sell) output_mint: Output token mint address (token to buy) making_amount: Amount of input token to sell in smallest unit taking_amount: Amount of output token to receive in smallest unit (sets the price) slippage_bps: Slippage in basis points (0 = exact price, >0 = accept worse price) expired_at: Unix timestamp when order expires (optional)

Returns: Dictionary containing: - success: Boolean indicating if the request was successful - data: Contains 'order' (account address), 'transaction' (unsigned), and 'requestId' - error: Error message if request failed

Note: - Uses configured wallet as maker/payer - Includes automatic referral (2.55%) - Order executes when market price reaches your target

Example: >>> # SAFE: Create limit order to sell 0.1 SOL when price reaches $200 >>> # Current market: 1 SOL = $180, so this waits for price to rise >>> result = await api.create_limit_order( ... input_mint="So11111111111111111111111111111111111111112", # SOL ... output_mint="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", # USDC ... making_amount="100000000", # 0.1 SOL (9 decimals) ... taking_amount="20000000", # 20 USDC (6 decimals) = $200/SOL rate ... slippage_bps=50 # 0.5% slippage for better fills ... ) >>> >>> # DANGEROUS: Wrong price - selling 1 SOL for only 1 USDC! >>> # This executes immediately and you LOSE ~$179! >>> # DON'T DO THIS: >>> # result = await api.create_limit_order( >>> # input_mint="So11...112", >>> # output_mint="EPj...t1v", >>> # making_amount="1000000000", # 1 SOL >>> # taking_amount="1000000" # 1 USDC - HUGE LOSS! >>> # )

🚨 WARNING: THIS WILL CREATE A REAL LIMIT ORDER ON-CHAIN! 🚨

Sign and execute a limit order transaction.

This is a PAID operation that creates a limit order on the Solana blockchain. The order will execute automatically when market conditions are met.

Args: transaction: Base64 encoded unsigned transaction from create_limit_order request_id: Request ID from create_limit_order response

Returns: Dictionary containing: - success: Boolean indicating if the execution was successful - data: Contains 'signature' and status if successful - error: Error message if execution failed

Note: - This creates a limit order that may execute later - Orders have fees: 0.03% (stable pairs) or 0.1% (other pairs) - Plus automatic referral fees (2.55%) - Minimum order size is $5 USD

Example: >>> # First create the order >>> order = await api.create_limit_order(...) >>> if order["success"]: ... # Then execute it ... result = await api.execute_limit_order( ... transaction=order["data"]["transaction"], ... request_id=order["data"]["requestId"] ... ) ... if result["success"]: ... print(f"Limit order created! Signature: {result['data']['signature']}")

Cancel a single active limit order.

This function is FREE to call and does not execute any transactions. It returns an unsigned transaction that must be signed and executed.

Args: order: Order account address to cancel

Returns: Dictionary containing: - success: Boolean indicating if the request was successful - data: Contains 'transaction' (unsigned) and 'requestId' - error: Error message if request failed

Note: - Returns unsigned transaction that needs to be executed - Uses configured wallet as maker

Example: >>> # Cancel a specific order >>> result = await api.cancel_limit_order( ... order="your_order_account_address_here" ... ) >>> if result["success"]: ... # Execute the cancellation ... exec_result = await api.execute_limit_order( ... transaction=result["data"]["transaction"], ... request_id=result["data"]["requestId"] ... )

Cancel multiple limit orders (batched in groups of 5).

This function is FREE to call and does not execute any transactions. It returns unsigned transactions that must be signed and executed.

Args: orders: Array of order account addresses. If None/empty, cancels ALL orders

Returns: Dictionary containing: - success: Boolean indicating if the request was successful - data: Contains 'transactions' (array of unsigned) and 'requestId' - error: Error message if request failed

Note: - Returns multiple transactions if >5 orders - Each transaction needs to be signed and executed separately - Uses configured wallet as maker

Example: >>> # Cancel specific orders >>> result = await api.cancel_limit_orders( ... orders=["order1_address", "order2_address", "order3_address"] ... ) >>> >>> # Cancel ALL orders >>> result = await api.cancel_limit_orders() >>> if result["success"]: ... # Execute each cancellation transaction ... for tx in result["data"]["transactions"]: ... exec_result = await api.execute_limit_order( ... transaction=tx, ... request_id=result["data"]["requestId"] ... )

Get active or historical limit orders for a wallet.

This function is FREE to call and does not execute any transactions.

Args: order_status: "active" or "history" (default: "active") wallet_address: Wallet to check (optional, defaults to configured wallet) input_mint: Filter by input token (optional) output_mint: Filter by output token (optional) page: Page number for pagination, 10 orders per page (optional)

Returns: Dictionary containing: - success: Boolean indicating if the request was successful - wallet_address: The wallet address that was queried - data: Array of order objects with details - hasMoreData: Boolean indicating if there are more pages - error: Error message if request failed

Example: >>> # Get active orders for configured wallet >>> result = await api.get_limit_orders(order_status="active") >>> if result["success"]: ... for order in result["data"]: ... print(f"Order {order['orderAccount']}: {order['makingAmount']} → {order['takingAmount']}") >>> >>> # Get order history with pagination >>> result = await api.get_limit_orders(order_status="history", page=1)