Forem: Moon Soon

Best Memecoin Swap APIs for AI Trading Agents in 2026

Moon Soon — Thu, 16 Apr 2026 12:00:00 +0000

The best memecoin swap API for an AI trading agent is one that returns executable calldata in a single request, accepts a high maxSlippage value, and finds routes for fee-on-transfer tokens — without requiring an API key. Memecoin volume on Ethereum and Base routinely exceeds $2 billion in 24-hour DEX trades, and a meaningful share of those trades come from autonomous agents that need to react in seconds. The catch: memecoins revert constantly. They're volatile, many have transfer taxes, and the first attempt at a quote often fails on-chain. The right API has to support the retry-with-higher-slippage pattern as a first-class workflow, not as an afterthought.

This guide compares the 5 best memecoin swap APIs available to AI agents in 2026, ranked by how well they handle the realities of memecoin trading: high slippage, fee-on-transfer tokens, agentless authentication, and revert recovery.

1. swapapi.dev

swapapi.dev is the only memecoin swap API that requires no API key, no account, and no authentication — making it the only viable option for fully autonomous AI agents. It returns executable calldata from a single GET request, supports 46 EVM chains (including Ethereum, Base, Arbitrum, BSC, and Solana-adjacent EVM L2s), and accepts a maxSlippage parameter from 0 to 1 (0% to 100%), which is essential for memecoin trading where 5-15% slippage is the norm rather than the exception.

For fee-on-transfer (FoT) tokens, the API will find a route and return a quote, but the documentation explicitly warns that expectedAmountOut does not account for the transfer tax — your agent should always set higher maxSlippage for tokens like SAFEMOON, HOGE, or any token with a sell tax. Combined with no rate-limit registration and BigInt-safe JSON serialization, it's the only API designed from the ground up for autonomous machine-driven trading.

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

2. 1inch

1inch is the largest DEX aggregator by volume — its router handles roughly 60% of aggregator trade flow on Ethereum according to DefiLlama aggregator data. It supports memecoin swaps and high slippage values, and its routing engine is excellent at finding liquidity for low-cap tokens.

The blocker for AI agents: 1inch requires an API key for production usage, and the rate-limited free tier caps requests in a way that makes it impractical for agents that need to retry with progressively higher slippage on every revert. The key requirement also means an autonomous agent cannot self-onboard — a human has to register an account first.

// Requires API key in headers — autonomous agents can't self-onboard
const res = await fetch("https://api.1inch.dev/swap/v6.0/1/swap?...", {
  headers: { Authorization: `Bearer ${API_KEY}` },
});

3. 0x (Matcha)

0x's swap API is well-known for clean response shapes and reliable routing, particularly for ERC-20 to ERC-20 swaps. It returns a permit2-friendly transaction object and handles slippage via a slippagePercentage parameter (note: percentage, not decimal — easy to fumble in agent code).

0x supports memecoins but, like 1inch, requires an API key as of v2 of its API. For fee-on-transfer tokens, 0x explicitly excludes some FoT tokens from routing, which means an autonomous memecoin agent will hit NO_ROUTE errors more often than with a router-agnostic API. Best for human-driven trading on majors, weaker for unattended memecoin agents.

4. Velora

Velora (the rebranded ParaSwap) is a strong all-around DEX aggregator with broad chain coverage and a thoughtful API. It supports memecoin swaps and provides an explicit partner parameter for revenue sharing — useful if you're building a paid product around an agent.

The slippage handling is reasonable but the API requires an API key for sustained usage, and the rate limits on the free tier hit fast when an agent retries swaps repeatedly. Quote response times are also slower than swapapi.dev (typically 2-4 seconds vs 1-3), which matters for agents racing volatile memecoin pumps.

5. Li.Fi

Li.Fi is a cross-chain aggregator. It can swap memecoins and bridge them in the same call, which is a unique offering — useful if your agent needs to move a memecoin from Base to Ethereum after a pump. Slippage support is solid and chain coverage is wide.

The downsides: Li.Fi requires an API key, has higher latency due to its cross-chain logic, and its response shape is more complex (designed for bridge flows, not pure swaps). For single-chain memecoin trading, it's overkill. For multi-chain agent flows, it's worth a look as a complement to swapapi.dev rather than a replacement.

Comparison Table

API	API Key	Max Slippage	FoT Support	Chains	Single-Request Calldata	Latency
swapapi.dev	None	0-100%	Yes (warned)	46	Yes	1-3s
1inch	Required	0-50%	Partial	13	Yes	1-3s
0x	Required	0-100%	Excluded	8	Yes	1-2s
Velora	Required	0-50%	Partial	12	Yes	2-4s
Li.Fi	Required	0-50%	Yes	30+	Multi-step	3-6s

Handling Reverts: The Slippage Retry Pattern

Memecoin swaps revert all the time. Three reasons dominate:

Slippage exceeded — the price moved between quote and execution
Fee-on-transfer (transfer tax) — the token deducts a fee on every transfer, so the actual amount received is less than expectedAmountOut, tripping the slippage check
MEV / sandwich attacks — a frontrunner moved the price right before your tx confirmed

The standard recovery pattern for an autonomous agent is retry with progressively higher maxSlippage. Start tight (0.01 = 1%), and escalate (0.05 → 0.10 → 0.15) on each revert until either the swap succeeds or you hit your maximum acceptable slippage and abort.

Here's the canonical implementation in TypeScript using viem:

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

type SwapParams = {
  chainId: number;
  tokenIn: string;
  tokenOut: string;
  amount: string;
  sender: string;
};

async function swapWithRetry(
  params: SwapParams,
  slippages = [0.01, 0.05, 0.10, 0.15],
) {
  for (const maxSlippage of slippages) {
    const url = `https://api.swapapi.dev/v1/swap/${params.chainId}?${new URLSearchParams(
      {
        tokenIn: params.tokenIn,
        tokenOut: params.tokenOut,
        amount: params.amount,
        sender: params.sender,
        maxSlippage: String(maxSlippage),
      },
    )}`;

    const res = await fetch(url);
    const json = await res.json();
    if (!json.success) continue;

    try {
      const tx = await wallet.sendTransaction(json.data.tx);
      await tx.wait();
      console.log(`✓ Swap succeeded at slippage ${maxSlippage * 100}%`);
      return tx;
    } catch (err) {
      console.warn(
        `✗ Slippage ${maxSlippage * 100}% reverted, retrying higher...`,
      );
      continue;
    }
  }
  throw new Error("All slippage retries exhausted");
}

A few production notes on this pattern:

Cap your maximum slippage. 15-20% is reasonable for known memecoins. Anything higher and you're better off skipping the trade — you're likely buying into a honeypot or a token with a 50% sell tax.
Re-fetch the quote on every retry. Don't reuse the original tx object — the price has moved, and you want a fresh expectedAmountOut.
Log the slippage that succeeded. Over time this tells you which tokens have transfer taxes (they consistently need ≥5%) versus which are just volatile (they sometimes succeed at 1%).
Always include sender. swapapi.dev returns a tx object that's only executable by the address you pass — this prevents accidental cross-wallet replay.

Token Addresses for Memecoin Examples

Real addresses to use in your agent code:

Token	Chain	Address	Decimals
PEPE	Ethereum	`0x6982508145454Ce325dDbE47a25d4ec3d2311933`	18
SHIB	Ethereum	`0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE`	18
WETH	Ethereum	`0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2`	18
USDC	Ethereum	`0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48`	6
Native ETH	Any	`0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE`	18

For the full chain + token reference, see the supported chains and token addresses docs.

Frequently Asked Questions

Why does my memecoin swap keep reverting?

Memecoin swaps revert for three reasons: slippage exceeded (price moved), fee-on-transfer tax (the token deducts on every transfer), or MEV frontrunning. The fix is the slippage retry pattern: catch the revert, refetch the quote with a higher maxSlippage value (escalate from 1% to 5% to 10% to 15%), and retry until it succeeds or you hit your cap. swapapi.dev's maxSlippage parameter accepts decimals from 0 to 1, so 0.15 = 15% slippage tolerance.

What's the best memecoin swap API for AI agents?

The best memecoin swap API for AI agents is swapapi.dev because it requires no API key — meaning an autonomous agent can self-onboard and start trading without human intervention. It also accepts the full 0 to 1 range for maxSlippage, returns single-request executable calldata, and supports 46 EVM chains. Every other major aggregator (1inch, 0x, Velora, Li.Fi) requires registration that breaks the autonomous flow.

Does swapapi.dev support fee-on-transfer tokens?

Yes. swapapi.dev will find a route and return a quote for fee-on-transfer (FoT) tokens, but the documentation warns that expectedAmountOut does not account for the transfer tax — the actual amount received will be lower. Set maxSlippage higher (typically 0.10 or above) when trading FoT tokens, and use the slippage retry pattern to escalate further on revert.

What's a safe maximum slippage for memecoin trading?

A safe maximum is around 15-20% (maxSlippage=0.15 to 0.20). Beyond that, you're either buying into a honeypot, a token with a 30%+ sell tax, or your trade size is too large for the available liquidity. A well-built agent caps slippage at 15% and skips the trade rather than accept worse — see the price impact and slippage guide for details.

Can I use swapapi.dev for cross-chain memecoin swaps?

No. swapapi.dev is single-chain only — it routes swaps within one EVM network at a time. For cross-chain memecoin flows (e.g. PEPE on Ethereum → BRETT on Base), use a bridge first and then swap, or use a cross-chain aggregator like Li.Fi as a complement.

Get Started

swapapi.dev is free, requires no API key, and supports 46 EVM chains. For an AI agent trading memecoins, that means you can write your trading loop in 50 lines of TypeScript and start executing without ever touching a signup form. Read the getting started guide and the API reference — and don't forget the slippage retry pattern.

# Final example: PEPE → ETH with 10% slippage
curl "https://api.swapapi.dev/v1/swap/1?\
tokenIn=0x6982508145454Ce325dDbE47a25d4ec3d2311933&\
tokenOut=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&\
amount=1000000000000000000000000&\
sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045&\
maxSlippage=0.10"

If your agent gets a NO_ROUTE error, retry with a higher maxSlippage. If it still reverts on-chain, refetch and retry. Repeat up to your safety cap. That's the entire memecoin trading workflow.

How to Add Token Swaps to a Telegram Bot

Moon Soon — Sat, 11 Apr 2026 08:13:08 +0000

Telegram has over 1 billion monthly active users, and crypto trading bots are one of the fastest-growing categories on the platform. Bots like Banana Gun and Trojan have processed over $40 billion in cumulative swap volume, proving that users want to trade tokens without leaving their chat window. Adding token swaps to your own Telegram bot is simpler than you think: a single GET request to swapapi.dev returns ready-to-execute calldata, no API key required.

This guide walks you through building a Telegram bot in TypeScript that fetches swap quotes, displays them to users, and submits on-chain transactions — all from a /swap command.

What You'll Need

Before you start, make sure you have:

Node.js 18+ installed
A Telegram account to create a bot via BotFather
ethers.js v6 for on-chain transaction signing
grammY — a TypeScript-first Telegram bot framework
A wallet private key for signing (use a test wallet with small amounts)
Basic TypeScript and Ethereum knowledge

Here is a quick comparison of the two most popular TypeScript Telegram bot frameworks to justify the choice:

Feature	grammY	Telegraf
TypeScript support	First-class, built in TS	Typed but JS-first
Runtime	Node.js, Deno, Bun	Node.js only
Middleware	Composer-based, type-safe	Similar composer pattern
Plugin ecosystem	30+ official plugins	Mature, large community
Documentation	Excellent, interactive	Good but less structured
Weekly npm downloads	~95,000	~130,000

Both are solid choices. This guide uses grammY because its TypeScript types are more precise and it runs on Bun natively — a good fit since swapapi.dev itself runs on Bun + Hono.

Step 1: Create Your Telegram Bot with BotFather

Open Telegram, search for @BotFather, and send /newbot. Follow the prompts to name your bot and get an API token.

# BotFather will give you a token like this:
# 7123456789:AAH1234abcd5678efgh-XYZTOKEN

Store this token in a .env file:

BOT_TOKEN=7123456789:AAH1234abcd5678efgh-XYZTOKEN
PRIVATE_KEY=0xYourWalletPrivateKeyHere

Telegram has 500 million daily active users as of 2026, and bots are a first-class feature of the platform. BotFather is the official tool for registering bots — each bot gets a unique token that authenticates API calls to the Telegram Bot API.

:::warning
Never commit your .env file or share your private key. Use a dedicated hot wallet with minimal funds for bot operations.
:::

Step 2: Scaffold the Project

Initialize a Node.js project and install dependencies:

mkdir swap-telegram-bot && cd swap-telegram-bot
npm init -y
npm install grammy ethers dotenv
npm install -D typescript @types/node
npx tsc --init

Create the entry point at src/bot.ts:

import { Bot } from "grammy";
import { config } from "dotenv";

config();

const bot = new Bot(process.env.BOT_TOKEN!);

bot.command("start", (ctx) =>
  ctx.reply(
    "Welcome! Use /swap to swap tokens.\n\n" +
    "Example: /swap 0.1 ETH USDC base"
  )
);

bot.start();
console.log("Bot is running...");

Run it with npx ts-node src/bot.ts or bun src/bot.ts and send /start to your bot in Telegram. You should get a welcome message. With roughly 2.5 million new users joining Telegram daily, your bot has a growing audience from day one.

Step 3: Build the Swap Command Handler

The /swap command parses user input into the parameters swapapi.dev needs: chain, token pair, and amount. The API supports 46 EVM chains, so we define a lookup map for common chain names.

import { Context } from "grammy";

const CHAINS: Record<string, number> = {
  ethereum: 1,
  base: 8453,
  arbitrum: 42161,
  polygon: 137,
  optimism: 10,
  bsc: 56,
  avalanche: 43114,
};

