TL;DR
The Across Swap API returns ready-to-execute calldata from
/swap/approval, not a quote you still have to assemble into a transaction.One call covers four routing paths: direct bridge, swap-then-bridge, bridge-then-swap, and full swap-bridge-swap. The API picks the path from the tokens you pass.
It also selects the settlement mechanism for you: intents for ~2-second fills, Circle's CCTP V2 for USDC transfers up to
$10M, LayerZero's OFT for native USDT0.Lens and Infinex run it in production today, and Across V4 means new chains reach every integrator the moment Across adds them.
Ask a team that built crosschain swaps from scratch what it cost them. The answer is almost never the bridge. It is the glue: stitching a bridge to a DEX aggregator to a quoting endpoint to a pile of approval logic, then keeping that integration alive as every dependency under it shifts. The swap is five lines. The glue is five thousand, and it breaks. The Across Swap API exists to delete the glue.
The API Returns a Transaction, Not a Number
Most APIs in this category hand you a quote. A number tells you what the swap would cost, and you assemble the transaction yourself: build the calldata, sequence the approvals, handle the edge cases, and hope the quote still holds when the user signs.
The Across Swap API returns the contract call. One response from /swap/approval gives you the calldata, the approval transactions if any are needed, and the gas estimate. Your app sends it. That is the integration. Across's own docs put it in a table: the Swap API outputs "executable calldata for the transaction," where the older suggested-fees API returns "quote data only (requires dev assembly)." The gap between those two rows is the gap between an afternoon and a sprint of edge-case handling.
One Call Covers Four Routing Paths
A crosschain swap takes a different shape depending on what the user holds and what they want. The Swap API reads the shape from your token inputs and routes accordingly. You do not branch on the cases.
Same bridgeable token on both ends, like USDC on Arbitrum to USDC on Optimism: it bridges directly. Arbitrary token in, canonical token out: it swaps on the origin, then bridges. Canonical in, arbitrary out: it bridges, then swaps on the destination. Arbitrary on both ends: it runs the full swap-bridge-swap, converting to a canonical token on the origin, bridging it, swapping again on arrival. Across labels these bridgeableToBridgeable, anyToBridgeable, bridgeableToAny, and anyToAny, and the response tells you which one fired.
You write the same call for a USDC-to-USDC bridge and a long-tail-token swap across chains. The branching lives in Across.
Settlement Is the Second Thing You Stop Thinking About
Under the routing, Across runs three settlement mechanisms. Intents fill through the relayer network in about 2 seconds. Circle's CCTP V2 moves native USDC in amounts up to $10M without relayer capital. LayerZero's OFT standard handles native USDT0 with mint-and-burn, no wrapped tokens. The Swap API selects among them by token, amount, and route.
You do not decide whether a transfer should use intents or CCTP. The same integration code routes a $500 swap and a $5M USDC transfer through whichever mechanism fits.
Already in Production, and the Chain List Grows on Its Own
Lens, web3's social L2, uses the Swap API to route crosschain bridging when users claim rewards or move tokens between chains, all behind a single transaction call. Infinex, a non-custodial platform with CEX-like trading across 13+ chains, built its unified swap-and-bridge flow on it. Two products that share almost nothing share the same API underneath.
Across V4 made chain deployment faster, so when Across adds a chain, every Swap API integrator gets it without touching their code. You integrate once; your supported-chain list expands without you.
Intents are verified by UMA, and in five years of production the protocol has not been exploited. For an integrator that record is part of the API surface: the dependency you ship on has never broken.
Crosschain swaps were never hard because the math was hard. They were hard because the integration was a maintenance burden wearing a feature's clothes. The Swap API makes it one call, so you build the product instead of the plumbing.