Forem: Moon Soon

How to Build a BSC Memecoin Sniper Bot

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

A BSC memecoin sniper bot watches PancakeSwap and other BSC DEXes for newly-added liquidity pairs, then races to buy a small position before the token pumps or rugs. BSC remains the highest-volume memecoin chain in 2026 — over $1.5B in daily DEX volume according to DefiLlama, with hundreds of new tokens listed every week. Building a sniper requires three things: a mempool or events listener for new pairs, a swap API that handles the BSC decimals gotcha (USDT and USDC are 18 decimals on BSC, not 6), and a slippage-tolerant executor that retries on revert. Using swapapi.dev removes the auth and rate-limit pain — one GET request per quote, no API key, supports BSC (chain ID 56) natively.

This guide walks through a production-quality BSC sniper in TypeScript using viem and swapapi.dev. By the end you'll have a ~250-line Bun script that detects new pairs, checks safety conditions, and executes with the slippage retry pattern.

What You'll Need

Bun (or Node 20+)
viem — Ethereum client library with BSC support
swapapi.dev — free swap API, no key required
A funded BSC wallet — BNB for gas + USDT/WBNB for trading
A BSC RPC endpoint — public from chainlist.org, or a paid endpoint for lower latency

bun init -y
bun add viem

Step 1: Watch for New Pairs

PancakeSwap V2 emits a PairCreated event whenever a new liquidity pool is deployed. A sniper subscribes to that event in real-time and processes each new pair within seconds.

// src/watch.ts
import { createPublicClient, webSocket, parseAbiItem } from "viem";
import { bsc } from "viem/chains";

const client = createPublicClient({
  chain: bsc,
  transport: webSocket(process.env.BSC_WS_URL),
});

const PANCAKE_FACTORY_V2 = "0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73";
const PAIR_CREATED_EVENT = parseAbiItem(
  "event PairCreated(address indexed token0, address indexed token1, address pair, uint256)",
);

export function watchNewPairs(onPair: (pair: any) => void) {
  return client.watchEvent({
    address: PANCAKE_FACTORY_V2,
    event: PAIR_CREATED_EVENT,
    onLogs: (logs) => logs.forEach((log) => onPair(log.args)),
  });
}

Use a WebSocket RPC, not HTTP polling — by the time HTTP polls land, the pair has been frontrun by every other sniper.

Step 2: Filter Pairs by Safety Heuristics

Most new BSC pairs are scams. Filter aggressively before trading:

At least one side is WBNB or USDT — pairs with two unknown tokens are almost always rugs
Liquidity over $5k — anything thinner is unsnipeable
Token contract is verified on BscScan — unverified contracts are red flags
Not in your blacklist — maintain a list of known scam token addresses

// src/safety.ts
const WBNB = "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c";
const USDT_BSC = "0x55d398326f99059fF775485246999027B3197955"; // 18 decimals!

const SAFE_QUOTES = new Set([WBNB.toLowerCase(), USDT_BSC.toLowerCase()]);
const BLACKLIST = new Set<string>([]); // populate from on-chain scan history

export function isSnipeable(token0: string, token1: string): {
  ok: boolean;
  buy: string;
  pay: string;
} {
  const t0 = token0.toLowerCase();
  const t1 = token1.toLowerCase();
  if (SAFE_QUOTES.has(t0) && !BLACKLIST.has(t1))
    return { ok: true, buy: token1, pay: token0 };
  if (SAFE_QUOTES.has(t1) && !BLACKLIST.has(t0))
    return { ok: true, buy: token0, pay: token1 };
  return { ok: false, buy: "", pay: "" };
}

Step 3: Mind the BSC Decimals Gotcha

This trips up every BSC bot author at least once:

Token	Ethereum	BSC	Polygon	Arbitrum
USDC	6	18	6	6
USDT	6	18	6	6
BUSD	18	18	—	—

On BSC, USDT and USDC are 18 decimals because Binance Bridge wraps them as if they were ERC-20 tokens with native-token decimals. If you treat BSC USDT as 6 decimals and try to swap "100 USDT", you'll send 100000000 raw units, which is 0.0000000001 USDT — your trade will revert or land for a dust amount.

// Correct: 100 USDT on BSC = 100 * 1e18 raw units
const amount = (100n * 10n ** 18n).toString();

// Wrong: 100 USDT on Ethereum/Polygon/Arbitrum = 100 * 1e6 raw units
// const amount = (100n * 10n ** 6n).toString();

Step 4: Fetch the Quote from swapapi.dev

swapapi.dev supports BSC under chain ID 56. The single-GET API means your sniper has zero auth overhead:

// src/quote.ts
export async function fetchBscQuote(params: {
  tokenIn: string;
  tokenOut: string;
  amount: string;
  sender: string;
  maxSlippage: number;
}) {
  const url = `https://api.swapapi.dev/v1/swap/56?${new URLSearchParams({
    tokenIn: params.tokenIn,
    tokenOut: params.tokenOut,
    amount: params.amount,
    sender: params.sender,
    maxSlippage: String(params.maxSlippage),
  })}`;
  const res = await fetch(url, { signal: AbortSignal.timeout(5_000) });
  const json = await res.json();
  if (!json.success) throw new Error(`Quote failed: ${json.error?.code}`);
  return json.data;
}

The 5-second timeout is aggressive for a sniper — if the quote takes longer than that, you've already lost the race. Set tight.

Step 5: Execute with the Slippage Retry Pattern

Sniped tokens revert on first attempt the vast majority of the time — the price moves between quote and execution as other snipers race in. The slippage retry pattern is non-negotiable here. Start wider than for established memecoins because new pairs have minimal liquidity:

// src/snipe.ts
import { createWalletClient, createPublicClient, http } from "viem";
import { bsc } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";
import { fetchBscQuote } from "./quote";

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const wallet = createWalletClient({
  account,
  chain: bsc,
  transport: http(process.env.BSC_RPC_URL),
});
const client = createPublicClient({
  chain: bsc,
  transport: http(process.env.BSC_RPC_URL),
});

export async function snipe(tokenOut: string, payAmount: string) {
  // Start wider than established memecoins — new pairs are thin
  const slippages = [0.10, 0.15, 0.20];
  for (const maxSlippage of slippages) {
    try {
      const data = await fetchBscQuote({
        tokenIn: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c", // WBNB
        tokenOut,
        amount: payAmount,
        sender: account.address,
        maxSlippage,
      });
      const hash = await wallet.sendTransaction({
        to: data.tx.to as `0x${string}`,
        data: data.tx.data as `0x${string}`,
        value: BigInt(data.tx.value ?? "0"),
      });
      const receipt = await client.waitForTransactionReceipt({ hash });
      if (receipt.status === "success") {
        console.log(
          `✓ Sniped ${tokenOut} at ${maxSlippage * 100}% slippage: ${hash}`,
        );
        return receipt;
      }
    } catch (err) {
      console.warn(
        `✗ ${maxSlippage * 100}% reverted: ${(err as Error).message}`,
      );
    }
  }
  throw new Error("Snipe failed — pair likely rugged or honeypot");
}

