swapapi is the only DEX aggregator API that requires no API key or authentication. It supports 46 EVM chains and returns executable calldata in a single GET request.

Comparison Table​

Provider Details​

swapapi​

Free / No auth / 46 chains

The only DEX aggregator API built for autonomous systems. No API keys, no registration, no SDK required. A single GET request returns executable calldata across 46 EVM chains. BigInt values are serialized as strings for safe JSON parsing. Every response uses a consistent envelope format with status, price impact, and ready-to-sign transaction data.

1inch​

API key required / ~10 chains

The market leader in DEX aggregation. Requires API key registration and has tiered rate limits. Recently migrated from GET to POST for swap endpoints, which was a breaking change for many integrations. Offers additional features like Fusion mode (gasless swaps) and limit orders, but the core swap API is comparable in functionality.

0x (Swap API)​

API key required / ~8 chains

Strong Ethereum and L2 liquidity with professional-grade APIs. Requires API key registration. Supports approximately 8 EVM chains. Well-documented but oriented toward enterprise integrations. Pricing is usage-based after the free tier.

Li.Fi​

API key (free tier) / 20+ chains

Cross-chain focused aggregator that bridges and swaps in a single transaction. Supports 20+ chains including some non-EVM networks. Requires API key, though a free tier is available. Best choice when you need cross-chain swaps, which swapapi does not support.

Paraswap​

API key required / ~7 chains

Competitive rates on supported chains with a focus on gas optimization. Requires API key registration. Supports approximately 7 EVM chains. Uses a GET request for quotes and a separate POST for building transactions.

Jupiter​

Free / Solana only

The dominant DEX aggregator on Solana. Free, no API key required, and fast. However, it only supports Solana — no EVM chain support at all. If you need Solana swaps, Jupiter is the clear choice. For EVM chains, look elsewhere.

When to Choose swapapi​

swapapi is purpose-built for a specific set of use cases:

• AI agents and autonomous systems — No API key means no registration flow, no secrets management, no key rotation. An agent can start swapping tokens with a single HTTP call.
• Rapid prototyping — Zero setup. No account creation, no SDK installation, no configuration. Start building in 30 seconds with a curl command.
• Multi-chain EVM applications — 46 chains with one consistent API. The same endpoint, same parameters, same response format across Ethereum, Arbitrum, Base, Polygon, BSC, and 41 more.
• No-auth requirements — If your architecture cannot support API keys (serverless functions, client-side apps, or embedded systems), swapapi is the only option.
• BigInt-safe integrations — All large numbers are returned as strings, preventing JavaScript's Number.MAX_SAFE_INTEGER precision loss.

Quick Example​

One GET request, ready-to-sign calldata:

curl "https://api.swapapi.dev/v1/swap/1?\
  tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&\
  tokenOut=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&\
  amount=1000000000000000000&\
  sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

Response:

{
  "success": true,
  "data": {
    "status": "Successful",
    "tokenFrom": { "symbol": "ETH", "decimals": 18 },
    "tokenTo": { "symbol": "USDC", "decimals": 6 },
    "swapPrice": 2847.53,
    "priceImpact": 0.0012,
    "amountIn": "1000000000000000000",
    "expectedAmountOut": "2847530000",
    "tx": {
      "to": "0x...router",
      "data": "0x...calldata",
      "value": "1000000000000000000",
      "gas": "250000"
    }
  },
  "timestamp": "2026-03-20T00:00:00.000Z"
}

Related​

• Step-by-step tutorial
• Migration guide from 1inch
• Supported chains
• swapapi for AI agents

What You'll Build​

A trading bot that:

• Fetches optimal swap routes across 46 EVM chains
• Validates safety constraints before executing
• Signs and submits transactions automatically
• Handles errors and retries with exponential backoff

Prerequisites​

• Node.js 18+ or Python 3.9+
• A wallet with private key (for testing, use a small amount)
• Basic knowledge of TypeScript or Python

Step 1: Choose Your Strategy​

Common automated trading strategies:

DCA (Dollar-Cost Averaging): Buy a fixed amount at regular intervals regardless of price.

Rebalancing: Maintain target portfolio weights by swapping when allocations drift.

Arbitrage: Exploit price differences between DEXs (requires monitoring multiple sources).

Signal-based: Execute trades based on technical indicators or external signals.

For this guide, we'll build a simple DCA bot that buys ETH with USDC every hour.

Step 2: Set Up the Project​

TypeScript Setup​

npm init -y
npm install viem

Python Setup​

pip install web3 requests

Step 3: Fetch Swap Quotes​

The core of your bot: fetching optimal swap routes and executable calldata.

TypeScript​

import { createWalletClient, http, parseEther } from 'viem';
import { base } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';

async function getSwapQuote(params: {
  chainId: number;
  tokenIn: string;
  tokenOut: string;
  amount: string;
  sender: string;
}) {
  const url = `https://api.swapapi.dev/v1/swap/${params.chainId}?` +
    new URLSearchParams({
      tokenIn: params.tokenIn,
      tokenOut: params.tokenOut,
      amount: params.amount,
      sender: params.sender,
    });

  const res = await fetch(url);
  const { success, data } = await res.json();

  if (!success) throw new Error("API request failed");
  if (data.status === "NoRoute") throw new Error("No swap route found");

  return data;
}