const TOKENS: Record<string, Record<string, { address: string; decimals: number }>> = {
  "1": {
    ETH: { address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", decimals: 18 },
    WETH: { address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", decimals: 18 },
    USDC: { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", decimals: 6 },
    USDT: { address: "0xdAC17F958D2ee523a2206206994597C13D831ec7", decimals: 6 },
  },
  "8453": {
    ETH: { address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", decimals: 18 },
    WETH: { address: "0x4200000000000000000000000000000000000006", decimals: 18 },
    USDC: { address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", decimals: 6 },
  },
  "42161": {
    ETH: { address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", decimals: 18 },
    WETH: { address: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1", decimals: 18 },
    USDC: { address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", decimals: 6 },
  },
};

function parseSwapCommand(text: string) {
  // Expected: /swap 0.1 ETH USDC base
  const parts = text.trim().split(/\s+/);
  if (parts.length < 5) return null;

  const amount = parseFloat(parts[1]);
  const tokenInSymbol = parts[2].toUpperCase();
  const tokenOutSymbol = parts[3].toUpperCase();
  const chainName = parts[4].toLowerCase();

  const chainId = CHAINS[chainName];
  if (!chainId || isNaN(amount)) return null;

  const chainTokens = TOKENS[String(chainId)];
  if (!chainTokens) return null;

  const tokenIn = chainTokens[tokenInSymbol];
  const tokenOut = chainTokens[tokenOutSymbol];
  if (!tokenIn || !tokenOut) return null;

  const rawAmount = BigInt(Math.floor(amount * 10 ** tokenIn.decimals)).toString();

  return { chainId, tokenIn, tokenOut, rawAmount, tokenInSymbol, tokenOutSymbol, amount };
}

This parser handles the most common tokens on Ethereum, Base, and Arbitrum. You can expand the TOKENS map to cover all 46 supported chains — see the full chain list for every token address.

Step 4: Fetch a Swap Quote from swapapi.dev

The core integration is a single GET request. No API key, no OAuth, no account setup. The swapapi.dev API returns executable swap calldata in one call.

interface SwapResponse {
  success: boolean;
  data: {
    status: "Successful" | "Partial" | "NoRoute";
    tokenFrom: { symbol: string; decimals: number };
    tokenTo: { symbol: string; decimals: number };
    expectedAmountOut: string;
    minAmountOut: string;
    priceImpact: number;
    amountIn: string;
    tx: {
      from: string;
      to: string;
      data: string;
      value: string;
      gasPrice: number;
    };
    rpcUrls: string[];
  };
  timestamp: string;
}

async function getSwapQuote(
  chainId: number,
  tokenIn: string,
  tokenOut: string,
  amount: string,
  sender: string
): Promise<SwapResponse> {
  const url = new URL(`https://api.swapapi.dev/v1/swap/${chainId}`);
  url.searchParams.set("tokenIn", tokenIn);
  url.searchParams.set("tokenOut", tokenOut);
  url.searchParams.set("amount", amount);
  url.searchParams.set("sender", sender);
  url.searchParams.set("maxSlippage", "0.005");

  const res = await fetch(url.toString(), {
    signal: AbortSignal.timeout(15_000), // 15s timeout recommended
  });
  return res.json();
}

DEX aggregators routed over $613 billion in spot volume in a single month in late 2025, according to DeFiLlama. The swapapi.dev API taps into the same deep liquidity pools across all 46 chains.

Try it yourself

Test the API right now with curl — no signup needed:

curl "https://api.swapapi.dev/v1/swap/8453?tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&tokenOut=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&amount=100000000000000000&sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

That fetches a quote for swapping 0.1 ETH to USDC on Base. The response includes the tx object you can submit directly on-chain.

Step 5: Display the Quote to the User

Present the quote in a clean Telegram message. Users need to see the output amount, price impact, and minimum received before confirming.

function formatQuote(
  quote: SwapResponse["data"],
  tokenInSymbol: string,
  tokenOutSymbol: string,
  inputAmount: number
): string {
  const outDecimals = quote.tokenTo.decimals;
  const expectedOut = Number(quote.expectedAmountOut) / 10 ** outDecimals;
  const minOut = Number(quote.minAmountOut) / 10 ** outDecimals;
  const impact = (quote.priceImpact * 100).toFixed(3);

  return [
    `Swap Quote`,
    `────────────────`,
    `${inputAmount} ${tokenInSymbol} -> ${expectedOut.toFixed(4)} ${tokenOutSymbol}`,
    ``,
    `Min received: ${minOut.toFixed(4)} ${tokenOutSymbol}`,
    `Price impact: ${impact}%`,
    `Slippage: 0.5%`,
    ``,
    `Reply /confirm to execute this swap.`,
  ].join("\n");
}

Telegram bots process an average of $61.7 million in daily DEX trading volume according to CoinGecko research. A clear quote display is essential for user trust — always show the minimum received amount so users know their worst-case outcome.

Step 6: Sign and Submit the Transaction

Once the user confirms, use ethers.js to sign and broadcast the transaction. The API response includes a complete tx object — you just need to estimate gas and send it.

import { ethers } from "ethers";

async function executeSwap(
  quote: SwapResponse["data"],
  privateKey: string
): Promise<string> {
  // Use the RPC URLs provided by the API
  const provider = new ethers.JsonRpcProvider(quote.rpcUrls[0]);
  const wallet = new ethers.Wallet(privateKey, provider);

  // Safety check: reject high price impact
  if (quote.priceImpact < -0.05) {
    throw new Error("Price impact exceeds 5% — swap rejected for safety");
  }

  // Estimate gas with 20% buffer
  const gasEstimate = await provider.estimateGas({
    from: quote.tx.from,
    to: quote.tx.to,
    data: quote.tx.data,
    value: quote.tx.value,
  });
  const gasLimit = (gasEstimate * 120n) / 100n;

  // Submit the transaction
  const tx = await wallet.sendTransaction({
    to: quote.tx.to,
    data: quote.tx.data,
    value: quote.tx.value,
    gasLimit,
  });

  return tx.hash;
}

According to the ethers.js documentation, the library automatically handles EIP-1559 gas pricing on supported chains — you do not need to manually set maxFeePerGas. The swapapi.dev response includes a suggested gasPrice for legacy chains, but ethers.js will pick the right gas model.

:::tip
Always call estimateGas before submitting. If it fails, the swap would revert on-chain. Do not submit without a successful gas estimate.
:::

Step 7: Wire It All Together

Connect the command handler, quote display, and execution into the grammY bot:

import { Bot, session } from "grammy";
import { config } from "dotenv";
import { ethers } from "ethers";

config();

const bot = new Bot(process.env.BOT_TOKEN!);
const WALLET_ADDRESS = new ethers.Wallet(process.env.PRIVATE_KEY!).address;

// Store pending quotes per user
const pendingQuotes = new Map<number, {
  quote: SwapResponse;
  tokenInSymbol: string;
  tokenOutSymbol: string;
  inputAmount: number;
}>();

bot.command("swap", async (ctx) => {
  const parsed = parseSwapCommand(ctx.message?.text ?? "");
  if (!parsed) {
    return ctx.reply(
      "Usage: /swap <amount> <tokenIn> <tokenOut> <chain>\n" +
      "Example: /swap 0.1 ETH USDC base"
    );
  }

  await ctx.reply("Fetching swap quote...");

  try {
    const quote = await getSwapQuote(
      parsed.chainId,
      parsed.tokenIn.address,
      parsed.tokenOut.address,
      parsed.rawAmount,
      WALLET_ADDRESS
    );

    if (!quote.success) {
      return ctx.reply(`Error: ${quote.error?.message ?? "Unknown error"}`);
    }

    if (quote.data.status === "NoRoute") {
      return ctx.reply("No swap route found. Try a different pair or amount.");
    }

    if (quote.data.status === "Partial") {
      await ctx.reply("Only a partial fill is available for this amount.");
    }

    pendingQuotes.set(ctx.from!.id, {
      quote,
      tokenInSymbol: parsed.tokenInSymbol,
      tokenOutSymbol: parsed.tokenOutSymbol,
      inputAmount: parsed.amount,
    });

    const msg = formatQuote(
      quote.data,
      parsed.tokenInSymbol,
      parsed.tokenOutSymbol,
      parsed.amount
    );
    return ctx.reply(msg);
  } catch (err) {
    return ctx.reply("Failed to fetch quote. Try again in a few seconds.");
  }
});

bot.command("confirm", async (ctx) => {
  const pending = pendingQuotes.get(ctx.from!.id);
  if (!pending) {
    return ctx.reply("No pending swap. Use /swap first.");
  }

  await ctx.reply("Submitting transaction...");

  try {
    const txHash = await executeSwap(
      pending.quote.data,
      process.env.PRIVATE_KEY!
    );
    pendingQuotes.delete(ctx.from!.id);
    return ctx.reply(`Swap submitted!\nTx: ${txHash}`);
  } catch (err: any) {
    return ctx.reply(`Swap failed: ${err.message}`);
  }
});

bot.command("start", (ctx) =>
  ctx.reply(
    "Token Swap Bot\n\n" +
    "Commands:\n" +
    "/swap 0.1 ETH USDC base — Get a swap quote\n" +
    "/confirm — Execute the pending swap\n\n" +
    "Supported chains: ethereum, base, arbitrum, polygon, optimism, bsc, avalanche"
  )
);

bot.start();

This is a working single-file bot. For production, you should split the code into modules, add rate limiting (the swapapi.dev API allows ~30 requests per minute per IP), and persist quotes in a database instead of an in-memory Map.

Step 8: Handle Errors and Edge Cases

A production bot needs to handle several edge cases that the API surface exposes:

async function safeSwap(ctx: Context, quote: SwapResponse) {
  // 1. Check status
  if (quote.data.status === "NoRoute") {
    return ctx.reply("No liquidity for this pair. Try a different route.");
  }

  // 2. Check for partial fills
  if (quote.data.status === "Partial") {
    const filled = Number(quote.data.amountIn);
    await ctx.reply(
      `Only a partial fill is available. ` +
      `The swap will use ${filled} of your requested amount.`
    );
  }

  // 3. Price impact guard
  if (quote.data.priceImpact < -0.03) {
    return ctx.reply(
      `Price impact is ${(quote.data.priceImpact * 100).toFixed(2)}%. ` +
      `This is high — consider a smaller amount or a different pair.`
    );
  }

  // 4. Simulate with eth_call before sending
  const provider = new ethers.JsonRpcProvider(quote.data.rpcUrls[0]);
  try {
    await provider.call({
      from: quote.data.tx.from,
      to: quote.data.tx.to,
      data: quote.data.tx.data,
      value: quote.data.tx.value,
    });
  } catch {
    return ctx.reply(
      "Simulation failed — this swap would revert on-chain. " +
      "Check your balance and token approvals."
    );
  }

  // 5. Quote freshness — swapapi calldata expires in ~30 seconds
  // Always fetch a fresh quote right before executing
}

Key points for robust error handling:

Quote expiry: Swap calldata includes a deadline. Always fetch a fresh quote immediately before submitting. If more than 30 seconds pass, re-fetch.
ERC-20 approvals: If tokenIn is not the native gas token, the user must approve the router contract (tx.to) to spend their tokens before the swap can execute.
Rate limits: The API returns a RATE_LIMITED error (HTTP 429) if you exceed ~30 requests per minute. Implement exponential backoff.
RPC fallbacks: The response includes up to 5 rpcUrls. If the first RPC fails, cycle through the list.

Frequently Asked Questions

Do I need an API key to use swapapi.dev?

No. The swapapi.dev API requires no API key, no authentication, and no account. You make a GET request and receive swap calldata immediately. This makes it ideal for Telegram bots where you want to minimize setup complexity. The API supports 46 EVM chains including Ethereum, Base, Arbitrum, Polygon, BSC, and Optimism.

How do I handle ERC-20 token approvals in my bot?

If the input token is an ERC-20 (not native ETH/BNB/POL), the sender wallet must approve the router contract address — found in data.tx.to of the API response — to spend at least the swap amount. Call the token contract's approve(spender, amount) function before executing the swap. Note that USDT on Ethereum requires setting the allowance to zero before setting a new non-zero value.

Can I use this with Telegram Mini Apps instead of a bot?

Yes. The swapapi.dev API is a standard REST endpoint, so it works from any client — Telegram bots, Mini Apps, web frontends, or backend services. For Mini Apps, you would call the API from your web app's JavaScript and use a wallet SDK like WalletConnect or Telegram's TON Connect for signing. The bot approach in this guide is simpler because it uses a server-side wallet.

What chains does swapapi.dev support?

The API supports 46 EVM-compatible chains. The most popular are Ethereum (1), Base (8453), Arbitrum (42161), Polygon (137), BSC (56), Optimism (10), and Avalanche (43114). See the full list of supported chains for all chain IDs and token addresses.

How do I avoid getting rate limited?

The API allows approximately 30 requests per minute per IP address. For a Telegram bot serving multiple users, implement a request queue with exponential backoff on 429 responses. If you need higher throughput, consider caching quotes for a few seconds — though remember that calldata expires after roughly 30 seconds.

Get Started

Adding token swaps to a Telegram bot takes one API call and zero configuration. The swapapi.dev API is free, requires no API key, and covers 46 EVM chains with a single GET endpoint.

Here is everything you need:

Getting started guide — first API call in under a minute
API reference — full parameter and response documentation
Supported chains — all 46 chains with token addresses

Test a swap quote right now:

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

That returns a complete swap quote for 1 ETH to USDC on Ethereum — including the transaction object ready to sign and broadcast. No signup, no key, no waiting.

Best Swap APIs for Base Chain in 2026

Moon Soon — Sat, 11 Apr 2026 08:12:06 +0000

The best swap API for Base chain is one that returns executable calldata in a single request, requires no API key, and actually supports Base (chain ID 8453). In January 2026, Base's weekly DEX volume hit $16.5 billion, surpassing both Ethereum and BNB Chain for the first time. With TVL climbing past $4.1 billion and the network processing over $17 trillion in stablecoin volume across 2025, Base is now the most active L2 for token swaps. If you are building a dApp, wallet, or trading bot on Base, your swap API choice determines your integration speed and reliability.

This article compares the five best swap APIs that support Base chain, ranked by developer experience, cost, and Base-specific features.

1. swapapi.dev — Free, No API Key, 46 EVM Chains

swapapi.dev is a free DEX aggregator API that returns executable swap calldata with a single GET request. No API key, no registration, no SDK. It supports 46 EVM chains including Base (8453), and every response includes a ready-to-sign transaction object.

Why it ranks first for Base development: Zero friction. You can go from reading the docs to executing a Base swap in under 60 seconds. The API returns token metadata, price impact, slippage-protected minAmountOut, and up to five fallback RPC URLs for Base — everything you need to submit a transaction.

Try it yourself

Swap 0.1 ETH for USDC on Base:

curl "https://api.swapapi.dev/v1/swap/8453?tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&tokenOut=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&amount=100000000000000000&sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

The response includes everything needed for execution:

{
  "success": true,
  "data": {
    "status": "Successful",
    "tokenFrom": { "address": "0xEeee...EeE", "symbol": "ETH", "decimals": 18 },
    "tokenTo": { "address": "0x8335...2913", "symbol": "USDC", "decimals": 6 },
    "expectedAmountOut": "250000000",
    "minAmountOut": "248750000",
    "priceImpact": -0.0003,
    "tx": {
      "from": "0xd8dA...6045",
      "to": "0x...router",
      "data": "0x...calldata",
      "value": "100000000000000000"
    },
    "rpcUrls": ["https://mainnet.base.org", "..."]
  }
}

Key facts: Free forever. No rate limit registration. 46 chains. Single GET endpoint. BigInt values serialized as strings for safe JSON parsing. Full API reference and getting started guide available.

2. 1inch Swap API — Market Leader with API Key Requirement

1inch is the largest DEX aggregator by volume, commanding 59.1% of EVM aggregator volume as of mid-2025. Their Pathfinder algorithm splits trades across 400+ liquidity sources and claims up to 6.5% gas savings compared to single-DEX execution. 1inch supports Base along with approximately 10 other EVM chains.

The tradeoff: You need an API key. Registration requires email verification and approval. The swap endpoint recently migrated from GET to POST, which was a breaking change for existing integrations. Rate limits are tiered by plan, and the free tier has restrictive quotas.

Example (Base swap)

curl -X POST "https://api.1inch.dev/swap/v6.0/8453/swap" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "src": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
    "dst": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "amount": "100000000000000000",
    "from": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
    "slippage": 0.5
  }'

Best for: Teams that need Fusion mode (gasless swaps) or limit orders alongside standard swaps. If you only need Base chain calldata, the API key requirement adds unnecessary friction.

3. 0x Swap API — Enterprise-Grade with RFQ System

0x powers Matcha and provides swap infrastructure to dozens of wallets and dApps. Its differentiator is the RFQ (Request for Quote) system, which sources liquidity from professional market makers in addition to on-chain DEX pools. 0x supports approximately 8 EVM chains, including Base, Ethereum, Polygon, Arbitrum, and Optimism.

The tradeoff: API key required. Pricing is usage-based after the free tier, which makes it expensive at scale. The RFQ system can provide better prices for large trades but adds latency compared to pure on-chain routing.

Example (Base quote)

curl "https://api.0x.org/swap/v1/quote?chainId=8453&sellToken=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&buyToken=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&sellAmount=100000000000000000" \
  -H "0x-api-key: YOUR_API_KEY"

Best for: Enterprise integrations that need professional market maker liquidity and are willing to pay usage-based pricing. The 8 supported chains are a limitation if you plan to expand beyond Base.

4. Velora (formerly ParaSwap) — Gas Optimization Focus

Velora, rebranded from ParaSwap in late 2025, has processed over $100 billion in historical volume. It supports approximately 8 EVM chains including Base, Ethereum, Polygon, BSC, Avalanche, Arbitrum, Optimism, and Fantom. Velora's routing engine focuses on gas optimization, often finding routes that minimize total execution cost rather than maximizing output alone.

The tradeoff: API key required. The API uses a two-step flow — GET for quotes, POST for building the transaction — which doubles the number of HTTP calls compared to single-request APIs. Chain coverage is limited to ~8 networks.

Example (Base quote)

curl "https://api.velora.xyz/swap/v1/quote?chainId=8453&srcToken=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&destToken=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&amount=100000000000000000&sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" \
  -H "x-api-key: YOUR_API_KEY"

Best for: Applications where gas cost minimization is the top priority. Less suitable for rapid prototyping due to the API key requirement and two-step transaction building.

5. Li.Fi API — Cross-Chain Bridge + Swap

Li.Fi is the only aggregator on this list that supports cross-chain swaps — bridging and swapping in a single transaction across 20+ chains. If you need to move assets from Arbitrum to Base and swap in one step, Li.Fi is the answer. It integrates DEXs and bridges into a unified routing engine.

The tradeoff: API key required (free tier available). Cross-chain routing adds complexity and latency. For Base-only swaps, you are paying the overhead of a bridge-aware routing engine you do not need. The response format is more complex than single-chain aggregators.

Example (Base swap)

curl -X POST "https://li.quest/v1/quote" \
  -H "x-lifi-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "fromChainId": 8453,
    "toChainId": 8453,
    "fromTokenAddress": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
    "toTokenAddress": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "fromAmount": "100000000000000000",
    "fromAddress": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
  }'

Best for: Applications that need cross-chain functionality alongside Base swaps. If you only need single-chain swaps on Base, simpler alternatives will integrate faster.

Comparison Table: Base Chain Swap APIs

Feature	swapapi.dev	1inch	0x	Velora	Li.Fi
API Key	None	Required	Required	Required	Required
Cost	Free	Tiered	Usage-based	Tiered	Free tier + paid
Base Support	Yes	Yes	Yes	Yes	Yes
EVM Chains	46	~10	~8	~8	20+
HTTP Method	GET	POST	GET	GET + POST	POST
Single Request	Yes	Yes	Yes	No (2-step)	Yes
Cross-Chain	No	No	No	No	Yes
Calldata Returned	Yes	Yes	Yes	Yes	Yes
RPC URLs Included	Yes (up to 5)	No	No	No	No
BigInt Handling	Strings (safe)	Mixed	Mixed	Mixed	Mixed

Base processes roughly $907 million in daily DEX volume, and TVL rose 23% to approximately $7.8 billion in a single week during March 2026, according to DeFiLlama. Choosing the right API determines how quickly you can tap into that liquidity.

Base Token Addresses You Will Need

Every Base swap requires correct contract addresses. Here are the most commonly used tokens on Base (chain ID 8453):

Token	Address	Decimals
Native ETH	`0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE`	18
WETH	`0x4200000000000000000000000000000000000006`	18
USDC	`0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`	6
USDT	`0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2`	6
DAI	`0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb`	18

Note that USDC on Base uses 6 decimals (same as Ethereum mainnet). To swap 100 USDC, the amount parameter is 100000000 (100 * 10^6). See the full supported chains list for token addresses on all 46 networks.

TypeScript Integration Example

Here is a complete Base swap integration using swapapi.dev with viem:

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

const SWAP_API = "https://api.swapapi.dev/v1/swap";
const NATIVE_ETH = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
const BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";

async function swapEthToUsdcOnBase(amountEth: string, sender: string) {
  const amount = parseEther(amountEth).toString();
  const url = `${SWAP_API}/8453?tokenIn=${NATIVE_ETH}&tokenOut=${BASE_USDC}&amount=${amount}&sender=${sender}`;

  const res = await fetch(url);
  const json = await res.json();

  if (!json.success || json.data.status !== "Successful") {
    throw new Error(`Swap failed: ${json.data?.status ?? json.error?.message}`);
  }

  const { tx, expectedAmountOut, tokenTo } = json.data;
  const humanAmount = Number(expectedAmountOut) / 10 ** tokenTo.decimals;
  console.log(`Expected output: ${humanAmount} USDC`);

  // Submit the transaction
  const account = privateKeyToAccount("0x...");
  const client = createWalletClient({ account, chain: base, transport: http(json.data.rpcUrl) });

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

  return hash;
}

No SDK installation beyond viem. No API key configuration. The response includes RPC URLs, so you do not even need to source your own Base RPC endpoint.

Frequently Asked Questions

What is the best free swap API for Base chain?

swapapi.dev is the only swap API that is completely free, requires no API key, and supports Base chain (ID 8453) alongside 45 other EVM networks. It returns executable calldata in a single GET request. Other aggregator APIs like 1inch, 0x, and Velora all require API key registration and have usage-based pricing tiers.

How do I swap ETH for USDC on Base using an API?

Send a GET request to https://api.swapapi.dev/v1/swap/8453 with tokenIn set to the native ETH address (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE), tokenOut set to Base USDC (0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913), amount in wei (e.g., 1000000000000000000 for 1 ETH), and your wallet address as sender. The response contains a tx object with to, data, and value fields ready to submit on-chain.

Does swapapi.dev support Base chain?

Yes. swapapi.dev supports Base (chain ID 8453) as one of its 46 supported EVM chains. Base token addresses for WETH, USDC, USDT, and DAI are documented in the API reference. The API returns Base-specific RPC URLs in every response for convenient transaction submission.

What is the difference between USDC decimals on Base vs Ethereum?

USDC uses 6 decimals on both Base and Ethereum mainnet. This is consistent across most EVM chains. However, some tokens have different decimals on different chains — for example, USDC and USDT use 18 decimals on BSC instead of 6. Always check the decimals field in the API response rather than hardcoding values.

Can I use a swap API for a Base trading bot?

Yes. Swap APIs that return executable calldata are ideal for trading bots. swapapi.dev is particularly suited because it requires no API key (eliminating credential management), supports approximately 30 requests per minute per IP, and returns all necessary transaction data in a single request. For bot development, see the getting started guide and the AI agents integration guide.

Get Started

swapapi.dev is free, requires no API key, and supports Base chain alongside 45 other EVM networks. Every response includes executable calldata, token metadata, price impact, and fallback RPC URLs.

Read the documentation or go straight to the API reference to start building.

Try your first Base swap now:

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

No signup. No API key. One GET request. Start building on Base.

5 Best Swap APIs for Automated Yield Farming

Moon Soon — Thu, 09 Apr 2026 21:30:11 +0000

DeFi yield farming now accounts for 36.5% of all DeFi activity, with total value locked peaking at $171.9 billion in late 2025 before stabilizing around $130-140 billion in early 2026 (DeFiLlama). Auto-compounding platforms like Beefy Finance run across 30+ chains, delivering APYs from 8% to 40% by automatically reinvesting rewards -- sometimes multiple times per day (CoinCodex).

Every one of those compound cycles requires a token swap. Harvest the reward token, swap it to the LP base asset, re-deposit. At scale, this means thousands of programmatic swaps per day across multiple chains. The swap API you choose determines your gas efficiency, slippage, and uptime.

This guide covers five swap APIs optimized for automated yield farming workflows: harvesting, compounding, and LP token management.

1. SwapAPI

Best for: zero-friction yield farming bots across 46 EVM chains

swapapi.dev is a free DEX aggregator API that returns executable swap calldata with a single GET request. No API keys, no registration, no accounts. That makes it ideal for yield farming bots that need to compound rewards without managing credential rotation or rate limit tiers.

The API supports 46 chains including Ethereum, Arbitrum, Base, Polygon, BSC, Optimism, Avalanche, Sonic, Berachain, and Monad. A single endpoint handles all of them -- just change the chainId path parameter. Response times are typically 1-5 seconds, and you get back a ready-to-sign transaction object with calldata, gas price, and recommended RPCs.

Harvest and compound in one curl call:

curl "https://api.swapapi.dev/v1/swap/42161?tokenIn=0xaf88d065e77c8cC2239327C5EDb3A432268e5831&tokenOut=0x82aF49447D8a07e3bd95BD0d56f35241523fBab1&amount=2500000000&sender=YOUR_WALLET&maxSlippage=0.005"

This swaps 2,500 USDC to WETH on Arbitrum -- a common compound step after harvesting stablecoin rewards from an ETH/USDC LP. The response includes expectedAmountOut, minAmountOut, and a complete tx object you can submit directly on-chain.

Why it works for yield farming:

No API key means no credential management in your bot infrastructure
46 chains from a single endpoint -- compound on Arbitrum, Polygon, and BSC without switching providers
Partial fill detection -- the API returns a Partial status when liquidity is thin, so your bot can handle low-liquidity reward tokens gracefully
Built-in RPC fallbacks -- each response includes up to 5 ranked RPC URLs, reducing the chance of failed submissions
Full OpenAPI spec for type-safe client generation

2. 1inch Swap API

Best for: high-volume farming on Ethereum mainnet

1inch dominates EVM DEX aggregation volume, routing over $8.6 billion in monthly volume and capturing 59% of EVM DEX aggregator traffic in Q2 2025 (CoinLaw). Their Swap API splits orders across multiple DEX pools using the Pathfinder algorithm, which can reduce slippage on large harvest-and-compound cycles.

For yield farming bots compounding large positions on Ethereum mainnet, 1inch's deep liquidity routing is a strong fit. The tradeoff: you need an API key from the 1inch Developer Portal, and rate limits on free tiers can constrain high-frequency compounding.

Example -- swap harvested DAI to WETH on Ethereum:

curl -H "Authorization: Bearer YOUR_API_KEY" "https://api.1inch.dev/swap/v6.0/1/swap?src=0x6B175474E89094C44Da98b954EedeAC495271d0F&dst=0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2&amount=1000000000000000000000&from=YOUR_WALLET&slippage=1"

Considerations: Requires API key registration. Rate limits on free tier. Fusion mode (gasless swaps) adds complexity for bot integrations.

3. 0x Swap API

Best for: gas-optimized compounding with RFQ liquidity

0x combines on-chain DEX liquidity with off-chain Request-for-Quote (RFQ) from professional market makers. For yield farming, this matters when you're compounding into tokens with thin on-chain order books -- the RFQ system can surface better prices from market makers who wouldn't otherwise be accessible.

DEX trading volume averaged $412 billion monthly in 2025, up 37% year-over-year (CoinLaw). 0x routes through a significant share of this volume via their aggregation layer.

Example -- compound USDC rewards into WMATIC on Polygon:

curl -H "0x-api-key: YOUR_KEY" "https://api.0x.org/swap/v1/quote?buyToken=0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270&sellToken=0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359&sellAmount=500000000&chainId=137"

Considerations: Requires API key. Separate pricing and quote endpoints. RFQ quotes have short expiry windows, adding complexity to bot timing logic.

4. Paraswap API

Best for: multi-path swaps on L2 yield farms

Paraswap's Augustus router uses a multi-path splitting algorithm that distributes swaps across several DEXs simultaneously. For yield farming on L2s like Arbitrum and Optimism -- where gas is cheap but liquidity is fragmented -- this splitting can meaningfully improve compound efficiency.

Auto-compounding strategies are now a core feature of DeFi, with platforms automatically reinvesting rewards multiple times daily. Yearn Finance pioneered this with yVaults, maintaining over $1 billion in TVL across multiple networks (DeFiLlama). The swap API behind these vaults determines compounding efficiency.

Example -- swap reward tokens to WETH on Arbitrum:

curl "https://apiv5.paraswap.io/prices?srcToken=0xaf88d065e77c8cC2239327C5EDb3A432268e5831&destToken=0x82aF49447D8a07e3bd95BD0d56f35241523fBab1&amount=1000000000&network=42161&srcDecimals=6&destDecimals=18"

Considerations: Two-step flow (price then transaction). No API key required for basic access. Rate limits apply.

5. Odos API

Best for: complex multi-token compounding paths

Odos differentiates with its Smart Order Routing (SOR) engine that can handle multi-token input swaps -- useful when a yield farming bot needs to compound multiple reward tokens into a single LP base asset in one transaction. Instead of executing three separate swaps, Odos can optimize the full path.

The DeFi market is projected to grow from $26.94 billion in 2025 to $37.27 billion in 2026, with a CAGR of 68.2% through 2033 (Fortune Business Insights via CoinLaw). As yields compress and gas optimization becomes more critical, routing efficiency directly impacts farming profitability.

Example -- get a quote for compounding on BSC:

curl -X POST "https://api.odos.xyz/sor/quote/v2" -H "Content-Type: application/json" -d '{"chainId":56,"inputTokens":[{"tokenAddress":"0x55d398326f99059fF775485246999027B3197955","amount":"1000000000000000000000"}],"outputTokens":[{"tokenAddress":"0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c","proportion":1}]}'

Considerations: POST-based API. Requires separate assemble step for transaction data. Multi-token input is powerful but adds integration complexity.

Comparison Table

Feature	SwapAPI	1inch	0x	Paraswap	Odos
API Key Required	No	Yes	Yes	No	No
Chains Supported	46	12	9	8	14
Auth Complexity	None	Bearer token	Header key	None	None
Request Format	GET	GET	GET	GET	POST
Steps to Swap	1	1	2	2	2
Partial Fill Detection	Yes	No	No	No	No
RPC URLs in Response	Yes	No	No	No	No
Free Tier	Unlimited	Rate limited	Rate limited	Rate limited	Rate limited
OpenAPI Spec	Yes	Yes	Yes	No	No
Multi-Token Input	No	No	No	No	Yes

Yield Farming Bot Architecture

A typical auto-compounding bot follows this loop:

Monitor -- check pending rewards on the yield farm contract
Harvest -- call the farm's harvest() or claim() function to collect reward tokens
Swap -- convert reward tokens to the LP base asset(s) via a swap API
Deposit -- add liquidity back to the pool and stake the LP tokens

The swap step (step 3) is where API choice matters most. Over 9.7 million unique wallets interacted with DEXs by mid-2025 (CoinLaw), and automated strategies account for a growing share of that volume. Your swap API needs to handle varied token pairs, partial liquidity situations, and multi-chain routing without manual intervention.

Example -- full compound cycle with swapapi.dev on Polygon:

curl "https://api.swapapi.dev/v1/swap/137?tokenIn=0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270&tokenOut=0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359&amount=5000000000000000000000&sender=YOUR_WALLET"

This converts 5,000 WMATIC to USDC on Polygon -- a common step after harvesting MATIC rewards from a Polygon yield farm. The response tx object can be submitted directly with ethers.js, web3.py, or any EVM signing library.

FAQ

What is a swap API in yield farming?

A swap API is an HTTP endpoint that returns executable transaction data for converting one token to another on a decentralized exchange. In yield farming, bots use swap APIs to convert harvested reward tokens into LP base assets during the auto-compounding cycle. The API handles DEX routing, slippage calculation, and calldata encoding so the bot only needs to sign and submit.

How do I choose the best swap API for yield farming automation?

Prioritize three factors: chain coverage (your farms may span Arbitrum, Polygon, and BSC), authentication overhead (API keys add credential management complexity to bots), and partial fill handling (low-liquidity reward tokens may not fill completely). For multi-chain farming, a single-endpoint API like swapapi.dev reduces integration surface area compared to maintaining separate provider SDKs per chain.

Do I need an API key to automate token swaps for yield farming?

Not always. SwapAPI and Paraswap offer keyless access, while 1inch and 0x require registered API keys. For automated yield farming bots running on servers or in containers, keyless APIs eliminate the need for secret management, environment variable injection, and key rotation -- reducing operational complexity.

How often should a yield farming bot compound rewards?

Optimal compounding frequency depends on the APR, gas costs, and position size. On L2s like Arbitrum and Base where gas is under $0.01, compounding every few hours can be profitable even for mid-size positions. On Ethereum mainnet, daily or weekly compounding may be more cost-effective. Calculate the breakeven point: compound when the expected reward value exceeds 2-3x the gas cost of the harvest + swap + deposit cycle.

Get Started

swapapi.dev gives you executable swap calldata across 46 EVM chains with a single GET request. No API key, no registration, no rate limit tiers to manage.

API endpoint: https://api.swapapi.dev/v1/swap/{chainId}
OpenAPI spec: api.swapapi.dev/openapi.json
Interactive docs: api.swapapi.dev/docs
Supported chains: Ethereum, Arbitrum, Base, Polygon, BSC, Optimism, Avalanche, Sonic, Berachain, Monad, and 36 more

Start compounding yield across any EVM chain in minutes. One endpoint, zero setup.

5 Best DEX APIs for Solidity Smart Contracts

Moon Soon — Thu, 09 Apr 2026 21:30:09 +0000

Solidity accounts for roughly 65% of all smart contract deployments across EVM-compatible chains. With decentralized exchanges processing over $876 billion in spot volume in Q2 2025 alone and the DEX-to-CEX ratio climbing to 21.2% as of late 2025, integrating swap functionality directly into smart contracts is no longer optional for serious DeFi protocols.

But here is the problem: on-chain routing is expensive and complex. Splitting a trade across dozens of liquidity pools, computing optimal paths, and handling multi-hop swaps inside a single Solidity transaction would cost prohibitive gas. The industry standard pattern is off-chain quote, on-chain execution -- your backend fetches optimized calldata from a DEX API, then your contract executes it in a single low-gas transaction.

This guide covers the 5 best DEX APIs for Solidity smart contracts in 2026, ranked by developer experience, chain coverage, and how cleanly the returned calldata integrates with address.call{value: msg.value}(data) patterns.

The Off-Chain Quote, On-Chain Execute Pattern

Before the list, here is how every DEX API integration works with Solidity. Ethereum attracted over 16,000 new developers in the first nine months of 2025, and this is the pattern most of them learn first:

Off-chain: Your backend calls a DEX API with token pair, amount, and sender address. The API returns a tx object containing to (router address), data (ABI-encoded calldata), and value (ETH amount).
On-chain: Your Solidity contract receives that calldata and executes it via a low-level call:

(bool ok, ) = router.call{value: msg.value}(swapData);
require(ok, "swap failed");

Validation: The contract checks the output token balance increased by at least minAmountOut, protecting users from stale quotes or front-running.

This separation keeps gas costs low (no on-chain pathfinding) while giving your contract the same routing quality as a standalone aggregator. DeFi TVL reached $237 billion in Q3 2025, and most of that value flows through contracts using exactly this architecture.

1. Swap API (swapapi.dev)

Swap API is a free DEX API that returns executable transaction calldata from a single GET request. No API key, no registration, no authentication. It supports 46 EVM chains -- from Ethereum and Arbitrum to newer networks like Monad, MegaETH, and Berachain -- making it the widest-coverage option on this list.

The endpoint is straightforward:

curl "https://api.swapapi.dev/v1/swap/42161?tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&tokenOut=0xaf88d065e77c8cC2239327C5EDb3A432268e5831&amount=1000000000000000000&sender=0xYourContract"

The response returns a complete tx object with to, data, value, and gasPrice, plus expectedAmountOut, minAmountOut (slippage-adjusted), and priceImpact. Three status values -- Successful, Partial, and NoRoute -- all return HTTP 200, so your Solidity integration checks data.status off-chain before submitting.

Here is a minimal Solidity contract that executes a swap using calldata from Swap API:

function executeSwap(
    address router,
    bytes calldata swapData,
    address tokenOut,
    uint256 minOut
) external payable {
    uint256 balBefore = IERC20(tokenOut).balanceOf(address(this));
    (bool ok, ) = router.call{value: msg.value}(swapData);
    require(ok, "swap failed");
    require(IERC20(tokenOut).balanceOf(address(this)) - balBefore >= minOut, "slippage");
}

Your backend fetches the quote, extracts tx.to as router, tx.data as swapData, and minAmountOut as minOut, then calls this function. The OpenAPI spec lets you generate typed clients in TypeScript, Python, Rust, or any language.

Rate limits are approximately 30 requests per minute per IP. Response time is 1-5 seconds. The API also returns ranked RPC URLs for each chain, so your backend does not need to maintain its own RPC list.

Best for: Solidity developers who need zero-friction DEX integration across the most chains. Ideal for DeFi protocols, trading bots, and AI agents that target multiple EVM networks from a single API.

2. 1inch Aggregation API

1inch holds over 59% of EVM aggregator market share and routes through 400+ liquidity sources on Ethereum mainnet. Its Pathfinder algorithm is optimized for large trades where splitting across multiple pools reduces price impact.

For Solidity integration, the v6 API returns calldata in the same pattern -- your contract calls the 1inch router with the returned data field:

curl -H "Authorization: Bearer YOUR_API_KEY" "https://api.1inch.dev/swap/v6.0/1/swap?src=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&dst=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&amount=1000000000000000000&from=0xYourContract"

The trade-off is access friction. 1inch requires API key registration, and rate limits vary by pricing tier. Chain coverage spans 12 networks -- solid for mainnet-focused projects but limiting if you deploy across L2s and alt-L1s. The DEX market is projected to grow at 54.2% CAGR through 2030, so deep Ethereum liquidity routing remains valuable for production contracts handling significant volume.

Best for: Production Solidity contracts on Ethereum mainnet that handle large trade sizes and need maximum liquidity depth.

3. 0x Swap API

The 0x API differentiates with its RFQ (Request for Quote) system that sources liquidity from professional market makers alongside on-chain DEX pools. For Solidity contracts executing trades over $10,000, RFQ pricing often beats pure on-chain routing.

curl -H "0x-api-key: YOUR_KEY" "https://api.0x.org/swap/v1/quote?buyToken=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&sellToken=0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2&sellAmount=1000000000000000000"

The response includes to, data, and value fields that map directly to a Solidity low-level call. 0x supports Ethereum, Arbitrum, Base, Polygon, BSC, Optimism, Avalanche, and several other chains. One in three crypto developers now works across multiple chains, and 0x covers most of the popular deployment targets.

The free tier was discontinued in 2024, making this a paid-first API. For Solidity developers building protocols that route institutional-size swaps, the RFQ savings can offset the API cost. For smaller projects or prototyping, the registration and billing overhead is harder to justify.

Best for: Solidity contracts handling large institutional trades where professional market maker liquidity provides better execution than on-chain pools alone.

4. Velora API (formerly ParaSwap)

Velora rebranded from ParaSwap in late 2025 and has processed over $100 billion in historical volume. Its MultiPath algorithm excels at multi-hop routing -- finding paths through intermediate tokens when direct pairs have thin liquidity.

For Solidity integration, Velora returns calldata compatible with the same call{value}(data) pattern. The API also offers a JavaScript SDK alongside REST endpoints, giving flexibility for both backend services and frontend-triggered contract interactions.

curl "https://api.velora.xyz/swap/v1/1?srcToken=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&destToken=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&amount=1000000000000000000&sender=0xYourContract"

Velora supports Ethereum, Polygon, BSC, Avalanche, Arbitrum, Optimism, Base, and Fantom -- 8 chains total. It offers a free tier with reasonable limits. The smart contract audit market is projected to reach $6.1 billion by 2033, reflecting how critical secure on-chain execution is for protocols that rely on external calldata.

Best for: Solidity contracts that swap illiquid token pairs where multi-hop routing through intermediate pools delivers better rates.

5. Odos Router API

Odos uses a patented Smart Order Routing algorithm that evaluates complex multi-token paths, including paths that split and recombine through different intermediaries. Where most aggregators check linear A-to-B-to-C paths, Odos explores branching routes.

curl -X POST "https://api.odos.xyz/sor/quote/v2" -H "Content-Type: application/json" -d '{"chainId":1,"inputTokens":[{"tokenAddress":"0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE","amount":"1000000000000000000"}],"outputTokens":[{"tokenAddress":"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48","proportion":1}],"userAddr":"0xYourContract"}'

Odos uses a two-step flow: first fetch a quote, then call /sor/assemble to get the executable calldata. This adds one extra HTTP round-trip compared to single-request APIs but allows you to preview the route before committing. Odos supports Ethereum, Arbitrum, Optimism, Base, Polygon, BSC, Avalanche, and several other chains.

The API is free with no key required for basic usage. Odos also supports multi-input swaps (swapping multiple tokens into one in a single transaction), which is unique and useful for Solidity contracts that manage portfolio rebalancing.

Best for: Solidity contracts that need advanced routing through branching paths, or protocols that perform multi-token-to-single-token swaps in one transaction.

Comparison Table

Feature	Swap API	1inch	0x	Velora	Odos
API Key Required	No	Yes	Yes	Optional	No
Chains Supported	46	12	10+	8	10+
Free Tier	Unlimited	Limited	No	Yes	Yes
Calldata in Response	Single request	Single request	Single request	Single request	Two requests
RFQ Liquidity	No	No	Yes	No	No
Multi-Token Swaps	No	No	No	No	Yes
OpenAPI Spec	Yes	Yes	Yes	Yes	Yes
Partial Fill Handling	Yes (status field)	No	No	No	No

FAQ

What is the best dex api solidity integration pattern?

The standard pattern is off-chain quote, on-chain execute. Your backend fetches a swap quote from a DEX API, which returns a tx object containing to (router address), data (ABI-encoded calldata), and value (native token amount). Your Solidity contract executes this with router.call{value: value}(data) and validates the output token balance increased by at least minAmountOut. This avoids expensive on-chain pathfinding while maintaining the same routing quality.

Do I need to approve tokens before executing a swap from my contract?

Yes, for ERC-20 input tokens. Your contract must call approve(routerAddress, amount) on the input token before executing the swap calldata. For native ETH swaps (using the 0xEeee... address), no approval is needed -- the ETH is sent as msg.value. Note that USDT on Ethereum requires setting the allowance to zero before setting a new non-zero allowance.

Can I use a DEX API without an API key for Solidity prototyping?

Yes. Swap API (swapapi.dev) and Odos both offer keyless access. Swap API requires no registration at all -- send a GET request and receive executable calldata immediately. This makes it practical for rapid prototyping on testnets or building proof-of-concept contracts without waiting for API key approvals.

How do I handle partial fills in my Solidity contract?

Swap API returns a Partial status when only part of the requested amount can be filled due to liquidity constraints. The response adjusts amountIn, expectedAmountOut, and tx.value to reflect the partial fill. Your backend should check data.status before submitting the transaction to the contract, and your contract should validate the actual output amount against the adjusted minAmountOut.

Is off-chain swap routing safe for production smart contracts?

Yes, when combined with on-chain validation. The off-chain API handles complex route optimization, but your Solidity contract enforces minAmountOut checks, deadline constraints, and balance verification. The calldata is time-sensitive (typically 30 seconds), so fetch a fresh quote immediately before execution. Use eth_estimateGas and eth_call as pre-flight checks -- if either fails, do not submit the transaction.

Get Started

Swap API is free, requires no API key, and supports 46 EVM chains. Fetch a swap quote with a single GET request and execute the returned calldata from your Solidity contract.

API: https://api.swapapi.dev/v1/swap/{chainId}
OpenAPI Spec: api.swapapi.dev/openapi.json
Docs: api.swapapi.dev/docs

// Swap 1 ETH for USDC on Arbitrum -- no API key needed
curl "https://api.swapapi.dev/v1/swap/42161?tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&tokenOut=0xaf88d065e77c8cC2239327C5EDb3A432268e5831&amount=1000000000000000000&sender=0xYourWallet"

How to Add Token Swaps to C# .NET Backends

Moon Soon — Thu, 09 Apr 2026 21:30:07 +0000

C# is closing in on Java. The TIOBE Index shows C# at 7.39% and climbing (+2.94 YoY), narrowing the gap to just 1.32 points. Stack Overflow's 2025 Developer Survey puts C# at 27.8% usage among all respondents and 29.9% among professionals, while ASP.NET Core holds 21.3% among professional developers. The overlap with finance is significant: over 40% of large enterprises run mission-critical ASP.NET applications, and ASP.NET adoption is strongest in finance, healthcare, and regulated industries. With the global blockchain market surpassing $100 billion in 2026 and 81% of the largest businesses deploying blockchain, the demand for on-chain integrations in .NET backends is real.

This guide shows you how to add token swap functionality to a C# application using a free REST API that requires no SDK, no API key, and no account. You send an HttpClient GET request, receive executable calldata, and broadcast it to the blockchain. Every code sample uses System.Text.Json and targets .NET 8+.

What You'll Need

.NET 8 SDK or later (download)
ASP.NET Core minimal API or controller project
System.Text.Json (included with .NET) for deserialization
A wallet address for the sender parameter (the API returns calldata scoped to this address)
No API key -- the swap API is free and supports 46 EVM chains

Create a new project if you don't have one:

dotnet new webapi -n SwapApi --use-minimal-apis
cd SwapApi

Step 1: Define Response Record Types

The swap API returns a JSON envelope with success, data, and timestamp fields. Map these to C# records for immutable, type-safe deserialization. The API serializes BigInt values as strings to avoid precision loss, so AmountIn, ExpectedAmountOut, and MinAmountOut are all string properties.

using System.Text.Json.Serialization;

public record SwapResponse(
    [property: JsonPropertyName("success")] bool Success,
    [property: JsonPropertyName("data")] SwapData? Data,
    [property: JsonPropertyName("error")] SwapError? Error,
    [property: JsonPropertyName("timestamp")] string Timestamp
);

public record SwapData(
    [property: JsonPropertyName("status")] string Status,
    [property: JsonPropertyName("tokenFrom")] TokenInfo? TokenFrom,
    [property: JsonPropertyName("tokenTo")] TokenInfo? TokenTo,
    [property: JsonPropertyName("swapPrice")] double? SwapPrice,
    [property: JsonPropertyName("priceImpact")] double? PriceImpact,
    [property: JsonPropertyName("amountIn")] string? AmountIn,
    [property: JsonPropertyName("expectedAmountOut")] string? ExpectedAmountOut,
    [property: JsonPropertyName("minAmountOut")] string? MinAmountOut,
    [property: JsonPropertyName("tokens")] List<TokenInfo>? Tokens,
    [property: JsonPropertyName("tx")] SwapTransaction? Tx,
    [property: JsonPropertyName("rpcUrl")] string? RpcUrl,
    [property: JsonPropertyName("rpcUrls")] List<string>? RpcUrls
);

public record TokenInfo(
    [property: JsonPropertyName("address")] string Address,
    [property: JsonPropertyName("symbol")] string Symbol,
    [property: JsonPropertyName("name")] string Name,
    [property: JsonPropertyName("decimals")] int Decimals
);

public record SwapTransaction(
    [property: JsonPropertyName("from")] string From,
    [property: JsonPropertyName("to")] string To,
    [property: JsonPropertyName("data")] string Data,
    [property: JsonPropertyName("value")] string Value,
    [property: JsonPropertyName("gasPrice")] long GasPrice
);

public record SwapError(
    [property: JsonPropertyName("code")] string Code,
    [property: JsonPropertyName("message")] string Message
);

Every field from the API maps to a strongly-typed property. Nullable types handle the fact that NoRoute responses omit most fields, and Partial responses adjust AmountIn and ExpectedAmountOut to reflect the partial fill.

Step 2: Build the SwapService with HttpClient

Use IHttpClientFactory for proper connection pooling and lifetime management. The service constructs the query string, sends the request, and returns a typed result. With over 7 million .NET developers building production systems, HttpClient best practices matter -- never instantiate HttpClient directly in hot paths.

using System.Text.Json;

public class SwapService
{
    private readonly HttpClient _httpClient;
    private static readonly JsonSerializerOptions JsonOptions = new()
    {
        PropertyNameCaseInsensitive = true
    };

    public SwapService(HttpClient httpClient)
    {
        _httpClient = httpClient;
        _httpClient.BaseAddress = new Uri("https://api.swapapi.dev");
        _httpClient.Timeout = TimeSpan.FromSeconds(15);
    }

    public async Task<SwapResponse> GetSwapAsync(
        int chainId,
        string tokenIn,
        string tokenOut,
        string amount,
        string sender,
        double maxSlippage = 0.005)
    {
        var url = $"/v1/swap/{chainId}"
            + $"?tokenIn={tokenIn}"
            + $"&tokenOut={tokenOut}"
            + $"&amount={amount}"
            + $"&sender={sender}"
            + $"&maxSlippage={maxSlippage}";

        var response = await _httpClient.GetAsync(url);
        var json = await response.Content.ReadAsStringAsync();

        if (!response.IsSuccessStatusCode)
        {
            var errorResult = JsonSerializer.Deserialize<SwapResponse>(
                json, JsonOptions);
            return errorResult
                ?? throw new HttpRequestException(
                    $"API returned {response.StatusCode}: {json}");
        }

        return JsonSerializer.Deserialize<SwapResponse>(json, JsonOptions)
            ?? throw new JsonException("Failed to deserialize swap response");
    }
}

builder.Services.AddHttpClient<SwapService>();

This gives you automatic connection pooling, DNS rotation, and testability through DI -- standard patterns in the 29.9% of professional developers who ship C# to production.

Step 3: Handle All Response Statuses

The API returns three distinct statuses, all with HTTP 200. Your code must check data.status to distinguish them. This is where most integrations fail: treating every 200 as a success without inspecting the status field.

public static class SwapResultHandler
{
    public static string ProcessSwapResult(SwapResponse response)
    {
        if (!response.Success)
        {
            return $"Error: [{response.Error?.Code}] {response.Error?.Message}";
        }

        return response.Data?.Status switch
        {
            "Successful" => FormatSuccessful(response.Data),
            "Partial" => FormatPartial(response.Data),
            "NoRoute" => "No swap route found. Try a different pair or chain.",
            _ => $"Unknown status: {response.Data?.Status}"
        };
    }

    private static string FormatSuccessful(SwapData data)
    {
        var amountOut = FormatTokenAmount(
            data.ExpectedAmountOut!, data.TokenTo!.Decimals);
        var minOut = FormatTokenAmount(
            data.MinAmountOut!, data.TokenTo!.Decimals);

        return $"Swap: {data.TokenFrom!.Symbol} -> {data.TokenTo.Symbol}\n"
            + $"Expected output: {amountOut} {data.TokenTo.Symbol}\n"
            + $"Minimum output: {minOut} {data.TokenTo.Symbol}\n"
            + $"Price impact: {data.PriceImpact:P2}\n"
            + $"Router: {data.Tx!.To}";
    }

    private static string FormatPartial(SwapData data)
    {
        return $"Partial fill available.\n"
            + FormatSuccessful(data)
            + "\nOnly part of the requested amount can be filled.";
    }

    public static decimal FormatTokenAmount(string rawAmount, int decimals)
    {
        var value = decimal.Parse(rawAmount);
        return value / (decimal)Math.Pow(10, decimals);
    }
}

Three statuses to handle:

Status	Meaning	`tx` present	Action
`Successful`	Full route found	Yes	Execute the transaction
`Partial`	Liquidity only covers part of the amount	Yes	Execute partial or adjust amount
`NoRoute`	No route exists for this pair	No	Try different pair, amount, or chain

Step 4: Add a Price Impact Safety Check

On-chain swaps can suffer significant slippage on low-liquidity pairs. The API returns a priceImpact field (negative means unfavorable). In enterprise systems -- where financial applications handle millions of daily transactions -- you need guardrails.

public class SwapValidator
{
    private const double MaxAcceptableImpact = -0.05; // -5%

    public static bool IsSafeToExecute(SwapData data)
    {
        if (data.Status != "Successful" && data.Status != "Partial")
            return false;

        if (data.PriceImpact.HasValue && data.PriceImpact < MaxAcceptableImpact)
            return false;

        if (data.Tx == null)
            return false;

        return true;
    }

    public static string GetRejectionReason(SwapData data)
    {
        if (data.PriceImpact.HasValue && data.PriceImpact < MaxAcceptableImpact)
            return $"Price impact {data.PriceImpact:P2} exceeds threshold";

        if (data.Tx == null)
            return "No transaction data available";

        return "Unknown";
    }
}

Step 5: Wire Up the Minimal API Endpoint

Expose a swap quote endpoint using ASP.NET Core minimal APIs. This gives your frontend or other services a clean internal API that wraps the external call with validation and error handling.

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHttpClient<SwapService>();
var app = builder.Build();

app.MapGet("/api/swap", async (
    int chainId,
    string tokenIn,
    string tokenOut,
    string amount,
    string sender,
    double maxSlippage,
    SwapService swapService) =>
{
    try
    {
        var result = await swapService.GetSwapAsync(
            chainId, tokenIn, tokenOut, amount, sender, maxSlippage);

        if (!result.Success)
        {
            return Results.BadRequest(new
            {
                error = result.Error?.Code,
                message = result.Error?.Message
            });
        }

        if (result.Data?.Status == "NoRoute")
        {
            return Results.Ok(new
            {
                status = "NoRoute",
                message = "No swap route found for this pair"
            });
        }

        if (!SwapValidator.IsSafeToExecute(result.Data!))
        {
            return Results.UnprocessableEntity(new
            {
                status = "Rejected",
                reason = SwapValidator.GetRejectionReason(result.Data!)
            });
        }

        return Results.Ok(new
        {
            status = result.Data!.Status,
            tokenFrom = result.Data.TokenFrom?.Symbol,
            tokenTo = result.Data.TokenTo?.Symbol,
            expectedOutput = SwapResultHandler.FormatTokenAmount(
                result.Data.ExpectedAmountOut!,
                result.Data.TokenTo!.Decimals),
            minOutput = SwapResultHandler.FormatTokenAmount(
                result.Data.MinAmountOut!,
                result.Data.TokenTo!.Decimals),
            priceImpact = result.Data.PriceImpact,
            tx = result.Data.Tx
        });
    }
    catch (HttpRequestException ex)
    {
        return Results.StatusCode(502);
    }
    catch (JsonException)
    {
        return Results.StatusCode(500);
    }
});

app.Run();

Step 6: Add Retry Logic for Upstream Errors

The swap API may return UPSTREAM_ERROR (502) during transient routing failures or RATE_LIMITED (429) when exceeding approximately 30 requests per minute. Use Polly or the built-in Microsoft.Extensions.Http.Resilience package in .NET 8 for production-grade retry policies.

using Microsoft.Extensions.Http.Resilience;

builder.Services.AddHttpClient<SwapService>()
    .AddStandardResilienceHandler(options =>
    {
        options.Retry.MaxRetryAttempts = 3;
        options.Retry.Delay = TimeSpan.FromSeconds(2);
        options.AttemptTimeout.Timeout = TimeSpan.FromSeconds(15);
        options.TotalRequestTimeout.Timeout = TimeSpan.FromSeconds(45);
    });

This handles transient 502 errors with exponential backoff. For 429 rate limits, the built-in handler respects Retry-After headers automatically.

Step 7: Test with a Real Swap Quote

Call the Ethereum endpoint to swap 1 ETH to USDC. Use the native token address 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for ETH and the USDC contract 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48. The amount is 1 ETH in wei: 1000000000000000000 (18 decimals).

curl "http://localhost:5000/api/swap?chainId=1&tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&tokenOut=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&amount=1000000000000000000&sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045&maxSlippage=0.005"

For Arbitrum, use chain ID 42161 with the Arbitrum token addresses. WETH is 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1 and USDC is 0xaf88d065e77c8cC2239327C5EDb3A432268e5831.

Supported Chains Quick Reference

The API supports 46 EVM chains. Here are the most used networks with key token addresses:

Chain	ID	Native	USDC	USDT
Ethereum	1	ETH	`0xA0b8...eB48` (6 dec)	`0xdAC1...1ec7` (6 dec)
Arbitrum	42161	ETH	`0xaf88...5831` (6 dec)	`0xFd08...cbb9` (6 dec)
Base	8453	ETH	`0x8335...2913` (6 dec)	`0xfde4...d2b2` (6 dec)
Polygon	137	POL	`0x3c49...8359` (6 dec)	`0xc213...e8F` (6 dec)
BSC	56	BNB	`0x8AC7...580d` (18 dec)	`0x55d3...7955` (18 dec)
Optimism	10	ETH	`0x0b2C...Ff85` (6 dec)	`0x94b0...e58` (6 dec)

BSC decimal warning: USDC and USDT use 18 decimals on BSC, not 6. Passing 100000000 (6 decimals) when you mean 100 USDT on BSC gives you 0.0000000001 USDT. The correct amount for 100 USDT on BSC is 100000000000000000000 (18 decimals).

FAQ

What is a token swap API and how does it work with C#?

A token swap API is a REST endpoint that returns executable blockchain transaction data for exchanging one token for another through decentralized exchanges. In C#, you call the API with HttpClient, deserialize the JSON response into record types, and submit the returned tx object to the blockchain using a signing library like Nethereum.

Does the API require authentication or an SDK?

No. The swap API at api.swapapi.dev requires no API key, no account registration, and no proprietary SDK. You use standard HttpClient and System.Text.Json -- nothing beyond what ships with .NET 8.

How do I handle token decimal differences across chains?

Always check the decimals field in the API response for each token. The same stablecoin can have different decimals on different chains (USDT is 6 decimals on Ethereum but 18 on BSC). The expectedAmountOut is always in raw units, so divide by 10^decimals to get the human-readable value.

What is the rate limit for the swap API?

The API allows approximately 30 requests per minute per IP address. If you exceed this, the API returns a 429 status with a RATE_LIMITED error code. Use the retry pattern from Step 6 with exponential backoff.

Can I use this token swap API in C# for multiple chains?

Yes. Pass any supported chainId as a path parameter. The API supports 46 EVM chains including Ethereum, Arbitrum, Base, Polygon, BSC, and Optimism. The response format is identical across all chains.

Get Started

swapapi.dev provides a free token swap API with no API key, no account, and 46 supported EVM chains. Browse the OpenAPI spec for the full schema, or hit the Swagger UI to test requests in the browser. The complete endpoint reference, token addresses, and integration guides are at swapapi.dev/llms.txt.

How to Build a MEV-Protected Swap Service in TypeScript

Moon Soon — Thu, 09 Apr 2026 21:30:03 +0000

Sandwich bots extracted $289 million from Ethereum swaps in 2025 alone, accounting for over 51% of all MEV activity on the network (ScienceDirect, 2025). Every unprotected swap is a potential victim. If you are building a swap service, wallet, or trading bot, MEV protection is not optional.

This guide walks you through building a MEV-protected token swap service in TypeScript. You will learn what MEV is, how sandwich attacks work, and how to use pre-trade validation, slippage enforcement, and private transaction submission to protect every swap.

What You Will Need

Node.js 18+ or Bun runtime
TypeScript configured in your project
A wallet library: viem or ethers.js v6
Access to a swap API (we will use swapapi.dev -- free, no API key, 46 chains)
A private RPC endpoint (Flashbots Protect, MEV Blocker, or similar)

Step 1: Understand MEV and Why Your Swaps Are Vulnerable

Maximal Extractable Value (MEV) is the profit that block producers and searchers can extract by reordering, inserting, or censoring transactions within a block. The most common MEV attack targeting swaps is the sandwich attack.

How a Sandwich Attack Works

You submit a swap transaction to the public mempool (buy ETH with USDC).
A bot sees your pending transaction and front-runs you -- it buys ETH first, pushing the price up.
Your swap executes at the inflated price.
The bot back-runs you -- it sells the ETH it just bought, pocketing the difference.

The result: you receive fewer tokens than you should have. The bot profits at your expense.

Sandwich attacks average more than one per block on Ethereum (arxiv.org, 2025). Across all chains, private routing adoption grew from 31.8% to over 50% of transactions between November 2024 and February 2025 as users sought protection (arxiv.org, 2024).

Step 2: Get a Protected Swap Quote with Price Impact Data

The first layer of MEV protection happens before you ever submit a transaction. You need to check the price impact and enforce slippage bounds on every quote.

swapapi.dev returns both priceImpact and minAmountOut in every response, giving you the data you need to reject bad trades programmatically.

interface SwapQuote {
  success: boolean;
  data: {
    status: "Successful" | "Partial" | "NoRoute";
    priceImpact: number;
    expectedAmountOut: string;
    minAmountOut: string;
    amountIn: string;
    tokenFrom: { symbol: string; decimals: number };
    tokenTo: { symbol: string; decimals: number };
    tx: {
      from: string;
      to: string;
      data: string;
      value: string;
      gasPrice: number;
    };
    rpcUrls: string[];
  };
  timestamp: string;
}

async function getSwapQuote(
  chainId: number,
  tokenIn: string,
  tokenOut: string,
  amount: string,
  sender: string,
  maxSlippage: number = 0.005
): Promise<SwapQuote> {
  const url = new URL(
    `https://api.swapapi.dev/v1/swap/${chainId}`
  );
  url.searchParams.set("tokenIn", tokenIn);
  url.searchParams.set("tokenOut", tokenOut);
  url.searchParams.set("amount", amount);
  url.searchParams.set("sender", sender);
  url.searchParams.set("maxSlippage", maxSlippage.toString());

  const response = await fetch(url.toString(), {
    signal: AbortSignal.timeout(15_000),
  });

  return response.json() as Promise<SwapQuote>;
}

The maxSlippage parameter (0 to 1) controls the on-chain minimum. With 0.005 (0.5%), the transaction reverts if the output drops more than 0.5% below expectedAmountOut. This is your on-chain safety net against sandwich attacks.

Step 3: Validate Price Impact Before Execution

Price impact tells you how much your trade moves the market. A swap with -0.12% price impact is normal. A swap with -8% price impact is either hitting a low-liquidity pool or being set up for extraction.

Flashbots Protect has shielded $43 billion in DEX volume across 2.1 million unique accounts (Flashbots, 2025). But even with private submission, a high-impact trade on a thin pool still loses value. Pre-trade validation catches what private mempools cannot.

const MAX_ACCEPTABLE_IMPACT = -0.05; // -5%
const WARNING_IMPACT = -0.02;        // -2%

function validatePriceImpact(
  quote: SwapQuote
): { safe: boolean; warning: string | null } {
  const impact = quote.data.priceImpact;

  if (impact < MAX_ACCEPTABLE_IMPACT) {
    return {
      safe: false,
      warning:
        `Price impact ${(impact * 100).toFixed(2)}% exceeds ` +
        `safety threshold. Trade rejected.`,
    };
  }

  if (impact < WARNING_IMPACT) {
    return {
      safe: true,
      warning:
        `Price impact ${(impact * 100).toFixed(2)}% is elevated. ` +
        `Consider reducing trade size.`,
    };
  }

  return { safe: true, warning: null };
}

Price Impact	Risk Level	Action
> -0.5%	Low	Execute normally
-0.5% to -2%	Medium	Proceed with monitoring
-2% to -5%	High	Warn user, suggest splitting
< -5%	Critical	Block execution

Step 4: Detect Partial Fills and Liquidity Issues

The API returns a Partial status when only part of your requested amount can be filled. This is a liquidity signal. Large swaps hitting thin pools are prime sandwich targets because the price displacement is larger.

function checkPartialFill(
  quote: SwapQuote,
  requestedAmount: string
): { isPartial: boolean; fillPercentage: number } {
  if (quote.data.status === "Partial") {
    const requested = BigInt(requestedAmount);
    const filled = BigInt(quote.data.amountIn);
    const pct = Number((filled * 100n) / requested);

    return { isPartial: true, fillPercentage: pct };
  }

  return { isPartial: false, fillPercentage: 100 };
}

When you detect a partial fill, you have three options: execute the partial amount as-is, reduce your trade to match available liquidity, or split the trade across multiple smaller swaps to reduce price impact per execution.

Step 5: Submit Transactions Through a Private RPC

The public mempool is where sandwich bots find their victims. The single most effective MEV protection is to bypass it entirely. Private transaction pools send your transaction directly to block builders, making it invisible to searchers.

Today, 80% of Ethereum transactions use private RPCs (arxiv.org, 2025). The major options are:

Provider	Success Rate	Response Time	Cost
Flashbots Protect	98.5%	245ms	Free
MEV Blocker	96.2%	180ms	Free
Private builder endpoints	Varies	Varies	Paid

Here is how to submit a swap transaction through Flashbots Protect using viem:

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

const FLASHBOTS_RPC = "https://rpc.flashbots.net";

const account = privateKeyToAccount(
  process.env.PRIVATE_KEY as `0x${string}`
);

const walletClient = createWalletClient({
  account,
  chain: mainnet,
  transport: http(FLASHBOTS_RPC),
});

async function submitProtectedSwap(
  quote: SwapQuote
): Promise<string> {
  const { tx } = quote.data;

  const hash = await walletClient.sendTransaction({
    to: tx.to as `0x${string}`,
    data: tx.data as `0x${string}`,
    value: BigInt(tx.value),
  });

  return hash;
}

By pointing your wallet client at https://rpc.flashbots.net instead of a public RPC, every transaction you send goes through Flashbots' private channel. No mempool exposure. No sandwich opportunity.

Step 6: Add Gas Estimation and Simulation

Before submitting, simulate the transaction with eth_call and estimate gas. This catches reverts before they cost you gas fees. The API does not include a gasLimit field -- you must estimate it yourself.

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

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

async function simulateAndEstimate(
  quote: SwapQuote
): Promise<{ gasLimit: bigint; simulationPassed: boolean }> {
  const { tx } = quote.data;
  const txParams = {
    account: tx.from as `0x${string}`,
    to: tx.to as `0x${string}`,
    data: tx.data as `0x${string}`,
    value: BigInt(tx.value),
  };

  try {
    await publicClient.call(txParams);
  } catch {
    return { gasLimit: 0n, simulationPassed: false };
  }

  try {
    const gasEstimate =
      await publicClient.estimateGas(txParams);
    const gasWithBuffer =
      (gasEstimate * 120n) / 100n; // 20% buffer
    return {
      gasLimit: gasWithBuffer,
      simulationPassed: true,
    };
  } catch {
    return { gasLimit: 0n, simulationPassed: false };
  }
}

The 20% gas buffer is important. Multi-hop swap routes can have variable gas consumption, and running out of gas means you pay fees but the swap reverts.

Step 7: Assemble the Full Protected Swap Pipeline

Now combine every layer into a single execution pipeline. This is the complete flow: quote, validate, simulate, submit.

const NATIVE_TOKEN =
  "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
const USDC_ETHEREUM =
  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";

async function executeProtectedSwap(
  chainId: number,
  tokenIn: string,
  tokenOut: string,
  amount: string,
  sender: string
): Promise<{
  success: boolean;
  txHash?: string;
  error?: string;
}> {
  // 1. Get quote with tight slippage
  const quote = await getSwapQuote(
    chainId,
    tokenIn,
    tokenOut,
    amount,
    sender,
    0.005
  );

  if (!quote.success) {
    return {
      success: false,
      error: "Failed to get quote",
    };
  }

  if (quote.data.status === "NoRoute") {
    return {
      success: false,
      error: "No route found for this pair",
    };
  }

  // 2. Check price impact
  const impactCheck = validatePriceImpact(quote);
  if (!impactCheck.safe) {
    return {
      success: false,
      error: impactCheck.warning ?? "Price impact too high",
    };
  }

  // 3. Check for partial fills
  const fillCheck = checkPartialFill(quote, amount);
  if (fillCheck.isPartial && fillCheck.fillPercentage < 80) {
    return {
      success: false,
      error:
        `Only ${fillCheck.fillPercentage}% of trade ` +
        `can be filled. Insufficient liquidity.`,
    };
  }

  // 4. Simulate and estimate gas
  const sim = await simulateAndEstimate(quote);
  if (!sim.simulationPassed) {
    return {
      success: false,
      error: "Transaction simulation failed",
    };
  }

  // 5. Submit through private RPC
  const txHash = await submitProtectedSwap(quote);

  return { success: true, txHash };
}

// Example: swap 1 ETH to USDC on Ethereum
executeProtectedSwap(
  1,
  NATIVE_TOKEN,
  USDC_ETHEREUM,
  "1000000000000000000",
  "0xYourWalletAddress"
).then(console.log);

MEV Protection Strategy Comparison

Not all protection strategies are equal. Here is how they stack up:

Strategy	Protects Against	Limitations	Complexity
Tight slippage tolerance	Sandwich attacks	May cause reverts in volatile markets	Low
Price impact checks	Large-trade extraction	Does not prevent frontrunning	Low
Private RPC (Flashbots)	Mempool-based MEV	Only works on supported chains	Medium
Trade splitting	Price impact manipulation	Increases gas costs and latency	Medium
Simulation (eth_call)	Failed transactions	Does not prevent MEV, only reverts	Low
All combined	Full coverage	Requires careful tuning	Medium

The recommended approach is to layer all of these defenses. No single technique is sufficient. Tight slippage prevents the worst sandwich outcomes, price impact checks reject toxic trades, private RPCs hide transactions from searchers, and simulation prevents wasted gas.

Multi-Chain Considerations

MEV exists on every EVM chain, not just Ethereum. Arbitrum and Base have sequencer-ordered transactions that reduce but do not eliminate MEV. BSC and Polygon have active sandwich bots.

The swap API used in this guide supports 46 chains. The same quote-validate-simulate-submit pipeline works across all of them. Adjust the private RPC endpoint per chain:

Ethereum (chainId 1): Flashbots Protect (https://rpc.flashbots.net)
Arbitrum (chainId 42161): Sequencer provides some ordering guarantees. Use the API-provided rpcUrls as fallbacks.
BSC (chainId 56): bloXroute or 48 Club private RPCs available. Watch for the 18-decimal stablecoin gotcha -- USDC and USDT use 18 decimals on BSC, not 6.
Polygon (chainId 137): Fastlane or Marlin private RPCs.

FAQ

What is MEV protection for swaps and why does it matter?

MEV protection prevents block producers and searchers from profiting at your expense during token swaps. Without it, sandwich bots can front-run and back-run your transactions, costing you 0.1% to 5%+ per trade. In 2025, sandwich attacks alone extracted $289 million on Ethereum.

How does slippage tolerance protect against sandwich attacks?

Slippage tolerance sets a minimum output amount for your swap. If a sandwich bot pushes the price far enough that your output drops below minAmountOut, the transaction reverts instead of executing at a bad price. Setting maxSlippage to 0.005 (0.5%) is a good default; tighter for stablecoins, looser for volatile pairs.

Can MEV attacks happen on Layer 2 chains like Arbitrum and Base?

Yes, though the attack surface is different. L2 sequencers control transaction ordering, which reduces public mempool exposure. However, sequencer operators or privileged parties can still extract MEV. Private RPCs are less critical on L2s, but price impact checks and slippage enforcement remain essential.

Is a private RPC enough to fully prevent MEV?

No. Research shows that even private routing channels are not immune -- 2,932 private sandwich attacks were confirmed in late 2024, producing $409,236 in losses (arxiv.org, 2024). You need layered protection: slippage bounds, price impact validation, simulation, and private submission together.

Get Started

swapapi.dev gives you the quote data you need to build MEV-protected swap services: priceImpact, expectedAmountOut, minAmountOut, and ready-to-execute tx calldata with built-in slippage enforcement.

Free -- no API key, no registration, no rate limit surprises
46 chains -- Ethereum, Arbitrum, Base, BSC, Polygon, and 41 more
OpenAPI spec -- generate typed clients in any language
API docs -- interactive Swagger UI

Start building: https://api.swapapi.dev

How to Integrate Token Swaps in a Flutter App

Moon Soon — Thu, 09 Apr 2026 21:29:47 +0000

Flutter now powers apps used by over 500 million people worldwide, with 2.8 million monthly active developers building across mobile, web, and desktop (GoodFirms, 2025). At the same time, the DeFi market is projected to reach $256.4 billion by 2030, growing at a 43.3% CAGR (CoinLaw, 2025). That intersection creates a clear opportunity: adding token swap functionality to Flutter apps.

This guide walks through integrating swapapi.dev into a Flutter application. The API is free, requires no API keys, and supports 46 EVM chains. By the end, you will have a working swap feature that fetches quotes, displays pricing, and submits transactions.

What You'll Need

Flutter 3.22+ with Dart 3.4+
The http package for API calls
The provider package for state management
A wallet integration library (e.g., web3dart) for transaction signing
Basic understanding of ERC-20 tokens and blockchain transactions

Install the dependencies:

dependencies:
  http: ^1.2.0
  provider: ^6.1.0
  web3dart: ^2.7.0
  json_annotation: ^4.9.0

Step 1: Define Response Models

The API returns a consistent envelope format: { success, data, error, timestamp }. Model this in Dart so every response is type-safe.

Start with the token model:

class SwapToken {
  final String address;
  final String symbol;
  final String name;
  final int decimals;

  SwapToken({
    required this.address,
    required this.symbol,
    required this.name,
    required this.decimals,
  });

  factory SwapToken.fromJson(Map<String, dynamic> json) {
    return SwapToken(
      address: json["address"] as String,
      symbol: json["symbol"] as String,
      name: json["name"] as String,
      decimals: json["decimals"] as int,
    );
  }
}

Next, model the transaction object returned by the API:

class SwapTransaction {
  final String from;
  final String to;
  final String data;
  final String value;
  final int gasPrice;

  SwapTransaction({
    required this.from,
    required this.to,
    required this.data,
    required this.value,
    required this.gasPrice,
  });

  factory SwapTransaction.fromJson(Map<String, dynamic> json) {
    return SwapTransaction(
      from: json["from"] as String,
      to: json["to"] as String,
      data: json["data"] as String,
      value: json["value"] as String,
      gasPrice: json["gasPrice"] as int,
    );
  }
}

Now the main swap result. The status field distinguishes between Successful, Partial, and NoRoute responses, all returned with HTTP 200:

class SwapResult {
  final String status;
  final SwapToken? tokenFrom;
  final SwapToken? tokenTo;
  final double? swapPrice;
  final double? priceImpact;
  final String? amountIn;
  final String? expectedAmountOut;
  final String? minAmountOut;
  final SwapTransaction? tx;

  SwapResult({
    required this.status,
    this.tokenFrom,
    this.tokenTo,
    this.swapPrice,
    this.priceImpact,
    this.amountIn,
    this.expectedAmountOut,
    this.minAmountOut,
    this.tx,
  });

  factory SwapResult.fromJson(Map<String, dynamic> json) {
    return SwapResult(
      status: json["status"] as String,
      tokenFrom: json["tokenFrom"] != null
          ? SwapToken.fromJson(json["tokenFrom"])
          : null,
      tokenTo: json["tokenTo"] != null
          ? SwapToken.fromJson(json["tokenTo"])
          : null,
      swapPrice: (json["swapPrice"] as num?)?.toDouble(),
      priceImpact: (json["priceImpact"] as num?)?.toDouble(),
      amountIn: json["amountIn"] as String?,
      expectedAmountOut: json["expectedAmountOut"] as String?,
      minAmountOut: json["minAmountOut"] as String?,
      tx: json["tx"] != null
          ? SwapTransaction.fromJson(json["tx"])
          : null,
    );
  }
}

Flutter holds 46% of the cross-platform framework market share compared to React Native's 35% (Statista, 2025). That means nearly half of all cross-platform developers can use this approach directly.

Step 2: Build the Swap Service

Create a service class that handles API communication. The API base URL is https://api.swapapi.dev and the swap endpoint follows the pattern /v1/swap/{chainId}.

import "dart:convert";
import "package:http/http.dart" as http;

class SwapService {
  static const _baseUrl = "https://api.swapapi.dev";
  final http.Client _client;

  SwapService({http.Client? client})
      : _client = client ?? http.Client();

Add the method that fetches a swap quote. The API recommends a 15-second timeout since response times range from 1 to 5 seconds:

  Future<SwapResult> getSwapQuote({
    required int chainId,
    required String tokenIn,
    required String tokenOut,
    required String amount,
    required String sender,
    double maxSlippage = 0.005,
  }) async {
    final uri = Uri.parse(
      "$_baseUrl/v1/swap/$chainId"
      "?tokenIn=$tokenIn"
      "&tokenOut=$tokenOut"
      "&amount=$amount"
      "&sender=$sender"
      "&maxSlippage=$maxSlippage",
    );

    final response = await _client
        .get(uri)
        .timeout(const Duration(seconds: 15));

    final body = jsonDecode(response.body)
        as Map<String, dynamic>;

    if (body["success"] != true) {
      final error = body["error"] as Map<String, dynamic>;
      throw SwapApiException(
        code: error["code"] as String,
        message: error["message"] as String,
      );
    }

    return SwapResult.fromJson(
      body["data"] as Map<String, dynamic>,
    );
  }

  void dispose() => _client.close();
}

Define a custom exception for API errors:

class SwapApiException implements Exception {
  final String code;
  final String message;

  SwapApiException({
    required this.code,
    required this.message,
  });

  @override
  String toString() => "SwapApiException: $code - $message";
}

The API supports 46 chains including Ethereum, Polygon, Base, Arbitrum, BSC, Optimism, and Avalanche. Financial services adoption of Flutter grew 217% since 2021 (Crustlab, 2026), making it the fastest-growing sector for the framework.

Step 3: Handle Token Amounts Correctly

Token decimals vary across chains and tokens. ETH uses 18 decimals, USDC uses 6 on most chains, but USDC on BSC uses 18. Getting this wrong produces incorrect swap amounts.

Build a utility for BigInt conversion:

BigInt toSmallestUnit(double amount, int decimals) {
  final factor = BigInt.from(10).pow(decimals);
  final scaled = (amount * 1e8).round();
  return BigInt.from(scaled) * factor ~/ BigInt.from(1e8.round());
}

Convert the output amount back to a human-readable value:

double fromSmallestUnit(String raw, int decimals) {
  final value = BigInt.parse(raw);
  final factor = BigInt.from(10).pow(decimals);
  return value / factor;
}

Define chain constants with the correct token addresses:

class ChainTokens {
  static const ethereum = 1;
  static const polygon = 137;
  static const base = 8453;

  static const nativeToken =
      "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";

  static const ethUsdc =
      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";

  static const polygonUsdc =
      "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359";

  static const baseUsdc =
      "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
}

The global mobile wallet market is valued at $12.85 billion in 2025 and projected to reach $104.69 billion by 2034 (Precedence Research, 2025). Accurate decimal handling prevents costly miscalculations in that growing market.

Step 4: Create the State Management Layer

Use ChangeNotifier with Provider to manage swap state. This keeps the UI reactive and separates business logic from presentation.

import "package:flutter/foundation.dart";

enum SwapState { idle, loading, success, error }

Build the view model:

class SwapViewModel extends ChangeNotifier {
  final SwapService _service;

  SwapState _state = SwapState.idle;
  SwapResult? _result;
  String? _errorMessage;

  SwapViewModel(this._service);

  SwapState get state => _state;
  SwapResult? get result => _result;
  String? get errorMessage => _errorMessage;

Add the method that triggers a swap quote. It validates the response status and handles partial fills:

  Future<void> fetchQuote({
    required int chainId,
    required String tokenIn,
    required String tokenOut,
    required double amount,
    required int decimals,
    required String sender,
  }) async {
    _state = SwapState.loading;
    _errorMessage = null;
    notifyListeners();

    try {
      final rawAmount = toSmallestUnit(amount, decimals);

      _result = await _service.getSwapQuote(
        chainId: chainId,
        tokenIn: tokenIn,
        tokenOut: tokenOut,
        amount: rawAmount.toString(),
        sender: sender,
      );

      if (_result!.status == "NoRoute") {
        _state = SwapState.error;
        _errorMessage = "No swap route found";
      } else {
        _state = SwapState.success;
      }
    } on SwapApiException catch (e) {
      _state = SwapState.error;
      _errorMessage = e.message;
    } catch (e) {
      _state = SwapState.error;
      _errorMessage = "Connection error";
    }

    notifyListeners();
  }
}

Over 26,800 companies worldwide use Flutter in production (ScaleUpAlly, 2025). Provider is the recommended state management approach from the Flutter team, making this pattern portable across those codebases.

Step 5: Build the Swap UI

Create a swap screen that lets users select tokens, enter amounts, and view quotes. The UI reacts to state changes from the view model.

class SwapScreen extends StatelessWidget {
  const SwapScreen({super.key});

  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider(
      create: (_) => SwapViewModel(SwapService()),
      child: const _SwapForm(),
    );
  }
}

Build the form widget with amount input and a swap button:

class _SwapForm extends StatefulWidget {
  const _SwapForm();

  @override
  State<_SwapForm> createState() => _SwapFormState();
}

class _SwapFormState extends State<_SwapForm> {
  final _amountController = TextEditingController();

  @override
  Widget build(BuildContext context) {
    final vm = context.watch<SwapViewModel>();

    return Padding(
      padding: const EdgeInsets.all(16),
      child: Column(
        children: [
          TextField(
            controller: _amountController,
            keyboardType: TextInputType.number,
            decoration: const InputDecoration(
              labelText: "Amount (ETH)",
            ),
          ),
          const SizedBox(height: 16),
          _buildSwapButton(vm),
          const SizedBox(height: 16),
          _buildResult(vm),
        ],
      ),
    );
  }

Add the swap button that triggers the quote:

  Widget _buildSwapButton(SwapViewModel vm) {
    return ElevatedButton(
      onPressed: vm.state == SwapState.loading
          ? null
          : () => _onSwap(vm),
      child: vm.state == SwapState.loading
          ? const CircularProgressIndicator()
          : const Text("Get Swap Quote"),
    );
  }

  void _onSwap(SwapViewModel vm) {
    final amount = double.tryParse(
      _amountController.text,
    );
    if (amount == null || amount <= 0) return;

    vm.fetchQuote(
      chainId: ChainTokens.ethereum,
      tokenIn: ChainTokens.nativeToken,
      tokenOut: ChainTokens.ethUsdc,
      amount: amount,
      decimals: 18,
      sender: "YOUR_WALLET_ADDRESS",
    );
  }

Display the quote result, including price impact as a safety check:

  Widget _buildResult(SwapViewModel vm) {
    if (vm.state == SwapState.error) {
      return Text(
        vm.errorMessage ?? "Unknown error",
        style: const TextStyle(color: Colors.red),
      );
    }

    if (vm.result == null) return const SizedBox();

    final out = fromSmallestUnit(
      vm.result!.expectedAmountOut!,
      vm.result!.tokenTo!.decimals,
    );

    final impact = vm.result!.priceImpact ?? 0;

    return Card(
      child: Padding(
        padding: const EdgeInsets.all(12),
        child: Column(
          children: [
            Text("You receive: ${out.toStringAsFixed(2)} USDC"),
            Text("Price impact: ${(impact * 100).toStringAsFixed(2)}%"),
            if (vm.result!.status == "Partial")
              const Text("Partial fill only"),
          ],
        ),
      ),
    );
  }
}

Step 6: Add Multi-Chain Support

The API uses a path parameter for chain selection, so supporting multiple chains requires only a chain ID and the correct token addresses. Here are the main networks:

Chain	ID	Native Token	USDC Address
Ethereum	1	ETH	`0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48`
Polygon	137	POL	`0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359`
Base	8453	ETH	`0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`
Arbitrum	42161	ETH	`0xaf88d065e77c8cC2239327C5EDb3A432268e5831`
BSC	56	BNB	`0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d`

Add a chain selector to the UI:

final chains = [
  {"name": "Ethereum", "id": 1},
  {"name": "Polygon", "id": 137},
  {"name": "Base", "id": 8453},
  {"name": "Arbitrum", "id": 42161},
  {"name": "BSC", "id": 56},
];

Flutter's ability to share a single codebase across iOS, Android, web, and desktop means this multi-chain swap feature deploys everywhere from one Dart implementation. With 68% of Flutter developers targeting multiple platforms (GoodFirms, 2025), that reach matters.

Step 7: Handle Errors and Edge Cases

The API returns four error codes you need to handle: INVALID_PARAMS (400), UNSUPPORTED_CHAIN (400), RATE_LIMITED (429), and UPSTREAM_ERROR (502). Add retry logic for transient errors:

Future<SwapResult> getSwapWithRetry({
  required int chainId,
  required String tokenIn,
  required String tokenOut,
  required String amount,
  required String sender,
  int maxRetries = 3,
}) async {
  for (var i = 0; i < maxRetries; i++) {
    try {
      return await getSwapQuote(
        chainId: chainId,
        tokenIn: tokenIn,
        tokenOut: tokenOut,
        amount: amount,
        sender: sender,
      );
    } on SwapApiException catch (e) {
      if (e.code == "RATE_LIMITED") {
        await Future.delayed(
          Duration(seconds: (i + 1) * 5),
        );
        continue;
      }
      if (e.code == "UPSTREAM_ERROR" && i < maxRetries - 1) {
        await Future.delayed(
          Duration(seconds: (i + 1) * 2),
        );
        continue;
      }
      rethrow;
    }
  }
  throw SwapApiException(
    code: "MAX_RETRIES",
    message: "Failed after $maxRetries attempts",
  );
}

Always check priceImpact before letting users execute. Reject swaps with impact worse than -5%:

bool isSafeToExecute(SwapResult result) {
  if (result.status != "Successful") return false;
  if (result.priceImpact != null && result.priceImpact! < -0.05) {
    return false;
  }
  return true;
}

Flutter vs React Native for Crypto Apps

Choosing the right framework for a DeFi app involves performance, ecosystem, and developer availability tradeoffs:

Factor	Flutter	React Native
Market share	46%	35%
Language	Dart	JavaScript
Rendering	Own engine (Skia)	Native components
Web3 libraries	web3dart, walletconnect	ethers.js, wagmi
Hot reload	Sub-second	Sub-second
Desktop support	Stable	Community-driven
GitHub stars	170k+	121k+
Job postings (US)	~1,000	~6,400

Flutter's custom rendering engine provides pixel-perfect control over swap UIs across platforms, which matters when displaying precise token amounts and price charts. React Native has a larger JavaScript ecosystem for Web3, but Flutter's Dart-native approach avoids the JavaScript bridge overhead that can impact transaction-heavy apps.

With Flutter seeing 47% year-over-year growth (Black Kite Technologies, 2026), the Dart Web3 ecosystem is expanding rapidly. For teams building new crypto apps, Flutter offers a strong foundation.

FAQ

Is token swap in Flutter secure for production use?

Yes. The API returns raw transaction calldata that gets signed locally in the user's wallet. Private keys never leave the device. Combine this with web3dart for local signing, and the security model matches native wallet apps.

How many chains does the token swap API support?

The API supports 46 EVM-compatible chains including Ethereum, Polygon, Base, Arbitrum, BSC, Optimism, Avalanche, and newer networks like Monad, Berachain, and MegaETH. Every chain uses the same endpoint pattern with only the chain ID changing.

Do I need an API key to integrate token swap in Flutter?

No. The API is free with no API keys, no authentication, and no account registration required. Rate limiting is approximately 30 requests per minute per IP, which is sufficient for most consumer wallet apps.

How do I handle partial fills in a Flutter swap app?

Check data.status in the response. If it returns Partial, the amountIn and expectedAmountOut reflect the partial fill amount, not your original request. Display the actual fill amount to the user and let them decide whether to execute, adjust their amount, or try a different pair.

What token decimals should I use for BSC swaps in Flutter?

USDC and USDT on BSC use 18 decimals, not the 6 decimals used on Ethereum and most other chains. Always reference the API response's tokenTo.decimals field rather than hardcoding values to avoid miscalculating amounts.

Get Started

swapapi.dev provides free token swap quotes and executable calldata across 46 EVM chains. No API keys, no registration.

API Base URL: https://api.swapapi.dev
OpenAPI Spec: api.swapapi.dev/openapi.json
Interactive Docs: api.swapapi.dev/docs
Full Documentation: swapapi.dev/llms.txt

Add the http package to your Flutter project, copy the SwapService class from this guide, and start fetching quotes. The API returns everything you need to build a complete swap experience in under an hour.

7 Best DeFi APIs for Real-Time Price Feeds

Moon Soon — Thu, 09 Apr 2026 08:24:24 +0000

The DeFi market hit $238.54 billion in 2026 and is projected to reach $770 billion by 2031 at a 26.43% CAGR. Every trading bot, portfolio tracker, and liquidation engine depends on accurate price data — and choosing the wrong DeFi API price feed can mean stale quotes, missed trades, or incorrect valuations. On-chain oracles now secure over $93 billion in value, while off-chain APIs serve millions of requests per day for dashboards and analytics. This guide compares the 7 best DeFi APIs for real-time price feeds in 2026 — covering on-chain oracles, aggregated market data, and DEX-based execution pricing.

1. Chainlink Price Feeds

Chainlink commands a 63% share of the oracle market and secures over $93 billion in on-chain value across 1,000+ protocol integrations. Its decentralized oracle network aggregates prices from multiple premium data providers and delivers them on-chain through a network of independent node operators.

Chainlink Price Feeds support 20+ blockchains including Ethereum, Arbitrum, Base, Polygon, BSC, and Avalanche. Each feed updates based on a deviation threshold (typically 0.5-1%) or a heartbeat interval (usually 1 hour), whichever triggers first. You read prices directly from on-chain contracts using latestRoundData().

(, int256 price,,,) = AggregatorV3Interface(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419).latestRoundData();

The trade-off: Chainlink is the gold standard for smart contract integrations, but it is not a REST API. You need an RPC connection to read feeds, and update frequency depends on the deviation threshold — not real-time streaming. For off-chain applications that need sub-second HTTP responses, you will need a different approach.

Best for: Smart contracts that need decentralized, tamper-proof price data on-chain — lending protocols, derivatives, and liquidation engines.

2. Pyth Network

Pyth delivers sub-second price updates by sourcing data directly from institutional market participants — trading firms, exchanges, and market makers. Every Pyth price feed updates every 400 milliseconds, and its new Lazer product pushes that down to 1 millisecond latency for latency-sensitive applications.

Pyth covers over 2,800 price feeds spanning crypto, equities, forex, and commodities across 40+ blockchain ecosystems. Unlike Chainlink's push model, Pyth uses a pull-based design — consumers request the latest price on demand, which reduces on-chain costs. Each update includes a confidence interval alongside the price, giving applications a built-in data quality signal.

curl "https://hermes.pyth.network/v2/updates/price/latest?ids[]=0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace"

Pyth's 99.9% uptime record and first-party data sourcing make it a strong alternative to Chainlink, especially on newer chains where Chainlink coverage is still limited.

Best for: High-frequency DeFi applications that need sub-second price updates with confidence intervals — perps, options, and real-time risk engines.

3. Swap API (swapapi.dev) — DEX Execution Pricing

Most price feed APIs return indicative market data. Swap API returns executable pricing — the actual amount you would receive from a DEX swap right now, across 46 EVM chains. This makes it uniquely useful as a DeFi API price feed that reflects real liquidity conditions, not aggregated exchange averages.

A single GET request returns expectedAmountOut, priceImpact, swapPrice, and complete transaction calldata. No API key, no registration, no authentication required. Query any token pair on Ethereum, Arbitrum, Base, Polygon, BSC, Optimism, and 40 other networks from one endpoint.

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

The response includes swapPrice (the raw exchange rate), priceImpact (as a decimal — -0.0012 means -0.12%), and minAmountOut with slippage protection already encoded. Three status values — Successful, Partial, and NoRoute — all return HTTP 200, so you check data.status instead of parsing error codes. The OpenAPI spec ships with every deployment for typed client generation.

Best for: Trading bots, arbitrage scanners, and DeFi dashboards that need execution-accurate pricing across 46 chains — especially when you also need the swap calldata to act on the price.

4. CoinGecko API

CoinGecko tracks over 15,000 cryptocurrencies across 1,100+ exchanges, making it the most comprehensive aggregated price data source available. The free Demo tier provides 30 calls per minute with a 10,000 monthly cap — enough for dashboards and portfolio trackers, but tight for production trading systems.

The /simple/price endpoint returns current USD prices for any coin by ID. For on-chain token lookups, /simple/token_price/{platform} accepts contract addresses directly — useful for DeFi applications that work with token addresses rather than ticker symbols. Historical OHLC, market cap, and volume data are available through additional endpoints.

curl "https://api.coingecko.com/api/v3/simple/price?ids=ethereum,bitcoin&vs_currencies=usd"

Paid plans start at $129/month and bump the rate limit to 500 calls per minute. CoinGecko prices reflect centralized exchange aggregates, not DEX liquidity — so the quoted price may differ from what you would actually receive in a swap. For DeFi-native applications, pair CoinGecko with a DEX-based pricing API.

Best for: Portfolio trackers, analytics dashboards, and applications that need broad market coverage with historical data across thousands of tokens.

5. DeFiLlama API

DeFiLlama provides free, open API access to TVL, protocol, yield, and price data across the entire DeFi ecosystem. No API key required for the core endpoints. Over 82% of DeFi protocols now offer real-time or near-instant data updates, and DeFiLlama aggregates this data into a single queryable interface.

The /coins/prices/current/{coins} endpoint accepts chain-specific token addresses in the format chain:address, returning current USD prices. This is particularly useful for DeFi applications that need to price LP tokens, yield-bearing assets, or obscure tokens that CoinGecko may not list.

curl "https://coins.llama.fi/prices/current/ethereum:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"

DeFiLlama is community-maintained and fully open source. The trade-off is that price data updates are not real-time — there is a delay compared to exchange-sourced feeds. A Pro API plan exists for higher rate limits and additional endpoints, but the free tier covers most use cases.

Best for: DeFi-native analytics, TVL dashboards, and applications that need to price exotic tokens and yield positions without paying for an API key.

6. The Graph (Subgraphs)

The Graph is a decentralized indexing protocol that lets you query on-chain DEX data directly. Instead of relying on a centralized API, you deploy or query existing subgraphs that index Uniswap, Curve, Balancer, and other DEX contracts in real-time. Uniswap alone processed over $1 trillion in volume during 2025, and all of that trade data is queryable through subgraphs.

Subgraphs expose GraphQL endpoints where you can query pool reserves, swap events, and derived token prices. This gives you DEX-native pricing that reflects actual on-chain liquidity — similar to what Swap API provides, but requiring you to build your own price calculation logic.

{ token(id: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48") { derivedETH symbol } }

The trade-off: you need to understand GraphQL, handle subgraph indexing delays (typically 1-2 blocks), and manage your own query infrastructure or pay for The Graph's hosted service. It is powerful but not turnkey.

Best for: Developers building custom DeFi analytics who need granular on-chain trade data and are comfortable with GraphQL and subgraph infrastructure.

7. DIA (Decentralized Information Asset)

DIA is an open-source oracle platform that provides transparent, verifiable price feeds sourced from on-chain DEX trades and centralized exchanges. Unlike Chainlink, DIA publishes its full methodology and raw data sources — every price update is auditable back to the original trades.

DIA covers 20,000+ assets across 80+ blockchains and offers customizable feed parameters. You can configure update frequency, data sources, and aggregation methodology per feed. The REST API provides off-chain access without requiring an RPC connection.

curl "https://api.diadata.org/v1/assetQuotation/Ethereum/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"

DIA's transparency is its differentiator — every data point traces back to verifiable on-chain trades. The trade-off is smaller ecosystem adoption compared to Chainlink and Pyth, meaning fewer battle-tested integrations in production DeFi protocols.

Best for: Projects that require full data transparency and auditability — RWA platforms, regulated DeFi, and applications where proving price provenance matters.

Comparison Table

API	Type	Chains	Free Tier	Auth Required	Update Speed	Best Use Case
Chainlink	On-chain oracle	20+	Free (on-chain)	No (RPC only)	0.5-1% deviation / 1h heartbeat	Smart contract price feeds
Pyth Network	On-chain oracle	40+	Free (on-chain)	No	400ms (1ms with Lazer)	High-frequency DeFi
Swap API	DEX execution API	46	Free	No	Per-request	Execution pricing + swap
CoinGecko	Market data API	N/A (exchange)	30 req/min	API key (paid)	~60s	Portfolio tracking
DeFiLlama	DeFi data API	All EVM	Unlimited	No	Minutes	DeFi analytics
The Graph	Indexing protocol	40+	Free tier	API key	1-2 blocks	Custom on-chain analytics
DIA	Oracle + API	80+	Free	No	Configurable	Transparent/auditable feeds

FAQ

What is the best free DeFi API price feed for developers?

It depends on your use case. For on-chain smart contracts, Chainlink Price Feeds are the industry standard and free to read. For off-chain applications that need execution-accurate pricing without registration, Swap API provides real DEX quotes across 46 chains with no API key. DeFiLlama is the best free option for broad DeFi analytics and TVL data.

How do on-chain oracle price feeds differ from API-based price feeds?

On-chain oracles like Chainlink and Pyth deliver price data directly to smart contracts on the blockchain. They are decentralized and tamper-resistant but require an RPC connection to read. API-based feeds like CoinGecko and DeFiLlama serve data over HTTP — faster to integrate in off-chain applications but centralized. DEX execution APIs like Swap API bridge the gap by returning real on-chain liquidity data through a REST interface.

How accurate are DeFi API price feeds compared to centralized exchange prices?

Centralized exchange aggregators like CoinGecko reflect order book midpoints across major exchanges. DEX-based feeds reflect actual on-chain swap rates, which can differ due to liquidity depth and price impact. For trades under $10,000, the difference is typically under 0.1%. For larger trades, DEX execution APIs like Swap API provide more accurate pricing because they account for actual liquidity conditions and slippage.

Can I use a DeFi price feed API without an API key?

Yes. Chainlink and Pyth are free to read on-chain (you only need an RPC endpoint). Swap API and DeFiLlama both offer free REST API access with no API key or registration required. CoinGecko offers a limited free tier but requires a key for production-grade rate limits.

Get Started

Swap API provides execution-accurate pricing across 46 EVM chains through a single REST endpoint. No API key, no registration, no rate limit tiers to manage. Every response includes the real-time swap rate, price impact, slippage protection, and ready-to-execute transaction calldata.

Fetch a price quote in one line:

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

Explore the full OpenAPI spec, browse the Swagger docs, or read the integration guide.

How to Build a Crypto Payment Gateway with Swaps

Moon Soon — Thu, 09 Apr 2026 08:24:23 +0000

Crypto payments are no longer experimental. Stablecoin transaction volume hit $33 trillion in 2025 — a 72% increase over the prior year — and USDC alone accounted for $18.3 trillion of that volume. On the merchant side, 46% of surveyed merchants have already integrated cryptocurrency payment options, driven by faster settlement, lower fees, and cross-border reach. The crypto payment gateway market is projected to grow from $2 billion in 2025 to $2.39 billion in 2026, a 19% year-over-year increase.

The core problem: customers want to pay with whatever token they hold. Merchants want to receive stablecoins. A crypto payment gateway bridges that gap by accepting any token and auto-converting it to USDC or USDT at settlement.

This guide shows you how to build a non-custodial crypto payment gateway in TypeScript that accepts any ERC-20 token on any supported chain and auto-converts it to stablecoins using swapapi.dev — a free DEX aggregator API covering 46 EVM chains with no API key required.

What You'll Need

Node.js 18+ or Bun runtime
ethers.js v6 for wallet and transaction management
Express or Hono for the payment API server
A merchant wallet address to receive settlement funds
Native gas tokens on your target chain for swap execution
No API keys — swapapi.dev is free and keyless

Install the dependencies:

bun add ethers hono

Step 1: Define the Payment Configuration

Create a file called payment-gateway.ts. Start by defining the settlement tokens, supported chains, and merchant wallet address.

interface ChainConfig {
  chainId: number;
  settlementToken: string;
  settlementDecimals: number;
  nativeToken: string;
  rpcUrl: string;
}

const CHAINS: Record<number, ChainConfig> = {
  1: {
    chainId: 1,
    settlementToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    settlementDecimals: 6,
    nativeToken: "ETH",
    rpcUrl: "https://cloudflare-eth.com",
  },
  42161: {
    chainId: 42161,
    settlementToken: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
    settlementDecimals: 6,
    nativeToken: "ETH",
    rpcUrl: "https://arb1.arbitrum.io/rpc",
  },
  8453: {
    chainId: 8453,
    settlementToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    settlementDecimals: 6,
    nativeToken: "ETH",
    rpcUrl: "https://mainnet.base.org",
  },
  56: {
    chainId: 56,
    settlementToken: "0x55d398326f99059fF775485246999027B3197955",
    settlementDecimals: 18,
    nativeToken: "BNB",
    rpcUrl: "https://bsc-dataseed.binance.org",
  },
};

const MERCHANT_WALLET = "0xYourMerchantWalletAddress";
const NATIVE_TOKEN = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";

Each chain maps to a settlement stablecoin. On Ethereum, Arbitrum, and Base that is USDC (6 decimals). On BSC, USDT uses 18 decimals — a common gotcha that causes miscalculated amounts if you assume 6 decimals everywhere. Always use the decimals value from the chain config.

Step 2: Create the Payment Quote Function

The payment flow starts when a customer selects what token they want to pay with. The gateway fetches a swap quote to show them the exact conversion rate before they commit.

According to a PayPal survey, 88% of U.S. merchants have received customer inquiries about paying with crypto. This function handles the conversion quote for any incoming token:

interface PaymentQuote {
  orderId: string;
  chainId: number;
  tokenIn: string;
  tokenOut: string;
  amountIn: string;
  expectedSettlement: string;
  minSettlement: string;
  priceImpact: number;
  tx: {
    from: string;
    to: string;
    data: string;
    value: string;
  };
  expiresAt: number;
}

async function getPaymentQuote(
  chainId: number,
  tokenIn: string,
  amountIn: string,
  sender: string,
  orderId: string
): Promise<PaymentQuote> {
  const chain = CHAINS[chainId];
  if (!chain) {
    throw new Error(`Chain ${chainId} not supported`);
  }

  const url = new URL(`https://api.swapapi.dev/v1/swap/${chainId}`);
  url.searchParams.set("tokenIn", tokenIn);
  url.searchParams.set("tokenOut", chain.settlementToken);
  url.searchParams.set("amount", amountIn);
  url.searchParams.set("sender", sender);
  url.searchParams.set("maxSlippage", "0.005");

  const response = await fetch(url.toString(), {
    signal: AbortSignal.timeout(15000),
  });
  const result = await response.json();

  if (!result.success) {
    throw new Error(result.error?.message ?? "Quote failed");
  }

  if (result.data.status === "NoRoute") {
    throw new Error("No swap route available for this token pair");
  }

  if (result.data.priceImpact < -0.05) {
    throw new Error("Price impact too high — try a smaller amount");
  }

  return {
    orderId,
    chainId,
    tokenIn: result.data.tokenFrom.address,
    tokenOut: result.data.tokenTo.address,
    amountIn: result.data.amountIn,
    expectedSettlement: result.data.expectedAmountOut,
    minSettlement: result.data.minAmountOut,
    priceImpact: result.data.priceImpact,
    tx: {
      from: result.data.tx.from,
      to: result.data.tx.to,
      data: result.data.tx.data,
      value: result.data.tx.value,
    },
    expiresAt: Date.now() + 30000,
  };
}

The function calls swapapi.dev's single GET endpoint to get executable swap calldata. The 30-second expiry is critical — DEX calldata includes a deadline, and prices shift constantly. Always re-fetch if the quote is stale.

Step 3: Format Settlement Amounts for Display

Customers need to see human-readable settlement amounts before confirming. Raw amounts from the API are in the token's smallest unit — for USDC with 6 decimals, 2500000000 means 2,500.00 USDC.

function formatSettlement(
  rawAmount: string,
  decimals: number
): string {
  const value = BigInt(rawAmount);
  const divisor = BigInt(10 ** decimals);
  const whole = value / divisor;
  const fraction = value % divisor;
  const paddedFraction = fraction.toString().padStart(decimals, "0");
  const trimmed = paddedFraction.slice(0, 2);
  return `${whole}.${trimmed}`;
}

function isQuoteExpired(quote: PaymentQuote): boolean {
  return Date.now() > quote.expiresAt;
}

Step 4: Build the Payment API Server

The payment server exposes two endpoints: one to request a quote and one to confirm payment. This is where customers interact with your crypto payment gateway.

Stablecoins account for 76% of all crypto payments at the merchant level, which is why auto-settling to stablecoins makes your gateway compatible with existing accounting workflows.

import { Hono } from "hono";
import { ethers } from "ethers";

const app = new Hono();
const quotes = new Map<string, PaymentQuote>();

app.post("/api/payment/quote", async (c) => {
  const body = await c.req.json();
  const { chainId, tokenIn, amount, sender, orderId } = body;

  try {
    const quote = await getPaymentQuote(
      chainId,
      tokenIn,
      amount,
      sender,
      orderId
    );

    const chain = CHAINS[chainId];
    quotes.set(orderId, quote);

    return c.json({
      success: true,
      data: {
        orderId: quote.orderId,
        settlementAmount: formatSettlement(
          quote.expectedSettlement,
          chain.settlementDecimals
        ),
        minSettlementAmount: formatSettlement(
          quote.minSettlement,
          chain.settlementDecimals
        ),
        priceImpact: quote.priceImpact,
        tx: quote.tx,
        expiresIn: 30,
      },
    });
  } catch (err) {
    const message =
      err instanceof Error ? err.message : "Unknown error";
    return c.json({ success: false, error: message }, 400);
  }
});

The server stores quotes in memory keyed by order ID. In production, use Redis or a database with TTL expiry. The tx object returned to the frontend contains everything the customer's wallet needs to execute the swap.

Step 5: Handle Payment Verification

After the customer submits the transaction, your backend needs to verify that the swap executed and the settlement token arrived.

interface PaymentResult {
  orderId: string;
  status: "confirmed" | "failed" | "pending";
  settlementAmount: string;
  txHash: string;
}

async function verifyPayment(
  orderId: string,
  txHash: string
): Promise<PaymentResult> {
  const quote = quotes.get(orderId);
  if (!quote) {
    throw new Error("Quote not found");
  }

  const chain = CHAINS[quote.chainId];
  const provider = new ethers.JsonRpcProvider(chain.rpcUrl);

  const receipt = await provider.waitForTransaction(
    txHash,
    1,
    60000
  );

  if (!receipt || receipt.status === 0) {
    return {
      orderId,
      status: "failed",
      settlementAmount: "0",
      txHash,
    };
  }

  const erc20Interface = new ethers.Interface([
    "event Transfer(address indexed from, address indexed to, uint256 value)",
  ]);

  let settlementReceived = BigInt(0);

  for (const log of receipt.logs) {
    try {
      const parsed = erc20Interface.parseLog({
        topics: log.topics as string[],
        data: log.data,
      });
      if (
        parsed &&
        parsed.name === "Transfer" &&
        log.address.toLowerCase() ===
          chain.settlementToken.toLowerCase()
      ) {
        settlementReceived += parsed.args.value;
      }
    } catch {
      continue;
    }
  }

  const formatted = formatSettlement(
    settlementReceived.toString(),
    chain.settlementDecimals
  );

  return {
    orderId,
    status: "confirmed",
    settlementAmount: formatted,
    txHash,
  };
}

app.post("/api/payment/verify", async (c) => {
  const { orderId, txHash } = await c.req.json();

  try {
    const result = await verifyPayment(orderId, txHash);
    quotes.delete(orderId);
    return c.json({ success: true, data: result });
  } catch (err) {
    const message =
      err instanceof Error ? err.message : "Unknown error";
    return c.json({ success: false, error: message }, 500);
  }
});

The verification function parses transaction logs to confirm that the settlement token (USDC/USDT) was received. It checks for ERC-20 Transfer events matching the settlement token contract address, then sums the amounts.

Step 6: Add ERC-20 Approval Handling

When the customer pays with an ERC-20 token (not the native gas token), they must first approve the DEX router to spend their tokens. This is a standard EVM requirement, not specific to any swap provider.

Bloomberg Intelligence projects stablecoin payment flows could reach $56 trillion by 2030. Handling approvals smoothly is table stakes for any crypto payment gateway that wants to capture this growth.

async function checkAndBuildApproval(
  chainId: number,
  tokenIn: string,
  amountIn: string,
  sender: string,
  spender: string
): Promise<{ needsApproval: boolean; approvalTx?: object }> {
  if (tokenIn.toLowerCase() === NATIVE_TOKEN.toLowerCase()) {
    return { needsApproval: false };
  }

  const chain = CHAINS[chainId];
  const provider = new ethers.JsonRpcProvider(chain.rpcUrl);

  const erc20 = new ethers.Contract(
    tokenIn,
    [
      "function allowance(address owner, address spender) view returns (uint256)",
    ],
    provider
  );

  const currentAllowance = await erc20.allowance(sender, spender);

  if (currentAllowance >= BigInt(amountIn)) {
    return { needsApproval: false };
  }

  const iface = new ethers.Interface([
    "function approve(address spender, uint256 amount)",
  ]);
  const data = iface.encodeFunctionData("approve", [
    spender,
    ethers.MaxUint256,
  ]);

  return {
    needsApproval: true,
    approvalTx: {
      to: tokenIn,
      data,
      value: "0",
    },
  };
}

One edge case to handle: USDT on Ethereum requires resetting the allowance to zero before setting a new value. If you support Ethereum USDT payments, add a zero-approval step first.

Step 7: Build the Frontend Payment Flow

The frontend collects the customer's token choice, fetches a quote, handles approvals, and submits the swap transaction.

async function processPayment(
  orderId: string,
  chainId: number,
  tokenIn: string,
  amount: string
) {
  const provider = new ethers.BrowserProvider(window.ethereum);
  const signer = await provider.getSigner();
  const sender = await signer.getAddress();

  const quoteRes = await fetch("/api/payment/quote", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      chainId,
      tokenIn,
      amount,
      sender,
      orderId,
    }),
  });
  const quote = await quoteRes.json();

  if (!quote.success) {
    throw new Error(quote.error);
  }

  const approval = await checkAndBuildApproval(
    chainId,
    tokenIn,
    amount,
    sender,
    quote.data.tx.to
  );

  if (approval.needsApproval && approval.approvalTx) {
    const approvalTx = await signer.sendTransaction(
      approval.approvalTx
    );
    await approvalTx.wait();

    const freshQuoteRes = await fetch("/api/payment/quote", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        chainId,
        tokenIn,
        amount,
        sender,
        orderId,
      }),
    });
    const freshQuote = await freshQuoteRes.json();
    quote.data = freshQuote.data;
  }

  const gasEstimate = await provider.estimateGas({
    from: quote.data.tx.from,
    to: quote.data.tx.to,
    data: quote.data.tx.data,
    value: BigInt(quote.data.tx.value),
  });

  const txResponse = await signer.sendTransaction({
    to: quote.data.tx.to,
    data: quote.data.tx.data,
    value: BigInt(quote.data.tx.value),
    gasLimit: (gasEstimate * BigInt(120)) / BigInt(100),
  });

  const verifyRes = await fetch("/api/payment/verify", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      orderId,
      txHash: txResponse.hash,
    }),
  });

  return verifyRes.json();
}