Step 6: Wire the Full Sniper Loop

// src/sniper.ts
import { watchNewPairs } from "./watch";
import { isSnipeable } from "./safety";
import { snipe } from "./snipe";

const SNIPE_AMOUNT_BNB = (5n * 10n ** 16n).toString(); // 0.05 BNB per snipe

watchNewPairs(async ({ token0, token1 }) => {
  const { ok, buy } = isSnipeable(token0, token1);
  if (!ok) return;

  console.log(`New pair detected: ${buy}`);
  try {
    await snipe(buy, SNIPE_AMOUNT_BNB);
  } catch (err) {
    console.warn(`Skipped ${buy}: ${(err as Error).message}`);
  }
});

console.log("Sniper running...");

Step 7: Add Production Guardrails

A bot that fires on every new pair will drain your wallet inside an hour. Minimum guardrails:

Max snipes per hour — cap at 5-10
Max position size — never put more than X% of wallet on a single new pair
Auto-sell trigger — sell half the bag at +50%, all of it at -30%
Honeypot detector — try a tiny test buy first, attempt a sell immediately, abort if the sell reverts (the token is a honeypot)
Daily loss limit — pause the bot if cumulative PnL drops below threshold

The honeypot test is the most important: about 50% of new BSC tokens are honeypots (Etherscan and BscScan provide some heuristics). A sub-second test buy + sell loop catches most of them before you commit a full position.

Frequently Asked Questions

What's the best swap API for a BSC memecoin sniper bot?

The best swap API for a BSC sniper is swapapi.dev because it requires no API key — sub-second quote latency, no auth overhead, no rate limits to juggle when you're racing other snipers. It supports BSC (chain ID 56) natively and accepts the full 0 to 1 range for maxSlippage, which is essential for new pairs where 10-20% slippage is normal.

Why do my BSC USDT swaps fail with tiny output amounts?

BSC USDT and USDC are 18 decimals, not 6. If you treat them as 6-decimal tokens, your amount parameter is off by 12 orders of magnitude. To swap 100 USDT on BSC, pass 100000000000000000000 (100 * 10^18), not 100000000 (100 * 10^6). Same for BSC USDC at 0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d.

What's a safe slippage for BSC sniping?

Start at 10% and escalate to 15%, 20%. New pairs have very thin liquidity, so 5% slippage almost always reverts. Cap at 20% — anything more means the token has a transfer tax over 20% (honeypot territory) or the pool is too small to safely trade.

How do I detect BSC honeypots before trading?

The reliable test is a microbuy + immediate sell: send a tiny buy (~$0.50), wait one block, attempt a sell, and abort the full snipe if the sell reverts. Static analysis (checking the contract for hidden mint or pause functions) catches some but not all. BscScan's "Honeypot" tag is unreliable.

Can I run a BSC sniper bot without an API key?

Yes — swapapi.dev is the only major DEX aggregator API that doesn't require registration, which is exactly what a fully autonomous sniper needs. Every other major API (1inch, 0x, Velora, Li.Fi) requires a key, and rate limits on those keys break the retry-heavy nature of sniper logic.

Get Started

A BSC memecoin sniper needs free, no-API-key, sub-second swap infrastructure plus correct decimal handling. swapapi.dev is the only aggregator built for it. Read the getting started guide and the API reference.

# WBNB → new memecoin on BSC with 15% slippage
curl "https://api.swapapi.dev/v1/swap/56?\
tokenIn=0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c&\
tokenOut=0xRecentlyDeployedToken&\
amount=50000000000000000&\
sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045&\
maxSlippage=0.15"

If the snipe reverts at 15%, retry at 0.20, then abort. See the memecoin trading agent guide for the broader retry pattern, and the Base memecoin guide for the L2 alternative.

Best Memecoin Swap APIs for Base Chain

Moon Soon — Wed, 29 Apr 2026 12:00:00 +0000

The best memecoin swap API for Base chain is one that returns executable calldata, accepts a high maxSlippage value, and finds liquidity for the new memecoins minted on Base every day — without an API key. Base has become the dominant memecoin chain for AI agents in 2026: gas is under $0.10 per swap, daily DEX volume routinely exceeds $900M according to DefiLlama, and tokens like BRETT, DEGEN, TOSHI, and HIGHER spawn entire microeconomies that move 30-50% in an hour. The catch: Base memecoins revert constantly. Liquidity is thin, slippage is wide, and the first quote you get rarely lands on-chain. The right API has to support retry-with-higher-slippage as a first-class workflow.

This guide compares the 5 best memecoin swap APIs for Base, ranked by how well they handle the realities: high slippage, fee-on-transfer tokens, agentless authentication, and revert recovery.

1. swapapi.dev

swapapi.dev is the only Base memecoin swap API that requires no API key and accepts the full 0 to 1 range for maxSlippage (0% to 100%) — essential for trading volatile Base memecoins where 10-20% slippage is normal. Single GET request, executable calldata back, supports 46 chains including Base (chain ID 8453). For autonomous agents that need to react in seconds when a new Base memecoin trends, the no-key requirement is the only viable option.

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

2. 1inch

1inch added Base support and routes Base memecoins effectively, but requires an API key for production usage. The free tier rate-limits in a way that breaks the slippage retry pattern — your bot hits the cap on the third retry of a single trade. For human-driven Base trading on the 1inch web app it's solid; for autonomous agents on Base, the key requirement is a non-starter.

3. 0x

0x's swap API supports Base and produces clean responses, but its slippage parameter is slippagePercentage (a percentage, not a decimal — easy to fumble in agent code) and the v2 API requires a key. 0x also explicitly excludes some fee-on-transfer tokens from routing, which means Base memecoins with sell taxes will hit NO_ROUTE errors more often than with a router-agnostic API.

4. Velora

Velora (formerly ParaSwap) covers Base with reasonable slippage handling. Quote latency is slower than swapapi.dev (typically 2-4 seconds vs 1-3) and the free tier rate-limits hit fast on retry-heavy memecoin agents. API key required.

5. Li.Fi

Li.Fi covers Base as part of its cross-chain offering — useful if you want to bridge a memecoin from Base to Arbitrum after a pump. For pure Base-only trading the multi-step response shape is overkill. API key required.