Python​

import requests

def get_swap_quote(chain_id: int, token_in: str, token_out: str, 
                   amount: str, sender: str):
    url = f"https://api.swapapi.dev/v1/swap/{chain_id}"
    params = {
        "tokenIn": token_in,
        "tokenOut": token_out,
        "amount": amount,
        "sender": sender
    }
    
    response = requests.get(url, params=params)
    result = response.json()
    
    if not result["success"]:
        raise Exception("API request failed")
    if result["data"]["status"] == "NoRoute":
        raise Exception("No swap route found")
    
    return result["data"]

Step 4: Add Safety Checks​

Never execute trades without validating safety constraints.

Price Impact Check​

function validateTrade(data: any, maxPriceImpact: number = -0.05) {
  // Reject if price impact exceeds 5%
  if (data.priceImpact < maxPriceImpact) {
    throw new Error(`Price impact ${data.priceImpact} exceeds limit ${maxPriceImpact}`);
  }
  
  // Check for partial fills
  if (data.status === "Partial") {
    throw new Error("Only partial fill available");
  }
  
  return true;
}

Maximum Trade Size​

const MAX_TRADE_SIZE = parseEther("1"); // 1 ETH max

function validateAmount(amount: string) {
  if (BigInt(amount) > MAX_TRADE_SIZE) {
    throw new Error("Trade size exceeds maximum");
  }
}

Simulate Before Submitting​

Use eth_call to simulate the transaction before broadcasting:

import { createPublicClient, http } from 'viem';

const publicClient = createPublicClient({
  chain: base,
  transport: http(),
});

async function simulateTx(tx: any) {
  try {
    await publicClient.call({
      account: tx.from,
      to: tx.to,
      data: tx.data,
      value: BigInt(tx.value),
    });
    return true;
  } catch (error) {
    console.error("Simulation failed:", error);
    return false;
  }
}

Step 5: Execute Trades​

Once validated, sign and submit the transaction.

TypeScript with Viem​

async function executeTrade(privateKey: string, chainId: number) {
  const account = privateKeyToAccount(privateKey as `0x${string}`);
  const sender = account.address;
  
  // Get quote
  const quote = await getSwapQuote({
    chainId,
    tokenIn: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC on Base
    tokenOut: "0x4200000000000000000000000000000000000006", // WETH on Base
    amount: "10000000", // 10 USDC (6 decimals)
    sender,
  });
  
  // Validate
  validateTrade(quote);
  
  // Simulate
  const canExecute = await simulateTx(quote.tx);
  if (!canExecute) throw new Error("Transaction simulation failed");
  
  // Execute
  const walletClient = createWalletClient({
    account,
    chain: base,
    transport: http(),
  });
  
  const hash = await walletClient.sendTransaction({
    to: quote.tx.to as `0x${string}`,
    data: quote.tx.data as `0x${string}`,
    value: BigInt(quote.tx.value),
    gas: BigInt(quote.tx.gas),
  });
  
  return hash;
}

Python with Web3.py​

from web3 import Web3
import time

def execute_trade(private_key: str, chain_id: int, rpc_url: str):
    w3 = Web3(Web3.HTTPProvider(rpc_url))
    account = w3.eth.account.from_key(private_key)
    sender = account.address
    
    # Get quote
    quote = get_swap_quote(
        chain_id=chain_id,
        token_in="0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
        token_out="0x4200000000000000000000000000000000000006",
        amount="10000000",
        sender=sender
    )
    
    # Build transaction
    tx = {
        'from': sender,
        'to': quote['tx']['to'],
        'data': quote['tx']['data'],
        'value': int(quote['tx']['value']),
        'gas': int(quote['tx']['gas']),
        'gasPrice': w3.eth.gas_price,
        'nonce': w3.eth.get_transaction_count(sender),
        'chainId': chain_id
    }
    
    # Sign and send
    signed_tx = w3.eth.account.sign_transaction(tx, private_key)
    tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
    
    return tx_hash.hex()

Step 6: Production Hardening​

Error Handling with Exponential Backoff​

async function executeWithRetry(fn: () => Promise<any>, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      
      const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
      console.log(`Retry ${i + 1}/${maxRetries} after ${delay}ms`);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

Gas Management​

async function getOptimalGasPrice() {
  const block = await publicClient.getBlock();
  // Use base fee + 10% buffer
  const baseFee = block.baseFeePerGas || BigInt(0);
  const priorityFee = parseGwei("0.1");
  return baseFee + priorityFee;
}

Rate Limit Awareness​

let lastRequestTime = 0;
const MIN_REQUEST_INTERVAL = 2000; // 2 seconds

async function throttledRequest(fn: () => Promise<any>) {
  const now = Date.now();
  const timeSinceLastRequest = now - lastRequestTime;
  
  if (timeSinceLastRequest < MIN_REQUEST_INTERVAL) {
    await new Promise(resolve => 
      setTimeout(resolve, MIN_REQUEST_INTERVAL - timeSinceLastRequest)
    );
  }
  
  lastRequestTime = Date.now();
  return fn();
}

Logging and Monitoring​

import winston from 'winston';

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'trades.log' }),
    new winston.transports.Console()
  ]
});