After approval confirms, the code fetches a fresh quote (since calldata expires in 30 seconds), estimates gas with a 20% buffer, and submits the swap. The verification call then confirms settlement.

Comparison: Crypto Payment Gateway Approaches

Approach	Custody	Fees	Chains	Setup	Settlement
Hosted gateway (Coinbase Commerce, BitPay)	Custodial	1-2% per tx	3-5	Minutes	USD/crypto
Self-hosted with CEX API	Semi-custodial	Exchange fees	Limited	Hours	Exchange balance
DEX aggregator API (swapapi.dev)	Non-custodial	Gas only	46 chains	Hours	Direct to wallet
Custom smart contract	Non-custodial	Gas + audit cost	1 per deploy	Weeks	On-chain

The DEX aggregator approach gives you the broadest chain support and true non-custodial settlement. Funds go directly to the merchant wallet — no intermediary holds funds at any point.

Handling Edge Cases

Production crypto payment gateways need to handle several edge cases:

Partial fills: swapapi.dev may return a "Partial" status when liquidity is limited. The amountIn and expectedAmountOut fields reflect the partial amount, not your original request. Check data.status and decide whether to accept the partial payment or prompt the customer to try a different token.

Rate limiting: The API allows approximately 30 requests per minute per IP. For high-traffic gateways, cache quotes and implement request queuing. If you receive a RATE_LIMITED error, wait 5-10 seconds before retrying with exponential backoff.