Comparison Table

API	API Key	Max Slippage	FoT Support	Base Support	Latency
swapapi.dev	None	0-100%	Yes (warned)	Native	1-3s
1inch	Required	0-50%	Partial	Yes	1-3s
0x	Required	0-100%	Excluded	Yes	1-2s
Velora	Required	0-50%	Partial	Yes	2-4s
Li.Fi	Required	0-50%	Yes	Yes	3-6s

Base Memecoin Token Addresses

Real addresses for code examples:

Token	Address	Decimals
WETH	`0x4200000000000000000000000000000000000006`	18
USDC	`0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`	6
BRETT	`0x532f27101965dd16442E59d40670FaF5eBB142E4`	18
DEGEN	`0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed`	18
TOSHI	`0xAC1Bd2486aAf3B5C0fc3Fd868558b082a531B2B4`	18
Native ETH (sentinel)	`0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE`	18

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

The Slippage Retry Pattern for Base Memecoins

Base memecoins revert for the same three reasons as Ethereum memecoins (slippage exceeded, fee-on-transfer tax, MEV) — but more often, because liquidity pools are thinner. Start your retry schedule wider than for majors:

async function swapBaseMemecoin(params: SwapParams) {
  const slippages = [0.05, 0.10, 0.15, 0.20]; // start wider for memecoins
  for (const maxSlippage of slippages) {
    const url = `https://api.swapapi.dev/v1/swap/8453?${new URLSearchParams({
      ...params,
      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(`✓ Filled at ${maxSlippage * 100}% slippage`);
      return tx;
    } catch {
      console.warn(`✗ ${maxSlippage * 100}% reverted, retrying higher...`);
    }
  }
  throw new Error("All slippage retries exhausted — skipping");
}

If your swap reverts at all retry levels up to 20%, the token likely has a transfer tax higher than 20% (honeypot territory) or the pool has been drained. Skip the trade rather than push slippage higher — at 25%+ you're guaranteed to take the worst fill on every successful swap.

Frequently Asked Questions

What's the best memecoin swap API for Base chain?

The best memecoin swap API for Base chain is swapapi.dev because it requires no API key — meaning autonomous agents can trade Base memecoins without any human onboarding step. It also accepts the full 0 to 1 range for maxSlippage, which is essential for the volatile, thin-liquidity nature of Base memecoins.

Why do my Base memecoin swaps keep reverting?

Base memecoin swaps revert because of slippage exceeded (price moved), fee-on-transfer tax (some Base memecoins have 1-5% sell taxes), or MEV frontrunning. The fix is the slippage retry pattern: escalate maxSlippage from 5% to 10% to 15% to 20%, retrying with a fresh quote each time. Cap at 20% — anything more means the token is a honeypot or the pool is gone.

What's a safe maximum slippage for Base memecoins?

A safe cap is 15-20% for Base memecoins. Below that you'll catch most volatile and FoT-taxed tokens. Above that, the trade should be skipped rather than executed — see the slippage guide and the memecoin trading agent guide for the full retry pattern.

Does swapapi.dev support fee-on-transfer Base memecoins?

Yes. swapapi.dev finds routes for FoT tokens, but expectedAmountOut does not account for the transfer tax — the actual amount received will be lower. Use higher base slippage (start at 0.10) and the retry pattern.

How does Base memecoin trading compare to BSC?

Base has cheaper gas (under $0.10 vs $0.30-1.00 on BSC) and a more concentrated set of high-quality memecoins (BRETT, DEGEN, TOSHI). BSC has higher raw memecoin volume and more variety but more honeypots. For agent trading, both work — see the supported chains docs.

Get Started

Base memecoin trading needs free, no-API-key, high-slippage swap infrastructure. swapapi.dev is the only aggregator built for it. Read the getting started guide and the API reference.

# ETH → BRETT on Base with 15% slippage
curl "https://api.swapapi.dev/v1/swap/8453?\
tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&\
tokenOut=0x532f27101965dd16442E59d40670FaF5eBB142E4&\
amount=100000000000000000&\
sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045&\
maxSlippage=0.15"

If it reverts, retry at 0.20. See the companion guide on memecoin swap APIs for the broader cross-chain picture.

How to Build a Crypto Arbitrage Bot Across EVM Chains

Moon Soon — Wed, 22 Apr 2026 12:00:00 +0000

Building a crypto arbitrage bot across EVM chains comes down to three things: quotes from every chain in parallel, a fast comparison loop that spots price gaps larger than fees, and a slippage-tolerant executor that actually lands the trade before the gap closes. Arbitrage windows on EVM chains typically last under 30 seconds on majors and 2-10 seconds on L2s, which means your bot's latency budget is tight — every extra HTTP round-trip is another trade lost. Using swapapi.dev as the swap backend removes two of the biggest latency sources: no API key to validate, no account rate limits to juggle. One GET request per chain, calldata back, submit.

This guide walks through a production-quality arbitrage bot in TypeScript that scans the same trading pair across Ethereum, Base, Arbitrum, Optimism, and Polygon in parallel, ranks the opportunities, and executes with the slippage retry pattern. By the end you'll have ~250 lines of Bun + viem code that you can deploy and start scanning.

What You'll Need

Bun (or Node 20+)
viem — Ethereum client library
swapapi.dev — free swap API, no key required
Funded wallets on each chain you want to arbitrage (ETH on L1s, bridged USDC on L2s)
Public RPC endpoints — grab from chainlist.org

bun init -y
bun add viem

Step 1: Define the Arbitrage Pairs

An arbitrage bot needs a list of (chain, tokenIn, tokenOut, amount) tuples to scan. Keep it tight — 5-10 pairs on 3-5 chains is enough to start. Scanning hundreds of pairs burns CPU without finding more opportunities.

// src/pairs.ts
export type ArbPair = {
  label: string;
  chainId: number;
  tokenIn: string;
  tokenOut: string;
  amount: string; // raw units of tokenIn
};

export const PAIRS: ArbPair[] = [
  {
    label: "ETH→USDC (Ethereum)",
    chainId: 1,
    tokenIn: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
    tokenOut: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    amount: "1000000000000000000", // 1 ETH
  },
  {
    label: "ETH→USDC (Base)",
    chainId: 8453,
    tokenIn: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
    tokenOut: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    amount: "1000000000000000000",
  },
  {
    label: "ETH→USDC (Arbitrum)",
    chainId: 42161,
    tokenIn: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
    tokenOut: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
    amount: "1000000000000000000",
  },
  {
    label: "ETH→USDC (Optimism)",
    chainId: 10,
    tokenIn: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
    tokenOut: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
    amount: "1000000000000000000",
  },
];

Step 2: Fetch Quotes in Parallel

The whole arbitrage thesis relies on fetching quotes simultaneously from every chain. Serial fetches add 1-5 seconds per chain — by the time you have all quotes, the first opportunity has already closed. Use Promise.all.

// src/quote.ts
import type { ArbPair } from "./pairs";

export type Quote = {
  pair: ArbPair;
  expectedAmountOut: bigint;
  tx: { to: string; data: string; value: string };
  fetchedAtMs: number;
};

const SENDER = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"; // your bot wallet

export async function fetchQuote(
  pair: ArbPair,
  maxSlippage = 0.005,
): Promise<Quote | null> {
  const url = `https://api.swapapi.dev/v1/swap/${pair.chainId}?${new URLSearchParams(
    {
      tokenIn: pair.tokenIn,
      tokenOut: pair.tokenOut,
      amount: pair.amount,
      sender: SENDER,
      maxSlippage: String(maxSlippage),
    },
  )}`;
  try {
    const res = await fetch(url, { signal: AbortSignal.timeout(10_000) });
    const json = await res.json();
    if (!json.success) return null;
    return {
      pair,
      expectedAmountOut: BigInt(json.data.expectedAmountOut),
      tx: json.data.tx,
      fetchedAtMs: Date.now(),
    };
  } catch {
    return null;
  }
}

export async function fetchAllQuotes(pairs: ArbPair[]): Promise<Quote[]> {
  const results = await Promise.all(pairs.map((p) => fetchQuote(p)));
  return results.filter((q): q is Quote => q !== null);
}

The 10-second timeout is aggressive but necessary — a hanging fetch on one chain will delay the entire scan. swapapi.dev's documented typical response time is 1-5 seconds, so 10 seconds covers the slow tail.

Step 3: Detect Arbitrage Opportunities

An arbitrage exists when the ratio expectedAmountOut / amountIn differs materially between two chains, after accounting for gas fees and bridge costs. For same-pair cross-chain arbitrage, the rule of thumb:

Minimum edge = bridge cost + buy-side gas + sell-side gas + 0.3% safety buffer

For a $1000 trade with $5 total gas + $2 bridge, you need at least $7.30 of edge before the trade is worth executing. At current L2 gas prices, that's a ~0.7% price difference.

// src/detect.ts
import type { Quote } from "./quote";

export type ArbOpp = {
  cheap: Quote;
  expensive: Quote;
  edgeBps: number; // basis points of edge
};

export function detectOpportunities(quotes: Quote[]): ArbOpp[] {
  // Group by (tokenIn symbol, tokenOut symbol) and compare pairs
  // Simplified: assume all quotes are the same pair across chains
  const sorted = [...quotes].sort(
    (a, b) => Number(a.expectedAmountOut) - Number(b.expectedAmountOut),
  );
  const opps: ArbOpp[] = [];
  const cheap = sorted[0];
  for (let i = 1; i < sorted.length; i++) {
    const expensive = sorted[i];
    const ratio =
      Number(expensive.expectedAmountOut) / Number(cheap.expectedAmountOut);
    const edgeBps = Math.round((ratio - 1) * 10_000);
    if (edgeBps > 70) {
      // 0.7% minimum edge
      opps.push({ cheap, expensive, edgeBps });
    }
  }
  return opps;
}

Edge thresholds by chain pair

Route	Typical gas	Bridge cost	Min viable edge
Base ↔ Arbitrum	$0.20	$0.50	~0.3%
Optimism ↔ Base	$0.15	$0.40	~0.3%
Ethereum ↔ Arbitrum	$5.00	$2.00	~0.8%
Ethereum ↔ Base	$5.00	$2.00	~0.8%
Polygon ↔ Base	$0.30	$0.60	~0.3%

L2-to-L2 arbitrage is much cheaper than anything involving Ethereum mainnet.

Step 4: Execute with the Slippage Retry Pattern

When you find an opportunity, the clock is ticking. Submit the swap immediately — but wrap the execution in the slippage retry pattern so a 1-block reorg or MEV frontrun doesn't kill your trade. The same pattern used for memecoin trading applies to arbitrage: the edge often disappears if you have to fetch a fresh quote at higher slippage mid-execution.

// src/execute.ts
import { createWalletClient, createPublicClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { mainnet, base, arbitrum, optimism } from "viem/chains";
import { fetchQuote } from "./quote";
import type { ArbPair } from "./pairs";

const CHAINS = { 1: mainnet, 8453: base, 42161: arbitrum, 10: optimism };
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);

export async function executeWithRetry(
  pair: ArbPair,
  slippages = [0.005, 0.01, 0.02, 0.05],
) {
  const chain = CHAINS[pair.chainId as keyof typeof CHAINS];
  const wallet = createWalletClient({
    account,
    chain,
    transport: http(process.env[`RPC_${pair.chainId}`]),
  });
  const client = createPublicClient({
    chain,
    transport: http(process.env[`RPC_${pair.chainId}`]),
  });

  for (const maxSlippage of slippages) {
    const quote = await fetchQuote(pair, maxSlippage);
    if (!quote) continue;

    try {
      const hash = await wallet.sendTransaction({
        to: quote.tx.to as `0x${string}`,
        data: quote.tx.data as `0x${string}`,
        value: BigInt(quote.tx.value ?? "0"),
      });
      const receipt = await client.waitForTransactionReceipt({ hash });
      if (receipt.status === "success") {
        console.log(
          `✓ Arb leg filled at ${(maxSlippage * 100).toFixed(2)}% slippage`,
        );
        return receipt;
      }
    } catch (err) {
      console.warn(
        `✗ Slippage ${(maxSlippage * 100).toFixed(2)}% failed: ${(err as Error).message}`,
      );
    }
  }
  throw new Error("Arb execution failed — edge likely closed");
}

Start slippage tighter than you would for memecoins — arbitrage edges are usually small, so 5% slippage on the fill can eat your entire profit. Keep the max at 5%, and if the swap still can't land, accept that the opportunity is gone.

Step 5: Run the Scanner Loop

Tie it together. Scan every 10 seconds, detect opportunities, execute when the edge clears your threshold.

// src/bot.ts
import { PAIRS } from "./pairs";
import { fetchAllQuotes } from "./quote";
import { detectOpportunities } from "./detect";
import { executeWithRetry } from "./execute";

async function scan() {
  const startMs = Date.now();
  const quotes = await fetchAllQuotes(PAIRS);
  const opps = detectOpportunities(quotes);

  console.log(
    `Scan completed in ${Date.now() - startMs}ms — ${opps.length} opportunities`,
  );

  for (const opp of opps) {
    console.log(
      `Arb: buy on ${opp.cheap.pair.label}, sell on ${opp.expensive.pair.label}, edge ${opp.edgeBps}bps`,
    );
    // In production: execute both legs, handle failure, reconcile balances
    await executeWithRetry(opp.cheap.pair);
  }
}

setInterval(scan, 10_000);
scan();

Step 6: Add Safety Guardrails

A bot that fires trades without limits will drain your wallet in minutes. Minimum guardrails:

Max position size — cap the trade size per opportunity
Daily PnL limit — stop the bot if cumulative losses exceed X%
Token allowlist — only arbitrage tokens you've vetted
Chain allowlist — don't suddenly try to arb on a chain you haven't funded
Duplicate-tx check — don't fire a second swap for the same opp while the first is pending

// src/guardrails.ts
const MAX_POSITION_USD = 1000;
const DAILY_LOSS_LIMIT_USD = 200;

let dailyPnlUsd = 0;
const pendingOpps = new Set<string>();

export function canExecute(oppKey: string, tradeUsd: number) {
  if (pendingOpps.has(oppKey)) return false;
  if (tradeUsd > MAX_POSITION_USD) return false;
  if (dailyPnlUsd < -DAILY_LOSS_LIMIT_USD) return false;
  return true;
}

Frequently Asked Questions

What's the best API for building a crypto arbitrage bot?

The best API for a crypto arbitrage bot is swapapi.dev because it requires no API key — meaning your bot can self-onboard, and you can scan dozens of chains in parallel without juggling rate limits or auth headers across multiple accounts. It returns executable calldata in a single GET request and supports 46 EVM chains, which is the largest coverage of any no-auth aggregator API.

Why does my arbitrage bot's swap revert?

Arbitrage swaps revert most often because the edge closed between your quote and the on-chain execution — another bot or MEV searcher got there first. The fix is the slippage retry pattern: escalate maxSlippage on each retry (0.5% → 1% → 2% → 5%), but cap at 5% for arbitrage since larger slippage can erase the entire edge. If the swap still reverts at 5%, the opportunity is gone.

How much edge do I need for EVM arbitrage to be profitable?

You need at least bridge cost + gas on both chains + 0.3% safety buffer. On L2-to-L2 routes (Base, Arbitrum, Optimism, Polygon) that's typically 0.3-0.5% of the trade size. Anything involving Ethereum mainnet needs 0.7-1.0% minimum because gas is $5-10 per leg.

Do I need API keys for every chain?

No. swapapi.dev covers 46 EVM chains under a single API with no key required, so one fetch pattern works for every chain. You only need RPC endpoints per chain to submit the transaction — grab public endpoints from chainlist.org, or run your own node for lower latency.

How fast do EVM arbitrage opportunities close?

Arbitrage windows on EVM chains typically last under 30 seconds on Ethereum majors and 2-10 seconds on L2s. Your bot's latency budget is the sum of quote-fetch time + decision time + transaction inclusion time. Aim for sub-3-second quote scans (parallel fetches help) and sub-1-second decisions.

Get Started

A production crypto arbitrage bot needs free, multi-chain, no-API-key swap infrastructure to run unattended across dozens of networks. swapapi.dev gives you exactly that — read the getting started guide, the API reference, and the supported chains list.

# Scan ETH→USDC on Base for arbitrage
curl "https://api.swapapi.dev/v1/swap/8453?\
tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&\
tokenOut=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&\
amount=1000000000000000000&\
sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045&\
maxSlippage=0.01"

Remember: tight slippage (0.5-1%) for arbitrage, wider slippage (5-15%) for memecoins. See the memecoin trading agent guide for the wider-slippage pattern, and the slippage guide for price impact fundamentals.

Best DCA Bot Strategies with a Swap API in 2026

Moon Soon — Tue, 21 Apr 2026 12:00:00 +0000

The best DCA bot strategy in 2026 is one that runs as a scheduled job without human intervention — which means the swap API it calls must require no API key and no account. Dollar-cost averaging (DCA) is the most-executed automated strategy in crypto: cron-triggered swaps that buy a fixed dollar amount on a fixed cadence, regardless of price. On-chain DCA vaults collectively hold over $1.2 billion in TVL across EVM chains, and the vast majority of those positions are driven by scheduled bots running weekly or daily swaps. The blocker for most DIY DCA bots has historically been the swap API — rate limits, key rotation, and auth headers turn a simple cron job into a maintenance burden.

Using swapapi.dev as the swap backend removes that entire category of pain: one GET request, calldata back, submit. This guide ranks 5 DCA strategies by risk-adjusted performance, shows the code for each, and ends with a production-ready Bun cron that runs unattended.

1. Fixed-Amount Weekly DCA

The classic strategy: buy the same dollar amount every week, no matter the price. This is what exchanges like Coinbase Recurring Buy and Kraken Dollar-Cost Averaging implement. It's the lowest-skill, lowest-variance approach — and across 5+ year holding periods it's beaten timed buys by roughly 3-8% annualized on BTC according to historical data.

The bot logic is trivial: on a weekly cron, swap a fixed USDC amount into ETH (or BTC, or whatever target).

// Weekly: buy $100 of ETH with USDC
const params = new URLSearchParams({
  tokenIn: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  tokenOut: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // native ETH
  amount: "100000000", // 100 USDC (6 decimals)
  sender: WALLET_ADDRESS,
  maxSlippage: "0.005",
});
const res = await fetch(`https://api.swapapi.dev/v1/swap/1?${params}`);