// Log every trade
logger.info('Trade executed', {
  txHash,
  tokenIn: quote.tokenFrom.symbol,
  tokenOut: quote.tokenTo.symbol,
  amountIn: quote.amountIn,
  amountOut: quote.expectedAmountOut,
  priceImpact: quote.priceImpact,
  timestamp: new Date().toISOString()
});

Step 7: Schedule Your Bot​

Use cron or a scheduler to run your strategy:

// Run every hour
import cron from 'node-cron';

cron.schedule('0 * * * *', async () => {
  console.log('Running DCA strategy...');
  try {
    const txHash = await executeTrade(process.env.PRIVATE_KEY!, 8453);
    console.log(`Trade executed: ${txHash}`);
  } catch (error) {
    console.error('Trade failed:', error);
  }
});

Complete Example​

Here's a minimal but complete trading bot:

import { createWalletClient, http } from 'viem';
import { base } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';
import cron from 'node-cron';

const PRIVATE_KEY = process.env.PRIVATE_KEY!;
const CHAIN_ID = 8453; // Base

async function runDCA() {
  const account = privateKeyToAccount(PRIVATE_KEY as `0x${string}`);
  
  // Get quote
  const res = await fetch(
    `https://api.swapapi.dev/v1/swap/${CHAIN_ID}?` +
    `tokenIn=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&` +
    `tokenOut=0x4200000000000000000000000000000000000006&` +
    `amount=10000000&` + // 10 USDC
    `sender=${account.address}`
  );
  
  const { success, data } = await res.json();
  if (!success || data.status !== "Successful") {
    throw new Error("Failed to get quote");
  }
  
  // Execute
  const wallet = createWalletClient({
    account,
    chain: base,
    transport: http(),
  });
  
  const hash = await wallet.sendTransaction({
    to: data.tx.to as `0x${string}`,
    data: data.tx.data as `0x${string}`,
    value: BigInt(data.tx.value),
    gas: BigInt(data.tx.gas),
  });
  
  console.log(`DCA executed: ${hash}`);
}

// Run every hour
cron.schedule('0 * * * *', runDCA);
console.log('DCA bot started. Running every hour.');

Security Best Practices​

1. Never commit private keys — Use environment variables
2. Start small — Test with minimal amounts
3. Monitor gas costs — Set maximum gas limits
4. Use multisig for large amounts — Require multiple signatures
5. Have a kill switch — Emergency stop function
6. Log everything — Audit trail for all trades

Related Resources​

• API Reference
• Slippage Guide
• AI Agent Integration

Token Swap APIs​

swapapi (DEX Aggregator)​

The only DEX aggregator API that requires no authentication.

• What it does: Returns optimal swap routes and executable calldata across 46 EVM chains
• Authentication: None
• Rate limit: ~30 req/min per IP
• Best for: Trading bots, AI agents, DeFi integrations

curl "https://api.swapapi.dev/v1/swap/1?\
  tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&\
  tokenOut=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&\
  amount=1000000000000000000&\
  sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

Jupiter (Solana)​

The dominant DEX aggregator on Solana.

• What it does: Swap routing on Solana
• Authentication: None
• Chains: Solana only
• Best for: Solana trading bots

curl "https://quote-api.jup.ag/v6/quote?\
  inputMint=So11111111111111111111111111111111111111112&\
  outputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&\
  amount=1000000000"

Price Data APIs​

CoinGecko (Public Endpoints)​

Free cryptocurrency price data without API key (limited endpoints).

• What it does: Price, market cap, volume data
• Authentication: None for basic endpoints
• Rate limit: 10-30 calls/minute
• Best for: Price displays, portfolio tracking

# Get Bitcoin price in USD
curl "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd"

CoinMarketCap (Limited)​

Basic crypto data without API key.

• What it does: Market data, rankings
• Authentication: None for public endpoints
• Rate limit: Very limited
• Best for: Quick price checks

Blockchain Data APIs​

Public RPC Endpoints​

Most EVM chains have public RPC endpoints for reading blockchain data.

# Ethereum
curl -X POST https://eth.llamarpc.com \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Base
curl -X POST https://mainnet.base.org \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Arbitrum
curl -X POST https://arb1.arbitrum.io/rpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Note: Public RPCs are great for reads but may be rate-limited. For production, consider dedicated RPC providers.

Etherscan (Limited)​

Some read-only endpoints work without API key.

# Get ETH balance (limited requests without API key)
curl "https://api.etherscan.io/api?module=account&action=balance&\
  address=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045&tag=latest"

On-Chain Data​

Uniswap Subgraph (GraphQL)​

