Integrate Trading

Let users swap tokens on Base with executable routes from the 0x Swap API.

Add token swaps to your app with the 0x Swap API. 0x searches liquidity across decentralized exchanges and market makers, then returns a transaction that the user’s wallet can simulate, sign, and submit on Base.

Demo

The demo above is mock only. If you want to see onchain demos on Vibenet, head to Base chain demos.

Route a Swap with 0x

Use the AllowanceHolder flow for a B20 or ERC-20 swap:

1. Request an indicative /price while the user edits the trade.
2. Request a firm /quote when the user is ready to review and sign.
3. If issues.allowance is present, approve only the returned spender for the sell amount.
4. Fetch a fresh quote, simulate its transaction, submit it, and wait for confirmation.

Never approve the 0x Settler contract. Approve only the AllowanceHolder or Permit2 address returned by the API in issues.allowance.spender or allowanceTarget.

Install viem@2.55.19, create Base publicClient and walletClient instances in clients.ts, and keep ZERO_EX_API_KEY on your server. This example sells 100 USDC for WETH on Base mainnet.

The verified sample uses a server-side wallet only to keep the example runnable. In a user-facing app, request the quote from your backend, return the reviewed transaction fields to the frontend, and submit them with the user’s connected wallet.

This snippet is illustrative. It shows the shape of a routed trading integration on Base, not production-ready code. Follow the 0x Swap API documentation for current API behavior, supported liquidity sources, fees, and contract details.

trade-0x.ts

import { publicClient, walletClient } from './clients.js';
import { formatUnits, parseAbi, parseUnits, type Address, type Hex } from 'viem';
import { required } from '../shared/env.js';

const USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
const WETH = '0x4200000000000000000000000000000000000006';
const sellAmount = parseUnits('100', 6);
const user = walletClient.account.address;

type Quote = {
  liquidityAvailable: boolean;
  buyAmount: string;
  minBuyAmount: string;
  issues: {
    allowance: null | { spender: Address };
    balance: null | { actual: string; expected: string };
    simulationIncomplete: boolean;
  };
  transaction?: { to: Address; data: Hex; value: string | null };
};

async function getQuote(): Promise<Quote> {
  const params = new URLSearchParams({
    chainId: '8453', sellToken: USDC, buyToken: WETH,
    sellAmount: sellAmount.toString(), taker: user, slippageBps: '50',
  });
  const response = await fetch(
    `https://api.0x.org/swap/allowance-holder/quote?${params}`,
    { headers: { '0x-api-key': required('ZERO_EX_API_KEY'), '0x-version': 'v2' } },
  );
  if (!response.ok) throw new Error(`0x quote failed: ${response.status} ${await response.text()}`);
  return (await response.json()) as Quote;
}

let quote = await getQuote();
if (!quote.liquidityAvailable) throw new Error('No route is currently available');
if (quote.issues.balance) throw new Error('Insufficient USDC balance');

if (quote.issues.allowance) {
  const approval = await publicClient.simulateContract({
    account: user, address: USDC,
    abi: parseAbi(['function approve(address,uint256) returns (bool)']),
    functionName: 'approve', args: [quote.issues.allowance.spender, sellAmount],
  });
  await publicClient.waitForTransactionReceipt({
    hash: await walletClient.writeContract(approval.request),
  });
  quote = await getQuote();
}

if (quote.issues.allowance) throw new Error('Token allowance is still insufficient');
if (quote.issues.simulationIncomplete) throw new Error('0x could not complete its simulation');
if (!quote.transaction) throw new Error('Quote did not include transaction data');

const transaction = {
  account: walletClient.account,
  to: quote.transaction.to,
  data: quote.transaction.data,
  value: BigInt(quote.transaction.value ?? '0'),
};
await publicClient.call({ ...transaction, account: user });
const hash = await walletClient.sendTransaction(transaction);
await publicClient.waitForTransactionReceipt({ hash });

console.log(`Swap confirmed: ${hash}`);
console.log(`Minimum WETH output: ${formatUnits(BigInt(quote.minBuyAmount), 18)} WETH`);

0x Documentation

Swap API Quickstart

Follow the full price, allowance, quote, and submission flow.

AllowanceHolder Quote

Review every request parameter and response field.

Token Allowances

Approve the correct spender and avoid unsafe approvals.

See Also

Integrate Lending

Let users supply USDC to a money market.

Integrate Borrowing

Open a collateralized loan against WETH.

Integrate an Earn Product

Route deposits into yield-bearing vaults.