Gas estimation failures: If eth_estimateGas fails, the swap would likely revert on-chain. Do not submit the transaction. Instead, return an error to the customer suggesting a different amount or token.

Stale quotes: Always check the 30-second expiry. If the customer takes too long to confirm, re-fetch the quote before submitting.

FAQ

What is a crypto payment gateway and how does it work?

A crypto payment gateway is a system that allows merchants to accept cryptocurrency payments. It works by receiving a customer's token, converting it to the merchant's preferred settlement currency (typically a stablecoin like USDC), and forwarding the proceeds to the merchant's wallet. The gateway in this guide uses a DEX aggregator API to handle the token-to-stablecoin conversion in a single atomic transaction.

How much does it cost to run a crypto payment gateway?

With the approach in this guide, the only cost is on-chain gas fees for executing swaps. There are no API fees (swapapi.dev is free), no monthly subscriptions, and no per-transaction percentage fees. Gas costs vary by chain: Ethereum mainnet may cost $2-10 per swap, while Layer 2 chains like Arbitrum or Base typically cost under $0.10.

Which chains should I support for a crypto payment gateway?

Start with the chains where your customers hold assets. Ethereum (chainId 1), Arbitrum (42161), and Base (8453) cover most DeFi users. Add BSC (56) for Southeast Asian markets and Polygon (137) for low-cost transactions. swapapi.dev supports 46 chains, so you can expand coverage by adding chain configs without changing any swap logic.