Query Uniswap V3 data directly from The Graph.

curl -X POST https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3 \
  -H "Content-Type: application/json" \
  -d '{
    "query": "{ pools(first: 5) { id token0 { symbol } token1 { symbol } } }"
  }'

DeFiLlama API​

TVL and yield data without authentication.

# Get protocol TVL
curl "https://api.llama.fi/protocols"

# Get chain TVL
curl "https://api.llama.fi/chains"

IPFS Gateways​

Free IPFS gateways for decentralized storage.

# Cloudflare IPFS gateway
curl "https://cloudflare-ipfs.com/ipfs/Qm..."

# Pinata gateway
curl "https://gateway.pinata.cloud/ipfs/Qm..."

Comparison Table​

When to Use What​

For Trading Bots​

Use swapapi (EVM) or Jupiter (Solana). They return executable calldata — no need to construct transactions manually.

For Price Tracking​

Use CoinGecko for simple price checks. Use DeFiLlama for protocol analytics.

For Blockchain Queries​

Use public RPCs for development. Upgrade to dedicated RPC providers (Alchemy, QuickNode) for production with higher rate limits.

For Protocol Data​

Use The Graph subgraphs for complex queries on DeFi protocols.

Limitations of Free APIs​

Rate Limits: Free APIs have rate limits. For high-frequency trading or production apps, you'll eventually need paid tiers.

No Support: Free APIs typically don't come with dedicated support.

Reliability: Public RPCs can be unstable. Use multiple fallbacks for production.

Data Freshness: Some free price APIs have delays. For real-time trading, use the swap API directly.

Building Without API Keys​

The no-auth approach is perfect for:

• Rapid prototyping — Start building in minutes, not hours
• Open source projects — Users don't need to sign up
• AI agents — Autonomous systems can't fill out registration forms
• Serverless functions — No secrets management needed
• Educational projects — Lower barrier to entry

Example: Multi-API Integration​

Here's how you might combine multiple free APIs:

async function getTradeOpportunity() {
  // 1. Get price from CoinGecko
  const priceRes = await fetch(
    'https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd'
  );
  const { ethereum: { usd: ethPrice } } = await priceRes.json();
  
  // 2. Get swap quote from swapapi
  const swapRes = await fetch(
    `https://api.swapapi.dev/v1/swap/1?` +
    `tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&` +
    `tokenOut=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&` +
    `amount=1000000000000000000&` +
    `sender=0x...`
  );
  const { data: quote } = await swapRes.json();
  
  // 3. Analyze opportunity
  const swapPrice = quote.swapPrice;
  const priceDiff = Math.abs(swapPrice - ethPrice) / ethPrice;
  
  return {
    marketPrice: ethPrice,
    swapPrice,
    priceDiff: priceDiff * 100,
    quote
  };
}

Related Resources​

• swapapi Documentation
• Building Trading Bots
• API Comparison

swapapi is a drop-in alternative to 1inch's Swap API. No API key, no SDK, no account. One GET request returns the same calldata you're used to — across 46 EVM chains instead of ~10.

Why Developers Switch​

API Key Registration​

1inch requires creating an account and generating an API key before making any requests. swapapi requires nothing — start with a curl command in 30 seconds.

Restrictive Rate Limits​

1inch rate limits vary by plan. The free tier is restrictive and paid plans can be expensive for high-volume applications. swapapi has generous rate limits with no paid tiers.

Breaking API Changes​

1inch changed their swap endpoint from GET to POST, breaking existing integrations. swapapi uses a simple GET request and maintains backward compatibility.

Zero Setup​

No SDK installation, no account creation, no environment variables. swapapi works with raw HTTP from any language, any platform, any autonomous agent.

Parameter Mapping​

Most parameters map directly. The main differences are naming and slippage format.

Before and After​

1inch (before):

curl -X GET \
  "https://api.1inch.dev/swap/v6.0/1/swap" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "src": "0xEeee...EEeE",
    "dst": "0xA0b8...eB48",
    "amount": "1000000000000000000",
    "from": "0xd8dA...6045",
    "slippage": 1
  }'

swapapi (after):

curl "https://api.swapapi.dev/v1/swap/1?\
  tokenIn=0xEeee...EEeE&\
  tokenOut=0xA0b8...eB48&\
  amount=1000000000000000000&\
  sender=0xd8dA...6045"

# No API key
# No headers
# No request body
# Just a GET request

Response Differences​

swapapi wraps every response in an envelope with a success flag and timestamp. The transaction data is structurally similar.

1inch response:

{
  "tx": {
    "from": "0xd8dA...6045",
    "to": "0x...router",
    "data": "0x...calldata",
    "value": "1000000000000000000",
    "gas": 250000  // number — unsafe for large values
  }
}

swapapi response:

