Best DCA Bot Strategies with a Swap API in 2026

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.