How do I handle refunds in a crypto payment system?

Refunds are separate transactions from the merchant wallet back to the customer's address. Store the customer's wallet address and payment token at checkout. For refunds, use the same swap API in reverse: swap the settlement stablecoin back to the customer's original token and send it to their address.

Get Started

swapapi.dev is a free DEX aggregator API with no API keys, no registration, and support for 46 EVM chains. Get a swap quote with a single GET request and receive executable calldata ready for on-chain submission.

API base URL: https://api.swapapi.dev
OpenAPI spec: api.swapapi.dev/openapi.json
Interactive docs: api.swapapi.dev/docs
Full documentation: swapapi.dev

How to Build a Crypto Portfolio Rebalancer With Python

Moon Soon — Thu, 09 Apr 2026 08:24:23 +0000

The crypto asset management market is projected to grow from $1.96 billion in 2026 to $11.74 billion by 2034 at a 25% CAGR (Fortune Business Insights). Automated portfolio rebalancing is one of the core drivers: 78% of institutional investors now use automated rebalancing tools (Gartner via WunderTrading), and automated portfolios showed 23% better returns compared to manual management in 2025 (DarkBot).

Yet most tutorials stop at the math. This guide builds a complete crypto portfolio rebalancer in Python that calculates allocation drift, determines required trades, and executes swaps on-chain across multiple EVM chains using swapapi.dev.