{
  "success": true,                           // always check this first
  "data": {
    "status": "Successful",                  // "Successful" | "Partial" | "NoRoute"
    "swapPrice": 2847.53,                    // exchange rate
    "priceImpact": 0.0012,                   // 0.12% as decimal
    "amountIn": "1000000000000000000",       // string — BigInt safe
    "expectedAmountOut": "2847530000",       // string — BigInt safe
    "tx": {
      "from": "0xd8dA...6045",
      "to": "0x...router",
      "data": "0x...calldata",
      "value": "1000000000000000000",
      "gas": "250000"                        // string — BigInt safe
    },
    "rpcUrls": ["https://..."]              // bonus: RPC endpoints for the chain
  },
  "timestamp": "2026-03-20T..."              // ISO 8601
}

Key differences: swapapi adds a success envelope, a status field (Successful/Partial/NoRoute), price impact data, and RPC URLs. All BigInt values are returned as strings to prevent JavaScript precision loss.

What You Gain and What You Lose​

What You Gain​

• No authentication overhead — no keys, no headers, no secrets
• 46 EVM chains (vs ~10 on 1inch)
• BigInt-safe string serialization for all large numbers
• Built-in RPC URLs in every response
• AI-agent ready — designed for autonomous systems
• Consistent JSON envelope with status and price impact

What You Lose​

• No Fusion mode (gasless swaps via resolvers)
• No limit orders API
• No portfolio/balance tracking API
• No cross-chain swaps (for that, consider Li.Fi)

Migration Checklist​

• Replace base URL: api.1inch.dev/swap/v6.0/{chainId} to api.swapapi.dev/v1/swap/{chainId}
• Remove Authorization header
• Rename src to tokenIn
• Rename dst to tokenOut
• Rename from to sender
• Convert slippage: divide by 100 (e.g., slippage=1 becomes maxSlippage=0.01)
• Update response parsing: unwrap response.data.tx instead of response.tx
• Test with a small amount first

Related​

• Full integration tutorial
• Compare DEX aggregator APIs
• Supported chains
• Slippage guide

You can swap any ERC-20 token on 46 EVM chains with a single GET request to swapapi. No API key, no SDK, no account. The response includes executable calldata ready for on-chain submission.

Prerequisites​

All you need is an HTTP client (curl, fetch, requests) and a wallet to sign the transaction. No registration, no API keys, no SDK installation.

Step 1: Get a Swap Quote​

Send a GET request with the chain ID in the path, and the token addresses, amount, and sender as query parameters. This example swaps 1 ETH for USDC on Ethereum mainnet.

curl "https://api.swapapi.dev/v1/swap/1?\
  tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&\
  tokenOut=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&\
  amount=1000000000000000000&\
  sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

The native token address 0xEeee...EEeE represents ETH (or the native gas token on any chain). USDC on Ethereum is 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48. The amount is in raw units (wei) — 1 ETH = 10^18 wei.

Step 2: Understand the Response​

The API returns an envelope with success, data, and timestamp. The data object contains everything you need to execute the swap.

{
  "success": true,                                     // always check this first
  "data": {
    "status": "Successful",                            // route found, tx ready
    "tokenFrom": {
      "address": "0xEeee...EEeE",
      "symbol": "ETH",
      "name": "Ether",
      "decimals": 18
    },
    "tokenTo": {
      "address": "0xA0b8...eB48",
      "symbol": "USDC",
      "name": "USD Coin",
      "decimals": 6                                    // USDC uses 6 decimals
    },
    "swapPrice": 2500.0,                              // 1 ETH = 2500 USDC
    "priceImpact": 0.0012,                             // 0.12% — ratio, not percentage
    "amountIn": "1000000000000000000",                 // 1 ETH in wei
    "expectedAmountOut": "2500000000",                 // 2500 USDC (6 decimals)
    "minAmountOut": "2487500000",                      // minimum after slippage
    "tx": {                                            // ready-to-sign transaction
      "from": "0xd8dA...6045",
      "to": "0x...router",                             // router contract address
      "data": "0x...calldata",                         // encoded swap calldata
      "value": "1000000000000000000",                  // ETH to send (native swaps only)
      "gas": "250000"                                  // estimated gas limit
    }
  },
  "timestamp": "2026-03-20T12:00:00.000Z"
}

Step 3: Handle Edge Cases​

The status field has three possible values. Your code should handle all three.

Successful​

A full route was found. The tx object is ready to sign and submit. The expectedAmountOut reflects the full amount.

Partial​

Only part of the requested amount can be filled due to limited liquidity. The tx object is still present, but it will only swap the available portion. Check amountIn in the response to see how much will actually be swapped.

NoRoute​

No swap route exists for this token pair on this chain. There is no tx object. Try a different token pair, a different chain, or a smaller amount.

Step 4: Execute On-Chain​

Take the tx object from the response and submit it using your preferred library.

TypeScript (viem)​

import { createPublicClient, createWalletClient, http } from "viem";
import { mainnet } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

// 1. Get the swap quote
const res = await fetch(
  "https://api.swapapi.dev/v1/swap/1?" + new URLSearchParams({
    tokenIn: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
    tokenOut: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    amount: "1000000000000000000",
    maxSlippage: "0.005",
    sender: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
  })
);

const { data } = await res.json();