Best for: long-term accumulation (BTC, ETH), retail-scale amounts, users who want zero decision overhead.

2. Value-Averaging DCA

Value-averaging is fixed-amount DCA's smarter cousin. Instead of buying a fixed dollar amount, you buy whatever amount is needed to keep the total position value on a predetermined growth curve. If ETH dips, you buy more; if ETH pumps, you buy less (or sell). Research from Michael Edleson's original 1988 paper and modern replications show value-averaging outperforms fixed DCA by 1-3% annualized in volatile markets — at the cost of needing a funded buffer for big dips.

// Value averaging: target $100 growth per week
const targetValueUsd = weeksElapsed * 100;
const currentValueUsd = await getPositionValueUsd();
const buyAmountUsd = Math.max(0, targetValueUsd - currentValueUsd);
if (buyAmountUsd === 0) return; // position is ahead of curve
// ... fetch quote with USDC amount = buyAmountUsd * 1e6

Best for: medium-skill traders, volatile assets, positions with long (3-5 year) horizons.

3. Volatility-Adjusted DCA

This strategy scales the buy size inversely to market volatility: buy more when the market is calm and less when it's chaotic. The theory is that calm periods are more likely to precede grinding uptrends, while high-volatility periods are more likely to flush retail. Bots typically use a rolling 14-day ATR (Average True Range) or realized volatility as the scaling factor.