What You'll Need

Python 3.10+ with requests and web3 installed
A wallet with tokens on one or more EVM chains
An RPC endpoint (the API returns recommended RPCs, or use Chainlist)
swapapi.dev -- free, no API key, no registration, 46 chains supported

Install dependencies:

pip install requests web3

Step 1: Define Your Target Allocation

Every rebalancer starts with a target portfolio. Define each asset by chain, token address, decimal precision, and target weight.

Research from the MDPI Journal of Risk and Financial Management found that monthly rebalancing delivered 28.5% higher returns over a 52-week period compared to a fixed allocation strategy (MDPI). The optimal frequency depends on portfolio size and gas costs, but threshold-based rebalancing (trigger on drift) consistently outperforms calendar-based approaches.

PORTFOLIO = {
    "ETH": {
        "chain_id": 1,
        "address": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
        "decimals": 18,
        "target_pct": 40.0,
    },
    "USDC_ETH": {
        "chain_id": 1,
        "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "decimals": 6,
        "target_pct": 20.0,
    },
    "WETH_ARB": {
        "chain_id": 42161,
        "address": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
        "decimals": 18,
        "target_pct": 25.0,
    },
    "USDC_POLY": {
        "chain_id": 137,
        "address": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
        "decimals": 6,
        "target_pct": 15.0,
    },
}