if (data.status !== "Successful") {
  throw new Error("No route found");
}

// 2. Execute the swap on-chain
const account = privateKeyToAccount("0x...");
const client = createWalletClient({
  account,
  chain: mainnet,
  transport: http(),
});

const hash = await client.sendTransaction({
  to: data.tx.to,
  data: data.tx.data,
  value: BigInt(data.tx.value ?? "0"),
});

console.log("Transaction hash:", hash);

Python (web3.py)​

import requests
from web3 import Web3

# 1. Get the swap quote
response = requests.get(
    "https://api.swapapi.dev/v1/swap/1",
    params={
        "tokenIn": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
        "tokenOut": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "amount": "1000000000000000000",
        "maxSlippage": "0.005",
        "sender": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
    },
)

data = response.json()["data"]

# 2. Execute the swap on-chain
w3 = Web3(Web3.HTTPProvider("https://eth.llamarpc.com"))

tx = {
    "from": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
    "to": Web3.to_checksum_address(data["tx"]["to"]),
    "data": data["tx"]["data"],
    "value": int(data["tx"].get("value", "0")),
    "gas": int(data["tx"].get("gas", "0")),
}

signed = w3.eth.account.sign_transaction(tx, private_key="0x...")
tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
print(f"Transaction hash: {tx_hash.hex()}")

Rust​

use reqwest::Client;
use serde::Deserialize;

#[derive(Deserialize)]
struct ApiResponse {
    success: bool,
    data: SwapData,
}

#[derive(Deserialize)]
struct SwapData {
    status: String,
    #[serde(rename = "swapPrice")]
    swap_price: Option<f64>,
    #[serde(rename = "expectedAmountOut")]
    expected_amount_out: Option<String>,
    tx: Option<TxData>,
}

#[derive(Deserialize)]
struct TxData {
    to: String,
    data: String,
    value: Option<String>,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let res: ApiResponse = client
        .get("https://api.swapapi.dev/v1/swap/1?tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&tokenOut=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&amount=1000000000000000000&maxSlippage=0.005&sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")
        .send()
        .await?
        .json()
        .await?;

    if res.success && res.data.status == "Successful" {
        println!("Swap price: {:?}", res.data.swap_price);
        println!("Expected output: {:?}", res.data.expected_amount_out);
    }

    Ok(())
}

Step 5: ERC-20 Approval Flow​

When swapping native tokens (ETH, BNB, MATIC), no approval is needed — the value is sent directly with the transaction. But for ERC-20 to ERC-20 swaps, you must approve the router contract to spend your tokens first.

Call approve(routerAddress, amount) on the input token contract before submitting the swap transaction. The router address is the tx.to field from the swap response.

The USDT Approval Gotcha​

USDT on Ethereum has a non-standard approve function that requires you to set the allowance to 0 before setting a new value. If the current allowance is non-zero, calling approve with a new value will revert. Always reset to 0 first:

// USDT requires resetting allowance to 0 before approving
await usdt.write.approve([routerAddress, 0n]);
await usdt.write.approve([routerAddress, amount]);

Common Mistakes​

Wrong Decimals​

Token decimals vary by chain. USDC is 6 decimals on Ethereum but 18 decimals on BSC. USDT is 6 on Ethereum but 18 on BSC. Always check the decimals field in the response to interpret expectedAmountOut correctly.

Missing ERC-20 Approval​

If you skip the approval step for ERC-20 swaps, the transaction will revert on-chain. You will pay gas but get nothing. Always approve before swapping tokens (not needed for native ETH/BNB/MATIC).

Stale Calldata​

The tx calldata includes a deadline. Submit the transaction within 30 seconds of receiving the quote. If you wait too long, the transaction will revert. Re-fetch the quote if needed.

Not Checking priceImpact​

The priceImpact field tells you how much your trade moves the market. A value of -0.05 means you are getting 5% less than the market rate. Always check this before executing — high price impact usually means low liquidity. See our price impact and slippage guide for thresholds and best practices.

Related​

• Slippage Guide
• Compare APIs
• Supported Chains
• AI Agents
• Why No API Key

Price impact measures how much your trade moves the market price. Slippage is the maximum deviation you'll accept between quoted and executed price. swapapi returns both values so you can protect users from unfavorable trades.

What is Price Impact?​

When you trade on a DEX, you are trading against a liquidity pool. The pool uses an automated market maker (AMM) formula to determine the price. Larger trades consume more liquidity, which moves the price further from the market rate.

swapapi returns priceImpact as a decimal ratio. A value of -0.0012 means -0.12% (unfavorable — you get less than the market rate). Negative values always indicate an unfavorable price movement.

The relationship is straightforward: swapping 100 ETH will have a much higher price impact than swapping 0.1 ETH, because the larger trade consumes more of the pool's liquidity.

{
  "swapPrice": 2500.0,              // quoted exchange rate
  "priceImpact": -0.0012,            // -0.12% — unfavorable
  "expectedAmountOut": "2500000000"  // already accounts for impact
}