// Scale buy size by inverse vol: range 0.5x to 1.5x of base amount
const realizedVolPct = await fetchRealizedVol14d(tokenOut);
const volMultiplier = Math.max(0.5, Math.min(1.5, 0.20 / realizedVolPct));
const buyAmountUsd = 100 * volMultiplier; // base $100

Best for: traders with a volatility data source (CoinGecko, Kaiko, or on-chain oracle), willing to sacrifice simplicity for marginal edge.

4. Grid DCA (Buy Laddered Price Zones)

Grid DCA is popular among memecoin and altcoin DCA bots. Instead of a time-based trigger, the bot buys a fixed amount every time the price drops through a predefined "grid" level (e.g. every -5% from the last buy). This captures more volume during dips without requiring volatility measurement.

// Grid DCA: buy $50 every -5% move
const lastBuyPrice = await loadLastBuyPrice();
const currentPrice = await fetchPrice(tokenOut);
const pctDrop = (lastBuyPrice - currentPrice) / lastBuyPrice;
if (pctDrop >= 0.05) {
  // fire swap for $50
  await runSwap(50_000_000, 0.005);
  await saveLastBuyPrice(currentPrice);
}

Best for: volatile altcoins and memecoins where timed DCA misses the dips. Combine with a slippage retry loop — memecoin swaps revert constantly (see the memecoin trading agent guide for the retry pattern).