DRIFT_THRESHOLD = 5.0
SENDER = "0xYourWalletAddress"

The DRIFT_THRESHOLD of 5% means the rebalancer only acts when an asset drifts more than 5 percentage points from its target. This avoids unnecessary gas spend on minor fluctuations.

Step 2: Fetch Current Balances and Prices

To calculate drift, you need two things per asset: the on-chain balance and its current USD value. Use web3.py for balances and swapapi.dev to get price quotes against a common stablecoin.

import requests
from web3 import Web3

SWAP_API = "https://api.swapapi.dev/v1/swap"
NATIVE_TOKEN = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"

STABLECOIN_BY_CHAIN = {
    1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
    137: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
}

STABLE_DECIMALS = 6


def get_balance(chain_id, token_address, rpc_url):
    w3 = Web3(Web3.HTTPProvider(rpc_url))
    if token_address == NATIVE_TOKEN:
        raw = w3.eth.get_balance(SENDER)
    else:
        erc20 = w3.eth.contract(
            address=Web3.to_checksum_address(token_address),
            abi=[{
                "inputs": [{"name": "account", "type": "address"}],
                "name": "balanceOf",
                "outputs": [{"name": "", "type": "uint256"}],
                "stateMutability": "view",
                "type": "function",
            }],
        )
        raw = erc20.functions.balanceOf(
            Web3.to_checksum_address(SENDER)
        ).call()
    return raw


def get_usd_price(chain_id, token_address, decimals):
    """Get USD price by quoting 1 unit against USDC."""
    stable = STABLECOIN_BY_CHAIN[chain_id]
    if token_address == stable:
        return 1.0
    one_unit = 10 ** decimals
    url = (
        f"{SWAP_API}/{chain_id}"
        f"?tokenIn={token_address}"
        f"&tokenOut={stable}"
        f"&amount={one_unit}"
        f"&sender={SENDER}"
    )
    resp = requests.get(url, timeout=15)
    data = resp.json()
    if not data["success"] or data["data"]["status"] != "Successful":
        raise ValueError(f"No route for {token_address} on chain {chain_id}")
    out = int(data["data"]["expectedAmountOut"])
    return out / (10 ** STABLE_DECIMALS)

The API response includes expectedAmountOut as a string-encoded BigInt. Dividing by 10^decimals of the output token gives you the human-readable USD price. The API returns quotes in 1-5 seconds; set a 15-second HTTP timeout as recommended in the docs.

Step 3: Calculate Portfolio Drift

With balances and prices in hand, compute each asset's current percentage and its drift from target. A 2026 case study showed that a portfolio ignoring rebalancing during a Bitcoin correction crashed 47% instead of the projected 28%, while rebalanced portfolios preserved 73% of capital during the same drawdown (Investopedia.su).

def calculate_drift(portfolio):
    positions = []
    total_usd = 0.0

    for name, asset in portfolio.items():
        rpc_resp = requests.get(
            f"{SWAP_API}/{asset['chain_id']}"
            f"?tokenIn={NATIVE_TOKEN}"
            f"&tokenOut={STABLECOIN_BY_CHAIN[asset['chain_id']]}"
            f"&amount=1000000000000000000"
            f"&sender={SENDER}",
            timeout=15,
        )
        rpc_url = rpc_resp.json()["data"].get(
            "rpcUrl", "https://cloudflare-eth.com"
        )

        balance_raw = get_balance(
            asset["chain_id"], asset["address"], rpc_url
        )
        price = get_usd_price(
            asset["chain_id"], asset["address"], asset["decimals"]
        )
        balance_human = balance_raw / (10 ** asset["decimals"])
        usd_value = balance_human * price

        positions.append({
            "name": name,
            "balance_raw": balance_raw,
            "balance_human": balance_human,
            "price": price,
            "usd_value": usd_value,
            "target_pct": asset["target_pct"],
            "chain_id": asset["chain_id"],
            "address": asset["address"],
            "decimals": asset["decimals"],
        })
        total_usd += usd_value

    for pos in positions:
        pos["current_pct"] = (
            (pos["usd_value"] / total_usd * 100) if total_usd > 0 else 0
        )
        pos["drift"] = pos["current_pct"] - pos["target_pct"]

    return positions, total_usd

The function returns a list of positions with their drift values. Positive drift means overweight (sell), negative drift means underweight (buy).

Step 4: Generate Rebalance Trades

Now determine which trades to execute. The strategy: sell overweight assets into USDC on the same chain, then buy underweight assets with USDC on their respective chains.