Rule of thumb: reject any swap with a priceImpact below -0.05 (-5%). That level of impact usually means the pool has very low liquidity for this pair.

What is Slippage?​

Slippage is the difference between the expected execution price (at quote time) and the actual execution price (on-chain). Between when you receive a quote and when your transaction is mined, other trades may execute against the same pool, changing the price.

The maxSlippage parameter controls how much price movement you will tolerate. It is a decimal between 0 and 1:

• 0.005 = 0.5% tolerance (the default)
• 0.01 = 1% tolerance
• 0.03 = 3% tolerance

The API uses maxSlippage to calculate minAmountOut — the minimum acceptable output. If the actual output falls below this threshold, the transaction reverts on-chain and you keep your tokens (minus gas).

curl "https://api.swapapi.dev/v1/swap/1?\
  tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&\
  tokenOut=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&\
  amount=1000000000000000000&\
  maxSlippage=0.005&\
  sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

How minAmountOut is Calculated​

The API computes minAmountOut from expectedAmountOut and maxSlippage using this formula:

minAmountOut = expectedAmountOut × (1 − maxSlippage)

Example:
  expectedAmountOut = 2,500 USDC
  maxSlippage       = 0.005 (0.5%)
  minAmountOut      = 2,500 × 0.995 = 2,487.50 USDC

In raw units (6 decimals):
  expectedAmountOut = "2500000000"
  minAmountOut      = "2487500000"

This value is encoded into the swap calldata. The on-chain router contract enforces it — if the actual output is less than minAmountOut, the entire transaction reverts.

When to Reject Swaps​

Use the priceImpact field to decide whether to show or reject a swap. Here are recommended thresholds:

const { data } = await res.json();

if (data.priceImpact < -0.05) {
  throw new Error(
    `Price impact too high: ${(data.priceImpact * 100).toFixed(2)}%`
  );
}

if (data.priceImpact < -0.01) {
  console.warn(
    `Warning: ${(data.priceImpact * 100).toFixed(2)}% price impact`
  );
}

Fee-on-Transfer Tokens​

Some tokens charge a tax on every transfer — typically 1% to 10% of the amount. These are sometimes called "tax tokens" or "reflection tokens." Common examples include SafeMoon-style tokens.

The API cannot detect fee-on-transfer tokens. The expectedAmountOut will not account for the transfer tax, so the actual amount you receive in your wallet will be lower than quoted.

If you know a token charges a transfer fee, increase maxSlippage to accommodate it. For a 5% tax token, set maxSlippage to at least 0.06 (6%) to prevent reverts. A common safe range for known tax tokens is 0.10 to 0.15 (10-15%).

Protecting Against MEV​

MEV (Maximal Extractable Value) bots monitor the mempool for pending swap transactions. A common attack is the "sandwich" — the bot buys the token before your transaction executes (pushing the price up), then sells after your transaction (pocketing the difference).

Your maxSlippage setting is your primary defense. A lower slippage tolerance makes sandwich attacks less profitable, because the bot has less room to extract value. However, setting it too low increases the chance your transaction reverts due to normal price movement.

Recommended values:

• Major pairs (ETH/USDC, ETH/USDT): 0.005 (0.5%)
• Mid-cap tokens: 0.01 to 0.02 (1-2%)
• Small-cap / low liquidity: 0.02 to 0.03 (2-3%)

The swap calldata also includes a deadline — submit the transaction within 30 seconds of receiving the quote. Stale transactions with outdated prices are more vulnerable to MEV extraction.

Best Practices for Production​

1. Always check priceImpact before showing the swap to users. Display it prominently in the UI.
2. Set maxSlippage based on the token pair. Use 0.5% for major pairs, higher for smaller tokens. Let users override if they understand the risk.
3. Simulate with eth_call before submitting. This catches reverts before you pay gas. Use the tx object directly in a static call.
4. Re-fetch quotes if more than 30 seconds have passed. The calldata includes a deadline and prices move. Stale quotes waste gas on reverts.
5. Display minAmountOut to users as "Minimum received." This is the guaranteed floor — the transaction reverts if actual output falls below it.

Related​

• Swap Tutorial
• Compare APIs
• Supported Chains
• AI Agents
• Why No API Key

Why Stablecoin Swaps Matter​

Stablecoins are the backbone of DeFi trading:

• Price stability — Minimize exposure to volatile assets
• Liquidity — Deep pools mean low slippage
• Cross-chain — Move value between chains efficiently
• Trading pairs — Most tokens trade against USDC or USDT

With swapapi, you can swap stablecoins programmatically without managing API keys or authentication.

Common Stablecoin Addresses​

USDC (USD Coin)​

USDC is the most widely used stablecoin in DeFi.

USDT (Tether)​

USDT has the highest trading volume across centralized and decentralized exchanges.

DAI​

DAI is a decentralized stablecoin collateralized by crypto assets.

The Decimal Gotcha​

Always check token decimals. The same token can have different decimals on different chains:

// Wrong on BSC - will send 1,000,000x too much
const amount = 100 * 10**6; // Assumes 6 decimals