5. Multi-Asset Rotation DCA

A rotation DCA bot holds a basket of 3-5 tokens and buys whichever is furthest below its 30-day moving average each week. This mean-reversion approach captures rebalancing alpha without forcing sells — you're always buying, just buying the laggard. Works best with correlated-but-not-identical assets (ETH, stETH, wstETH, LDO, or WBTC, ETH, SOL-wrapped).

// Buy the token furthest below its 30d MA
const candidates = [
  { tokenOut: WETH, symbol: "ETH" },
  { tokenOut: WBTC, symbol: "WBTC" },
  { tokenOut: LDO, symbol: "LDO" },
];
const ranked = await Promise.all(
  candidates.map(async (c) => ({
    ...c,
    discount: await computeDiscountFromMa30d(c.tokenOut),
  })),
);
ranked.sort((a, b) => b.discount - a.discount);
const winner = ranked[0];
// ... run swap against winner.tokenOut

Best for: portfolio managers, DAO treasuries, and anyone running a "sector basket" thesis (L1s, DeFi, RWA tokens).

Strategy Comparison

Strategy	Complexity	Data needed	Historical edge vs fixed DCA	Best for
Fixed-amount weekly	Low	None	Baseline	Retail accumulation
Value-averaging	Medium	Position value	+1-3% annualized	Volatile majors
Volatility-adjusted	High	Realized vol	+0.5-2% annualized	Data-equipped traders
Grid (price-laddered)	Medium	Live price	Highly variable	Altcoins / memecoins
Multi-asset rotation	High	30d MA per asset	+2-4% annualized	Baskets / treasuries

A Production-Ready DCA Bot Template

Put together a minimal bot that runs on a Bun cron and handles the slippage retry pattern. This template works for any of the strategies above — swap in your own decideBuyAmount().