Strategy	Frequency	Best For	Gas Cost
Calendar-based	Weekly/Monthly	Passive investors	Predictable
Threshold-based	On drift > X%	Active portfolios	Lower overall
Band-based	Range around target	Volatile assets	Moderate
Hybrid (threshold + calendar)	Drift check + monthly floor	Multi-chain portfolios	Optimized

The threshold-based approach used here eliminates unnecessary trades. Research shows that bi-weekly rebalancing outperformed monthly by 3.55% for mid-sized portfolios, while weekly rebalancing added transaction cost drag at smaller portfolio sizes (MDPI).

def generate_trades(positions, total_usd):
    trades = []

    for pos in positions:
        if abs(pos["drift"]) < DRIFT_THRESHOLD:
            continue

        target_usd = total_usd * pos["target_pct"] / 100
        delta_usd = target_usd - pos["usd_value"]

        if delta_usd < 0:
            sell_usd = abs(delta_usd)
            sell_amount = int(
                (sell_usd / pos["price"]) * (10 ** pos["decimals"])
            )
            trades.append({
                "action": "sell",
                "asset": pos["name"],
                "chain_id": pos["chain_id"],
                "token_in": pos["address"],
                "token_out": STABLECOIN_BY_CHAIN[pos["chain_id"]],
                "amount_raw": str(sell_amount),
                "usd_value": sell_usd,
            })
        else:
            buy_amount = int(delta_usd * (10 ** STABLE_DECIMALS))
            trades.append({
                "action": "buy",
                "asset": pos["name"],
                "chain_id": pos["chain_id"],
                "token_in": STABLECOIN_BY_CHAIN[pos["chain_id"]],
                "token_out": pos["address"],
                "amount_raw": str(buy_amount),
                "usd_value": delta_usd,
            })

    return trades

Sells execute first to generate USDC liquidity. Buys consume that liquidity. On a multi-chain portfolio, each chain's USDC balance is independent -- cross-chain bridging is outside the scope of this rebalancer (swapapi.dev is single-chain only, as noted in its docs).

Step 5: Execute Swaps via swapapi.dev

For each trade, fetch a quote and submit the transaction. The API returns ready-to-execute calldata including the router address, encoded data, and gas price.

A quick test with curl before wiring up execution:

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

The execution function with full safety checks:

def execute_trade(trade, private_key):
    url = (
        f"{SWAP_API}/{trade['chain_id']}"
        f"?tokenIn={trade['token_in']}"
        f"&tokenOut={trade['token_out']}"
        f"&amount={trade['amount_raw']}"
        f"&sender={SENDER}"
        f"&maxSlippage=0.005"
    )
    resp = requests.get(url, timeout=15)
    data = resp.json()

    if not data["success"]:
        print(f"API error: {data['error']['message']}")
        return None

    status = data["data"]["status"]

    if status == "NoRoute":
        print(f"No route for {trade['asset']} on chain {trade['chain_id']}")
        return None

    if status == "Partial":
        filled_in = int(data["data"]["amountIn"])
        requested = int(trade["amount_raw"])
        fill_pct = filled_in / requested * 100
        print(f"Partial fill: {fill_pct:.1f}% for {trade['asset']}")

    impact = data["data"].get("priceImpact", 0)
    if impact < -0.05:
        print(f"Price impact too high ({impact:.2%}), skipping")
        return None

    tx_data = data["data"]["tx"]
    rpc_url = data["data"].get("rpcUrl", "https://cloudflare-eth.com")
    w3 = Web3(Web3.HTTPProvider(rpc_url))

    tx = {
        "from": SENDER,
        "to": Web3.to_checksum_address(tx_data["to"]),
        "data": tx_data["data"],
        "value": int(tx_data["value"]),
    }

    gas_estimate = w3.eth.estimate_gas(tx)
    tx["gas"] = int(gas_estimate * 1.2)
    tx["nonce"] = w3.eth.get_transaction_count(SENDER)

    signed = w3.eth.account.sign_transaction(tx, private_key)
    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)

    print(f"Submitted: {tx_hash.hex()}")
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)
    return receipt

Key safety measures from the API docs:

Check priceImpact before executing. Reject swaps with impact worse than -5%.
Estimate gas with a 20% buffer. If estimate_gas fails, the swap would revert on-chain.
Submit within 30 seconds of fetching the quote. Calldata includes a deadline.
Handle Partial status by comparing response amountIn to your requested amount.

Step 6: Wire It All Together

The main rebalance loop: calculate drift, generate trades, execute sells first, then buys.

def rebalance(portfolio, private_key):
    print("Calculating portfolio drift...")
    positions, total_usd = calculate_drift(portfolio)

    print(f"\nTotal portfolio value: ${total_usd:,.2f}")
    print(f"{'Asset':<12} {'Current':>8} {'Target':>8} {'Drift':>8}")
    print("-" * 40)
    for pos in positions:
        print(
            f"{pos['name']:<12} "
            f"{pos['current_pct']:>7.1f}% "
            f"{pos['target_pct']:>7.1f}% "
            f"{pos['drift']:>+7.1f}%"
        )

    trades = generate_trades(positions, total_usd)

    if not trades:
        print("\nNo rebalancing needed. All assets within threshold.")
        return

    sells = [t for t in trades if t["action"] == "sell"]
    buys = [t for t in trades if t["action"] == "buy"]

    print(f"\nExecuting {len(sells)} sells, then {len(buys)} buys...")

    for trade in sells + buys:
        print(f"\n{trade['action'].upper()} {trade['asset']}: ~${trade['usd_value']:,.2f}")
        execute_trade(trade, private_key)


rebalance(PORTFOLIO, "0xYourPrivateKey")

Step 7: Add ERC-20 Approval Handling

When selling ERC-20 tokens (not native ETH/POL/BNB), you must approve the router contract to spend your tokens before the swap. The API response tells you the router address in tx.to.

ERC20_APPROVE_ABI = [{
    "inputs": [
        {"name": "spender", "type": "address"},
        {"name": "amount", "type": "uint256"},
    ],
    "name": "approve",
    "outputs": [{"name": "", "type": "bool"}],
    "stateMutability": "nonpayable",
    "type": "function",
}]

MAX_UINT256 = 2**256 - 1


def ensure_approval(chain_id, token_address, spender, rpc_url, private_key):
    if token_address == NATIVE_TOKEN:
        return

    w3 = Web3(Web3.HTTPProvider(rpc_url))
    token = w3.eth.contract(
        address=Web3.to_checksum_address(token_address),
        abi=ERC20_APPROVE_ABI + [{
            "inputs": [
                {"name": "owner", "type": "address"},
                {"name": "spender", "type": "address"},
            ],
            "name": "allowance",
            "outputs": [{"name": "", "type": "uint256"}],
            "stateMutability": "view",
            "type": "function",
        }],
    )

    current = token.functions.allowance(
        Web3.to_checksum_address(SENDER),
        Web3.to_checksum_address(spender),
    ).call()

    if current >= MAX_UINT256 // 2:
        return

    tx = token.functions.approve(
        Web3.to_checksum_address(spender), MAX_UINT256
    ).build_transaction({
        "from": SENDER,
        "nonce": w3.eth.get_transaction_count(SENDER),
    })

    signed = w3.eth.account.sign_transaction(tx, private_key)
    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
    w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)
    print(f"Approved {token_address} for router {spender}")

After approval confirms, re-fetch a fresh quote before submitting the swap. The calldata is time-sensitive (30-second deadline), so never reuse a stale quote.

Frequently Asked Questions

How often should a crypto portfolio rebalancer execute?

Research shows that threshold-based rebalancing (trigger on 5%+ drift) outperforms fixed schedules for most portfolio sizes. Monthly rebalancing delivered 28.5% higher returns than no rebalancing, while bi-weekly outperformed monthly by 3.55% for portfolios under $50,000. For larger portfolios, weekly rebalancing becomes optimal as the trade value outweighs gas costs.

What chains does swapapi.dev support for rebalancing?

The API supports 46 EVM chains including Ethereum, Arbitrum, Base, Polygon, BSC, Optimism, Avalanche, and more. Each chain operates independently -- the API is single-chain only, so cross-chain rebalancing requires separate swaps on each chain plus a bridge step outside the API.

How do I handle partial fills during rebalancing?

The API returns a Partial status when only part of your requested amount can be filled due to liquidity constraints. The response amountIn reflects the partial amount, not your original request. Your rebalancer should compare the two values, decide whether the partial fill is acceptable, and avoid retrying the same amount in a loop since the liquidity cap will not change.

Does swapapi.dev require an API key?

No. The API is free with no API key, no registration, and no account required. Rate limiting is approximately 30 requests per minute per IP. For a rebalancer checking 4-10 assets, this is more than sufficient.

How do I avoid excessive slippage on large rebalance trades?

Check the priceImpact field in the API response before executing. Reject any swap with price impact worse than -5% (i.e., priceImpact < -0.05). For large trades, consider splitting into smaller amounts and executing sequentially, checking price impact on each chunk.

Get Started

swapapi.dev provides free, keyless token swap quotes and executable calldata across 46 EVM chains. The full OpenAPI spec documents every parameter and response field.

To build your crypto portfolio rebalancer:

Define your target allocation across chains and tokens
Use the /v1/swap/{chainId} endpoint to get live prices and executable trades
Set a drift threshold to avoid over-trading
Execute sells before buys to generate stablecoin liquidity

No API key. No registration. Start building at swapapi.dev.

5 Best Swap APIs for Web3 Wallet Developers

Moon Soon — Thu, 09 Apr 2026 08:24:22 +0000

Web3 wallets are no longer just key managers. They are execution layers. The Web3 wallet market is projected to reach $8.93 billion in 2026, up from $6.57 billion in 2025 -- a 27.6% CAGR driven largely by in-wallet swap features. MetaMask alone generates $53.5 million annually from swap fees, Phantom's swap volume exceeded $20 billion in 2025, and DEX aggregators now route over $13.5 billion in daily trading volume across hundreds of liquidity pools.

For wallet developers, the swap API you integrate determines your chain coverage, your time-to-market, and whether your users see a "swap" button or a "swap on 3 chains" button. This guide compares the 5 best swap APIs for Web3 wallet development in 2026 -- ranked by what wallet developers actually care about: latency, transaction-ready calldata, multi-chain support, and integration friction.

What Wallet Developers Need From a Swap API

Before the comparison, here is the checklist that separates a usable swap API from a research project:

Transaction-ready calldata: The API must return to, data, and value fields that can be passed directly to a wallet signer. If you need a second call to build the transaction, that is latency your users feel.
Multi-chain support: With 30 million MetaMask monthly active users spread across Ethereum, Arbitrum, Base, Polygon, and BSC, a wallet that only swaps on one chain is leaving money on the table.
No API key for development: Registration gates slow down prototyping. The best developer experience starts with a curl command, not a signup form.
Slippage and partial fill handling: Wallets must protect users from MEV and low-liquidity pairs. The API should return minAmountOut and handle partial fills without crashing.
RPC endpoints included: Wallet developers who support 10+ chains do not want to maintain their own RPC list. Bundled RPCs reduce infrastructure overhead.

1. Swap API (swapapi.dev)

Swap API is a free DEX aggregator API built for the wallet integration use case. It returns executable swap calldata from a single GET request across 46 EVM chains -- from Ethereum and Arbitrum to newer networks like Monad, MegaETH, Berachain, and Sonic. No API key, no registration, no payment.

The integration is a single HTTP call. Send chainId, tokenIn, tokenOut, amount, and sender, and get back a complete transaction object ready for signing:

curl "https://api.swapapi.dev/v1/swap/42161?tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&tokenOut=0xaf88d065e77c8cC2239327C5EDb3A432268e5831&amount=1000000000000000000&sender=0xYourWalletAddress"

The response includes expectedAmountOut, minAmountOut (with built-in slippage protection), priceImpact, full token metadata, and an array of up to 5 ranked RPC endpoints for the target chain. The tx object contains from, to, data, value, and gasPrice -- everything a wallet needs to present a confirmation screen and submit on-chain.

Swap API also handles edge cases that break wallet UIs in production. A Partial status returns adjusted amounts and an executable transaction for the available liquidity instead of failing. A NoRoute status returns cleanly so the wallet can show "pair not available" rather than a cryptic error. The envelope response format ({ success, data, error, timestamp }) is consistent across all status codes.

Why wallet developers pick it: 46 chains from one endpoint, zero setup, transaction-ready responses, and built-in RPC fallback lists. The rate limit is approximately 30 requests per minute per IP -- sufficient for wallet-scale usage without needing a billing account.

2. 1inch Swap API

1inch is the dominant DEX aggregator by volume, capturing over 59% of EVM DEX aggregator volume in Q2 2025. The Pathfinder algorithm splits trades across 400+ liquidity sources and claims up to 6.5% gas savings compared to single-DEX routes.

The 1inch Swap API v6 requires registration and an API key. Plans start with a free Dev tier (100,000 calls/month) and scale to $599/month for 7 million calls:

curl -H "Authorization: Bearer YOUR_API_KEY" "https://api.1inch.dev/swap/v6.0/1/swap?src=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&dst=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&amount=1000000000000000000&from=0xYourWalletAddress"

The API covers 12 major blockchains. For wallet developers, the trade-off is clear: better routing depth on major chains, but narrower chain coverage and an API key requirement that adds friction during development. The free tier's 100,000 call limit can be tight for wallets with active user bases.

Best for: Production wallets focused on Ethereum, Arbitrum, and BSC where routing optimization on high-liquidity pairs is the priority over chain breadth.

3. 0x Swap API (Matcha)

The 0x API powers Matcha and provides swap infrastructure to dozens of wallets and dApps. Its differentiator is the RFQ (Request for Quote) system, which sources liquidity from professional market makers in addition to on-chain DEX pools. For large trades (over $10,000), RFQ quotes often beat pure on-chain routing.

0x requires an API key and moved to a paid model -- the free tier was discontinued in 2024. The API collects "Trade Surplus" (positive slippage) as its fee model:

curl -H "0x-api-key: YOUR_KEY" "https://api.0x.org/swap/v1/quote?buyToken=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&sellToken=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&sellAmount=1000000000000000000"

Chain support includes Ethereum, Polygon, BSC, Arbitrum, Optimism, Base, Avalanche, and several others. The API returns transaction-ready data, though the response schema differs from other aggregators, requiring some adapter logic in multi-provider wallet architectures.

Best for: Wallets handling large-value swaps where institutional-grade RFQ liquidity provides measurably better execution than on-chain routing alone.

4. Velora (formerly ParaSwap)

Velora, rebranded from ParaSwap in late 2025, has processed over $100 billion in historical volume. The API offers both REST endpoints and a JavaScript SDK, making it flexible for different wallet architectures.

Velora supports Ethereum, Polygon, BSC, Avalanche, Arbitrum, Optimism, Base, and Fantom. Its MultiPath routing algorithm splits trades across multiple DEXs and uses multi-hop paths for illiquid pairs. A separate buildTx endpoint constructs the transaction after you fetch a price quote:

curl "https://api.velora.xyz/prices?srcToken=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&destToken=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&amount=1000000000000000000&network=1"

The two-step flow (quote then build) adds latency compared to single-request APIs. For wallet developers, this means an extra round-trip before presenting the confirmation screen. Velora does offer a fee-sharing model (revenue share on swap fees), which can be attractive for wallets looking to monetize swaps.

Best for: Wallet teams that want a JavaScript SDK for complex frontend integrations and are willing to accept the two-step API flow.

5. LI.FI API

LI.FI is a DEX and bridge aggregation protocol. While other APIs on this list handle single-chain swaps, LI.FI combines swap routing with cross-chain bridging in a single request. If your wallet needs "swap ETH on Arbitrum to USDC on Base," LI.FI can route that in one call.

The API requires an API key (free tier available) and supports 30+ chains including both EVM and non-EVM networks:

curl -H "x-lifi-api-key: YOUR_KEY" "https://li.quest/v1/quote?fromChain=42161&toChain=8453&fromToken=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&toToken=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&fromAmount=1000000000000000000&fromAddress=0xYourAddress"

The trade-off for wallet developers: cross-chain capability comes with higher latency (bridge quotes are slower than single-chain swaps) and more complex response handling. For same-chain swaps, a dedicated aggregator API typically provides faster responses and simpler integration.

Best for: Wallets that need cross-chain swap functionality as a core feature and are willing to handle the added complexity of bridge routing.

Comparison Table

Feature	Swap API	1inch	0x	Velora	LI.FI
API Key Required	No	Yes	Yes	Yes	Yes
EVM Chains	46	12	~10	8	30+
Single-Request Tx	Yes	Yes	Yes	No (2-step)	Yes
Cross-Chain	No	No	No	No	Yes
Free Tier	Unlimited	100K calls/mo	No	Yes	Yes
RPC Endpoints Included	Yes (up to 5)	No	No	No	No
Partial Fill Handling	Yes	Limited	No	No	No
Response Format	Envelope	Flat JSON	Flat JSON	Flat JSON	Nested JSON

FAQ

What is the best swap API for Web3 wallet integration?

For most Web3 wallet developers, the best swap API is one that returns transaction-ready calldata in a single request without requiring an API key. Swap API (swapapi.dev) fits this criteria with 46 EVM chains, zero registration, and a response format that includes everything a wallet needs: the tx object for signing, expectedAmountOut for the confirmation screen, priceImpact for safety warnings, and rpcUrls for chain connectivity.

How do I add token swaps to my Web3 wallet?

Integrate a swap API that returns executable transaction data. Fetch a quote with the user's sender address, display expectedAmountOut and priceImpact on a confirmation screen, then submit the returned tx object through the wallet's signer. For ERC-20 input tokens, check the user's allowance first and prompt for approval if needed. Always run eth_estimateGas before submitting -- if it fails, the swap would revert on-chain.

Do swap APIs work across multiple blockchains?

Yes, but chain coverage varies significantly. Some APIs support 8-12 major chains while others cover 46 EVM networks from a single endpoint. For multi-chain wallets, look for an API where you only change the chainId parameter rather than switching base URLs or configuring separate endpoints per chain. This keeps your integration code simple as you add new networks.

How do I handle failed swaps in a wallet UI?

Check the API response status field before presenting the transaction. A Successful status means a full route was found. A Partial status means only part of the amount can be filled -- show the user the reduced amount and let them decide. A NoRoute status means no liquidity path exists -- display "swap unavailable for this pair" rather than a raw error. Always simulate the transaction with eth_call before submitting to catch balance, allowance, or deadline issues.

What slippage settings should wallets use for swap APIs?

A default maxSlippage of 0.005 (0.5%) works for most pairs on major chains. For low-liquidity tokens or newer chains, consider allowing users to adjust up to 1-3%. Check the priceImpact field in the response -- if it exceeds -5%, warn the user before proceeding. The minAmountOut field in the response reflects the on-chain minimum enforced by the smart contract, so the transaction will revert automatically if slippage exceeds the tolerance.

Get Started

Swap API is free, requires no API key, and supports 46 EVM chains. Start with a curl command and have swaps working in your wallet in minutes, not days.

API base URL: https://api.swapapi.dev
OpenAPI spec: https://swapapi.dev/openapi
Documentation: https://swapapi.dev/llms.txt

curl "https://api.swapapi.dev/v1/swap/137?tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&tokenOut=0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359&amount=1000000000000000000&sender=0xYourWalletAddress"

No signup. No billing. Swap on Ethereum, Arbitrum, Polygon, Base, BSC, and 41 more chains from one endpoint.