// Correct - always fetch decimals dynamically
const decimals = await getDecimals(chainId, tokenAddress);
const amount = 100 * 10**decimals;

Chains with Non-Standard Decimals​

• BSC (56): USDC and USDT use 18 decimals
• Rootstock (30): USDT uses 18 decimals
• Boba BNB (56288): USDT uses 18 decimals

Swapping Stablecoins​

USDC to USDT on Ethereum​

curl "https://api.swapapi.dev/v1/swap/1?\
  tokenIn=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&\
  tokenOut=0xdAC17F958D2ee523a2206206994597C13D831ec7&\
  amount=100000000&\
  sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

DAI to USDC on Arbitrum​

curl "https://api.swapapi.dev/v1/swap/42161?\
  tokenIn=0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1&\
  tokenOut=0xaf88d065e77c8cC2239327C5EDb3A432268e5831&\
  amount=100000000000000000000&\
  sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

TypeScript Example​

async function swapStablecoins(
  chainId: number,
  fromToken: string,
  toToken: string,
  amount: number,
  decimals: number,
  sender: string
) {
  // Convert human-readable amount to raw
  const rawAmount = (amount * 10**decimals).toString();
  
  const res = await fetch(
    `https://api.swapapi.dev/v1/swap/${chainId}?` +
    `tokenIn=${fromToken}&` +
    `tokenOut=${toToken}&` +
    `amount=${rawAmount}&` +
    `sender=${sender}`
  );
  
  const { success, data } = await res.json();
  
  if (!success) throw new Error("Swap failed");
  if (data.status !== "Successful") throw new Error("No route found");
  
  // For stablecoin swaps, price impact should be minimal
  if (data.priceImpact > 0.001) {
    console.warn("High price impact:", data.priceImpact);
  }
  
  return data.tx;
}

// Example: Swap 1000 USDC to USDT on Base
const tx = await swapStablecoins(
  8453,
  "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC
  "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2", // USDT
  1000,
  6,
  "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
);

Best Practices​

1. Always Verify Decimals​

import { createPublicClient, http, erc20Abi } from 'viem';

const client = createPublicClient({
  chain: base,
  transport: http(),
});

async function getDecimals(chainId: number, tokenAddress: string) {
  const decimals = await client.readContract({
    address: tokenAddress as `0x${string}`,
    abi: erc20Abi,
    functionName: 'decimals',
  });
  return decimals;
}

2. Check Price Impact​

Even stablecoin swaps can have price impact on low-liquidity chains:

if (data.priceImpact > 0.001) {
  // 0.1% threshold
  throw new Error("Price impact too high for stablecoin swap");
}

3. Handle Different Addresses​

Don't hardcode addresses. Use a registry:

const STABLECOINS = {
  USDC: {
    1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
    8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    // ...
  },
  USDT: {
    1: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
    // ...
  }
};

4. Test on Small Amounts First​

Always test with $1-10 before executing larger trades.

Stablecoin Swap Strategies​

1. Yield Optimization​

Move between stablecoins to capture the highest yield:

// If USDC lending APY > USDT lending APY, swap to USDC
if (usdcApy > usdtApy + 0.5) {
  await swapStablecoins(chainId, USDT, USDC, amount, 6, sender);
}

2. Arbitrage​

Exploit price differences between stablecoins (requires monitoring):

// If USDC trades at $1.001 and DAI at $1.000, buy DAI, sell USDC
if (usdcPrice > daiPrice + threshold) {
  await swapStablecoins(chainId, USDC, DAI, amount, 6, sender);
}

3. Rebalancing​

Maintain target portfolio weights:

const targetRatio = { USDC: 0.5, USDT: 0.3, DAI: 0.2 };
const currentRatio = await getCurrentRatio();

// Rebalance if drift exceeds threshold
if (Math.abs(currentRatio.USDC - targetRatio.USDC) > 0.05) {
  await rebalancePortfolio();
}

Response Example​

{
  "success": true,
  "data": {
    "status": "Successful",
    "tokenFrom": {
      "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      "symbol": "USDC",
      "decimals": 6
    },
    "tokenTo": {
      "address": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
      "symbol": "USDT",
      "decimals": 6
    },
    "swapPrice": 0.9998,
    "priceImpact": 0.0001,
    "amountIn": "100000000",
    "expectedAmountOut": "99980000",
    "tx": {
      "to": "0x...",
      "data": "0x...",
      "value": "0",
      "gas": "150000"
    }
  },
  "timestamp": "2026-03-20T00:00:00.000Z"
}

Common Errors​

"Insufficient Liquidity"​

Some chains have limited stablecoin liquidity. Try a different route or smaller amount.

"High Price Impact"​

Large trades on low-liquidity chains can move prices significantly. Split into smaller trades.

"Invalid Token"​

Verify the token address is correct for the chain. Many tokens have different addresses on different chains.

Related Resources​

• Complete token addresses
• Building trading bots
• Slippage guide
• API comparison

Major Chains​

Layer 2 Chains​

Emerging Chains​

Other EVM Chains​