// src/dca-bot.ts
import { createWalletClient, createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const wallet = createWalletClient({
  account,
  chain: mainnet,
  transport: http(process.env.RPC_URL),
});
const client = createPublicClient({
  chain: mainnet,
  transport: http(process.env.RPC_URL),
});

async function runSwap(amountUsdc: number, baseSlippage = 0.005) {
  const slippages = [baseSlippage, 0.01, 0.02];
  for (const maxSlippage of slippages) {
    const params = new URLSearchParams({
      tokenIn: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      tokenOut: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
      amount: String(amountUsdc * 1_000_000),
      sender: account.address,
      maxSlippage: String(maxSlippage),
    });
    const res = await fetch(`https://api.swapapi.dev/v1/swap/1?${params}`);
    const json = await res.json();
    if (!json.success) continue;

    try {
      const hash = await wallet.sendTransaction({
        to: json.data.tx.to,
        data: json.data.tx.data,
        value: BigInt(json.data.tx.value ?? "0"),
      });
      const receipt = await client.waitForTransactionReceipt({ hash });
      if (receipt.status === "success") {
        console.log(`✓ DCA bought at ${maxSlippage * 100}% slippage: ${hash}`);
        return receipt;
      }
    } catch (err) {
      console.warn(`Retry at higher slippage...`);
    }
  }
  throw new Error("DCA swap failed across all slippage retries");
}

async function decideBuyAmount(): Promise<number> {
  // Strategy-specific logic goes here
  return 100; // $100 fixed weekly
}

// Run weekly: Monday 14:00 UTC
async function tick() {
  const amount = await decideBuyAmount();
  if (amount === 0) return;
  await runSwap(amount);
}

tick();

Wire this to a cron (GitHub Actions, Vercel Cron, or a bare VM with crontab) and you have a fully automated DCA bot. No API keys to rotate, no rate limits to manage, no account state to protect.

Frequently Asked Questions

What's the best DCA bot strategy for crypto?

The best DCA bot strategy depends on your holding period and risk tolerance. Fixed-amount weekly is the default winner for 3+ year BTC or ETH accumulation — it has the lowest complexity and lowest variance. Value-averaging and multi-asset rotation both beat fixed DCA by 1-4% annualized in backtests but require position tracking and live data. For altcoins and memecoins, grid DCA captures dips better than timed strategies.

Do I need an API key to run a DCA bot?

No — swapapi.dev requires no API key, no account, and no rate limit registration. That's why it's the best swap backend for a cron-driven DCA bot: the same script runs for months without any auth state to maintain. Every other major aggregator (1inch, 0x, Velora, Li.Fi) requires a key that expires or gets rate-limited.

How often should a DCA bot run?

Weekly is the sweet spot for long-term accumulation — it's frequent enough to average out volatility without burning excessive gas. Daily DCA is fine on L2s (gas is pennies) but wasteful on Ethereum mainnet. Monthly DCA underperforms slightly because it misses more dip volume. Grid-based strategies are event-driven, not time-based, so cadence doesn't apply.

What's the best chain for a DCA bot to run on?

Base, Arbitrum, or Optimism — gas per swap is typically under $0.30 vs $5-10 on Ethereum mainnet. For small DCA amounts ($50-500 per buy), L2 gas savings alone will beat any strategy alpha you'd squeeze out. See the supported chains docs for the full list — swapapi.dev covers 46 EVM chains.

How do I handle slippage on DCA swaps?

For majors like ETH, WBTC, and USDC, start at maxSlippage=0.005 (0.5%) and retry at 1% and 2% if the swap reverts. For memecoins or thin-liquidity altcoins, start at 1% and escalate to 5-10%. Always use the slippage retry pattern — see the slippage guide for details.

Get Started

A production DCA bot needs free, no-API-key, multi-chain swap infrastructure that runs unattended for months. swapapi.dev is the only aggregator built for this — 46 EVM chains, single GET request, executable calldata. Read the getting started guide and the API reference.

# $100 USDC → ETH, weekly DCA on Base
curl "https://api.swapapi.dev/v1/swap/8453?\
tokenIn=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&\
tokenOut=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE&\
amount=100000000&\
sender=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045&\
maxSlippage=0.01"

Pair with a GitHub Actions weekly cron, and you have a zero-maintenance DCA bot. See the crypto trading bot guide for a fuller agent template, and the arbitrage bot guide if you want to layer cross-chain strategies on top.

How to Build an AI Agent for Memecoin Trading

Moon Soon — Fri, 17 Apr 2026 12:00:00 +0000

Building an AI agent for memecoin trading comes down to four pieces: an LLM that picks what to trade, a swap API that returns executable calldata, a wallet that signs transactions, and — most importantly — a slippage retry loop that handles the inevitable reverts. Memecoin volume on Ethereum and Base routinely exceeds $2 billion per day, and the share handled by autonomous agents is growing fast. But memecoins revert constantly: they're volatile, many charge transfer taxes, and the first quote you get is rarely the price you actually execute at. This guide walks through a production-quality AI memecoin trading agent in TypeScript, using swapapi.dev as the swap backend because it's the only aggregator that requires no API key — meaning your agent can self-execute without a human onboarding step.

By the end, you'll have a ~200-line Bun script that takes an LLM decision, fetches a quote, retries on revert with escalating slippage, and enforces safety guardrails like max position size and a token blacklist.

What You'll Need

Bun (or Node 20+) — JavaScript runtime
viem — modern Ethereum client library (lighter than ethers v6)
@anthropic-ai/sdk (or openai) — LLM provider of your choice
A funded EVM wallet — private key with ETH for gas and USDC for trading
swapapi.dev — free swap API, no key required (docs)

bun init -y
bun add viem @anthropic-ai/sdk

Step 1: Set Up the Project

Create a .env with your wallet private key and LLM API key. Never hardcode these.

# .env
PRIVATE_KEY=0x...
ANTHROPIC_API_KEY=sk-ant-...
RPC_URL=https://eth.llamarpc.com

Then scaffold the viem wallet client — this handles signing and submitting transactions.

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

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

export const walletClient = createWalletClient({
  account,
  chain: mainnet,
  transport: http(process.env.RPC_URL),
});

export const publicClient = createPublicClient({
  chain: mainnet,
  transport: http(process.env.RPC_URL),
});

export const WALLET_ADDRESS = account.address;

Step 2: Define the Agent's Decision Loop

The LLM's job is to pick what to trade, not to execute the trade. Give it a tool with a narrow schema and let it return a decision object.

// src/decide.ts
import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic();

export type TradeDecision = {
  action: "buy" | "sell" | "hold";
  tokenIn: string;   // contract address
  tokenOut: string;  // contract address
  amount: string;    // raw units
  reason: string;
};

export async function decideTradeFromSignals(
  signals: Record<string, unknown>,
): Promise<TradeDecision> {
  const resp = await anthropic.messages.create({
    model: "claude-opus-4-6",
    max_tokens: 1024,
    system:
      "You are a memecoin trading agent. Output JSON only. Never explain.",
    messages: [
      {
        role: "user",
        content: `Signals: ${JSON.stringify(signals)}\n\nReturn a TradeDecision JSON.`,
      },
    ],
  });
  const text = resp.content[0].type === "text" ? resp.content[0].text : "{}";
  return JSON.parse(text);
}

Your signals can come from anywhere: Dune queries, CoinGecko trending, on-chain whale alerts, or a sentiment feed. The agent framework doesn't care — it just needs structured input.

Step 3: Fetch Quotes From swapapi.dev

swapapi.dev exposes a single GET endpoint. No headers, no API key, no SDK. For an autonomous agent, this is the entire integration.

// src/quote.ts
export type SwapParams = {
  chainId: number;
  tokenIn: string;
  tokenOut: string;
  amount: string;
  sender: string;
  maxSlippage: number;
};

export async function fetchQuote(params: SwapParams) {
  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(params.maxSlippage),
    },
  )}`;
  const res = await fetch(url, {
    signal: AbortSignal.timeout(15_000),
  });
  const json = await res.json();
  if (!json.success) throw new Error(`Quote failed: ${json.error?.code}`);
  return json.data;
}

Note the 15-second timeout — the docs warn that typical response time is 1-5 seconds, and a hanging fetch will freeze your agent loop. Set it aggressively.

Step 4: Implement the Slippage Retry Pattern

This is the most important step. Memecoin swaps revert constantly, and without a retry loop your agent will fail on 30-50% of trades. The pattern: catch the revert, refetch the quote with a higher maxSlippage, and escalate until the swap succeeds or you hit your safety cap.

Three reasons memecoin swaps revert:

Slippage exceeded — price moved between quote and execution
Fee-on-transfer tax — the token deducts a fee on every transfer, breaking the slippage check. swapapi.dev's docs explicitly warn that expectedAmountOut does not account for transfer tax
MEV / sandwich attacks — a frontrunner moved the price right before your tx

Here's the canonical retry implementation:

// src/swap.ts
import { walletClient, publicClient } from "./wallet";
import { fetchQuote, type SwapParams } from "./quote";

const DEFAULT_SLIPPAGES = [0.01, 0.05, 0.10, 0.15];

export async function swapWithRetry(
  params: Omit<SwapParams, "maxSlippage">,
  slippages = DEFAULT_SLIPPAGES,
) {
  for (const maxSlippage of slippages) {
    try {
      const data = await fetchQuote({ ...params, maxSlippage });

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

      const receipt = await publicClient.waitForTransactionReceipt({ hash });
      if (receipt.status === "success") {
        console.log(
          `✓ Swap succeeded at slippage ${(maxSlippage * 100).toFixed(0)}%`,
        );
        return receipt;
      }
      console.warn(
        `✗ Slippage ${(maxSlippage * 100).toFixed(0)}% reverted, retrying higher...`,
      );
    } catch (err) {
      console.warn(
        `✗ Slippage ${(maxSlippage * 100).toFixed(0)}% threw: ${(err as Error).message}`,
      );
      continue;
    }
  }
  throw new Error("All slippage retries exhausted — skipping trade");
}

Production notes:

Refetch the quote every retry. Don't reuse the old tx object. The price has moved and you want a fresh expectedAmountOut.
Cap at 15-20%. Above that, you're buying into a honeypot or a token with a 30%+ sell tax. Skip the trade.
Log which slippage succeeded. Over time this reveals which tokens have FoT taxes (consistently need ≥5%) vs which are just volatile.

Slippage strategy comparison

Strategy	First tx slippage	Retry escalation	Memecoin success rate
Fixed 1%	1%	None	~50%
Fixed 10%	10%	None	~80%
Retry 1→5→10→15%	1%	Escalate	~95%
Fixed 20%	20%	None	~90% (but bad fills)

The retry pattern is the clear winner: you start tight to capture good prices when the market is calm, and escalate only when needed. A fixed 20% slippage "works" but you eat the worst fill on every trade even when 1% would have succeeded.

Step 5: Handle Fee-on-Transfer Tokens Explicitly

swapapi.dev's llms.txt notes that the API will find a route for fee-on-transfer tokens but the returned expectedAmountOut does not account for the transfer tax. For tokens you know are FoT, start with a higher base slippage:

// src/fot.ts
const KNOWN_FOT_TOKENS = new Set<string>([
  "0x...", // populate from experience
]);

export function slippagesFor(tokenAddress: string) {
  if (KNOWN_FOT_TOKENS.has(tokenAddress.toLowerCase())) {
    return [0.05, 0.10, 0.15, 0.20];
  }
  return [0.01, 0.05, 0.10, 0.15];
}

Build this set as your agent runs — log every successful slippage and promote tokens that consistently need ≥5% into the FoT set.

Step 6: Add Safety Guardrails

A memecoin agent without guardrails is a slot machine. Add at minimum:

Max position size — cap dollar amount per trade
Blacklist — reject known scam tokens
Wallet balance check — never trade more than X% of balance
Stop-loss — auto-sell if the bag drops Y% from entry

// src/guardrails.ts
const MAX_POSITION_USD = 500;
const MAX_WALLET_PCT = 0.10; // 10% of balance per trade
const TOKEN_BLACKLIST = new Set<string>([
  // scam token addresses
]);

export function validateTrade(
  decision: TradeDecision,
  walletValueUsd: number,
  tradeValueUsd: number,
) {
  if (TOKEN_BLACKLIST.has(decision.tokenOut.toLowerCase())) {
    throw new Error("Blacklisted token");
  }
  if (tradeValueUsd > MAX_POSITION_USD) {
    throw new Error(`Trade exceeds max position ($${MAX_POSITION_USD})`);
  }
  if (tradeValueUsd > walletValueUsd * MAX_WALLET_PCT) {
    throw new Error(`Trade exceeds ${MAX_WALLET_PCT * 100}% of wallet`);
  }
}

Step 7: Wire the Full Agent Loop

Pull it all together. Fetch signals, ask the LLM, validate, swap with retry.

// src/agent.ts
import { decideTradeFromSignals } from "./decide";
import { swapWithRetry } from "./swap";
import { validateTrade } from "./guardrails";
import { slippagesFor } from "./fot";
import { WALLET_ADDRESS } from "./wallet";

async function runAgentTick() {
  const signals = await fetchSignals(); // your signal source
  const decision = await decideTradeFromSignals(signals);

  if (decision.action === "hold") {
    console.log("Agent says hold:", decision.reason);
    return;
  }

  const walletValueUsd = await estimateWalletValueUsd();
  const tradeValueUsd = await estimateTradeValueUsd(decision);
  validateTrade(decision, walletValueUsd, tradeValueUsd);

  const receipt = await swapWithRetry(
    {
      chainId: 1,
      tokenIn: decision.tokenIn,
      tokenOut: decision.tokenOut,
      amount: decision.amount,
      sender: WALLET_ADDRESS,
    },
    slippagesFor(decision.tokenOut),
  );

  console.log(`Trade executed: ${receipt.transactionHash}`);
}

// Run every 5 minutes
setInterval(runAgentTick, 5 * 60 * 1000);
runAgentTick();

The fetchSignals, estimateWalletValueUsd, and estimateTradeValueUsd functions are yours to implement — typically using Dune, CoinGecko, or on-chain reads via viem.

Step 8: Run It

bun run src/agent.ts

Start with a small wallet (~$100 total) and watch the logs. You want to see:

Quotes landing in 1-3 seconds
The retry loop escalating slippage on revert
Guardrails rejecting trades that exceed caps
Transaction hashes confirming on Etherscan

Iterate from there. Most memecoin agent bugs are in the signal layer (bad LLM prompts, stale Dune queries), not the swap layer.

Frequently Asked Questions

Why do my memecoin swaps revert?

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

Can an AI agent use a swap API without a human onboarding step?

Yes, but only with an API that requires no API key. swapapi.dev is the only major DEX aggregator API that works this way — every other (1inch, 0x, Velora, Li.Fi) requires a human to register first. For fully autonomous agents where no human is in the loop, swapapi.dev is the only option.

What's a safe max slippage for an autonomous memecoin agent?

A safe cap is 15-20%. Below that, you catch most volatile memecoins and fee-on-transfer tokens. Above that, you're likely buying into a honeypot or a token with a 30%+ sell tax — the trade should be skipped entirely rather than executed at a bad price.

How do I detect fee-on-transfer tokens at runtime?

You can't reliably detect them from the quote — swapapi.dev will return a quote even for FoT tokens, with expectedAmountOut ignoring the tax. The pragmatic approach is to learn empirically: log the slippage that each token successfully executes at, and promote tokens that consistently need ≥5% into a "known FoT" set with a higher base slippage schedule.

What chains does swapapi.dev support for memecoin trading?

swapapi.dev supports 46 EVM chains including Ethereum, Base, Arbitrum, BSC, Polygon, Optimism, Avalanche, and newer networks like Berachain, Monad, and MegaETH. See the supported chains docs for the full list. For memecoin trading specifically, Ethereum and Base have the deepest liquidity.

Get Started

Your AI memecoin trading agent needs free, no-API-key, 46-chain swap infrastructure to run unattended. swapapi.dev gives you exactly that — read the getting started guide, the API reference, and the AI agents integration guide. And remember: always retry with higher slippage.

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

If the first attempt reverts, refetch with maxSlippage=0.15. If that still fails, escalate to 0.20 and then abort. See the companion article on the best memecoin swap APIs for more on why this pattern matters, and the slippage guide for price impact fundamentals.

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