A swap route with the highest quoted token output is not always the cheapest route to execute.
The transaction may consume more gas, depend on shallow liquidity, cross several pools or expire before the wallet can sign it. A quote that looks attractive in a dashboard can become worse than a simpler route by the time the transaction reaches the blockchain.
This is why production crypto applications need more than a token-price endpoint. They need a DEX swap routing API that can compare liquidity sources, calculate executable routes, estimate gas and return transaction data ready for signing.
JarvisClaw provides access to DEX trading through a common Marketplace API. Its DEX service uses 0x infrastructure to route across more than 100 decentralized exchanges and supports indicative prices, executable quotes, Permit2 and gasless execution.
The practical objective is not simply to find a market price. It is to determine how much the taker is likely to receive after route selection, price impact, gas and other execution costs are considered.
What a DEX Swap Routing API Does
A decentralized exchange does not maintain one universal order book. Liquidity is distributed across automated market makers, professional market makers and different versions of the same protocol.
The best route for a USDC-to-WETH trade may use one pool when the trade is small and split the order across several sources when the amount becomes larger.
A routing API evaluates the available liquidity and returns a path designed to improve execution. The response may include:
- Expected buy amount
- Sell amount
- Liquidity sources
- Proportion assigned to each source
- Estimated gas
- Current gas price
- Transaction destination
- Executable calldata
- Permit2 signing data
- Quote expiration time
JarvisClaw separates indicative pricing from executable quotes. The /price endpoint is intended for display and pre-trade checks, while /quote returns transaction calldata and Permit2 data for signing.
That separation is important. A price is an estimate; a quote is a time-sensitive execution package.
Why the Highest Output Is Not Always the Best Route
Imagine two routes for the same trade:
| Route | Expected Output | Estimated Gas | Price Impact | Practical Result |
|---|---|---|---|---|
| Route A | 0.3849 WETH | High | 0.30% | Better output before gas |
| Route B | 0.3845 WETH | Low | 0.22% | May cost less overall |
| Route C | 0.3851 WETH | Medium | 0.85% | Attractive quote but higher execution risk |
Route A appears better if the application compares only buyAmount. Route B may produce more net value after gas. Route C may depend on thin liquidity and become invalid quickly.
A useful comparison should calculate:
Estimated Net Value =
Expected Output Value
− Network Gas
− API Cost
− Protocol or Liquidity Fees
− Expected Price ImpactSlippage should be treated as a risk allowance rather than a guaranteed charge. It defines how far execution may move before the transaction reverts.
For small trades, gas and fixed API charges can represent a meaningful percentage of the order. For large trades, liquidity depth and price impact usually become more important.
Price Requests vs Firm Quotes
JarvisClaw’s DEX base path is:
https://api.jarvisclaw.ai/v1/marketplace/dexAn indicative price can be requested from:
GET /priceRequired inputs include:
sellTokenbuyTokensellAmountchainId
The taker wallet is optional for a price request but can improve routing accuracy.
A simplified request for USDC to WETH on Base looks like this:
curl "https://api.jarvisclaw.ai/v1/marketplace/dex/price?\
chainId=8453&\
sellToken=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&\
buyToken=0x4200000000000000000000000000000000000006&\
sellAmount=1000000000" \
-H "Authorization: Bearer sk-your-api-key"The documentation’s example response includes the expected buy amount, route sources, allocation proportions, estimated gas and gas price. A route may, for example, divide liquidity between Uniswap V3 and Aerodrome instead of sending the complete order to one pool.
When the user is ready to trade, request a firm quote from:
GET /quoteThe quote requires the taker wallet and returns the destination contract, calldata, gas information and Permit2 EIP-712 data.
JarvisClaw currently documents a 30-second quote lifetime. If the quote expires before signing and submission, the application must request a fresh one.
How to Compare Routes in a Real Application
A dashboard should not rank routes on one number.
For each candidate trade size, evaluate:
| Field | What It Tells You | What to Check |
|---|---|---|
buyAmount | Expected tokens received | Convert from base units correctly |
sources | Liquidity venues used | Review concentration and route complexity |
estimatedGas | Expected execution work | Convert to the chain’s native-token cost |
gasPrice | Current gas price assumption | Refresh when the network is volatile |
validTo | Quote expiration | Do not sign an expired quote |
| Price impact | Effect of the order on liquidity | Reject trades above your limit |
| Minimum output | Worst acceptable execution | Enforce before submitting |
One practical pattern is to request prices for several order sizes.
For example, a treasury application planning to swap 100,000 USDC can compare:
- One 100,000 USDC trade
- Two 50,000 USDC trades
- Four 25,000 USDC trades
Splitting an order may reduce price impact, but it also creates more API calls, more transactions and potentially more gas. The application should compare total net output rather than assuming smaller trades are automatically cheaper.
Do not split transactions mechanically. Repeated visible trades can also expose execution intent and allow the market to move between orders.
Liquidity Depth Matters More Than the Number of DEXs
“Routing across 100+ exchanges” does not mean that every trade touches 100 venues.
The router should use only sources that improve the result for the requested pair, amount, wallet and network. Some pairs may have one dominant pool. Others may benefit from a split route.
More hops can improve price discovery, but they can also increase calldata complexity and gas usage. A route should therefore be judged by its result, not by the number of protocols it includes.
Developers should test:
- Stablecoin-to-stablecoin swaps
- Stablecoin-to-volatile-token swaps
- Small and large order sizes
- High-volume and thin-liquidity pairs
- Fast and congested network conditions
- Tokens with different decimal formats
JarvisClaw requires token contract addresses rather than ticker symbols. Amounts must be submitted in base units—for example, six decimals for USDC and 18 decimals for ETH or WETH. An incorrect decimal conversion can turn a valid order into a dangerously oversized one.
Execution Costs Developers Commonly Miss
Price Impact
Price impact is created by the trade itself. A large order consumes available liquidity and moves the pool price. It is not the same as slippage.
Slippage
Slippage is the difference between the expected and executed result caused by market movement before confirmation. A high tolerance improves the chance of execution but can expose the taker to a worse price.
Gas
A multi-source route may return more tokens but require more gas. Convert the gas estimate into a common currency before ranking routes.
Approval Cost
A token may require an approval before it can be transferred. Permit2 can simplify repeat authorization, but developers should still check whether an initial approval transaction is needed.
Failed-Transaction Cost
A reverted transaction may still consume gas. Expired quotes, insufficient balances, incorrect approvals and changed market conditions can create costs without producing a successful swap.
API Usage Cost
JarvisClaw’s current DEX documentation lists each endpoint at $0.001/call upstream and recommends reading the returned price.amount for the exact platform charge. The fee applies to price, quote, execution and status requests, so unnecessary polling can add avoidable cost at scale.
Permit2 and Gasless Execution
A normal Permit2 quote gives the application structured signing data and executable transaction information.
For supported gasless trades, the taker signs the authorization and submits it through:
POST /gasless/submitA relayer broadcasts the transaction and pays the network gas. The application can then monitor:
GET /gasless/status/:tradeHashGasless execution is useful when a wallet owns the token being sold but does not hold the native gas token.
It does not make the economic trade free. API charges, price impact and other swap costs still apply. JarvisClaw’s documentation explicitly separates gasless execution from the per-call platform fee.
A Safer Production Workflow
A production DEX integration should:
- Validate the chain and token contract addresses.
- Convert human-readable amounts into correct base units.
- Request an indicative price.
- Calculate estimated net value after gas and API cost.
- Reject excessive price impact.
- Request a firm quote only when execution is likely.
- Verify the taker, token amounts, destination and expiry.
- Sign the Permit2 data.
- Submit before the 30-second quote expires.
- Record the trade or transaction hash.
- Confirm the final on-chain result.
- Reconcile the actual output against the quoted output.
Retries require special care.
Do not automatically send a second transaction because the first request timed out. Check whether the original trade was already submitted. For gasless swaps, query the trade status. For conventional execution, check the wallet nonce or transaction hash before retrying.
DEX Routing for AI Agents
A trading agent can use a routing API to compare execution rather than blindly submitting the first quote it receives.
Its policy might include:
Maximum order value: $5,000
Maximum price impact: 0.50%
Maximum slippage: 0.30%
Maximum quote age: 20 seconds
Approved chain: Base
Approved tokens: USDC and WETH
Human approval required above: $1,000These controls should be enforced in application code.
Natural-language prompts are helpful for describing strategy, but they are not a substitute for hard limits on token addresses, trade size, slippage or allowed chains.
JarvisClaw supports API-key access and x402 authentication, making the same DEX endpoints available to conventional applications and wallet-enabled agents.
Route for Net Execution, Not Headline Price
The purpose of a DEX routing API is not to display the largest possible quote. It is to help an application make an executable decision.
Compare token output, liquidity sources, gas, price impact, quote age and failure risk. Recalculate immediately before signing and confirm the final result on-chain.
JarvisClaw brings indicative pricing, firm quotes, Permit2 execution and gasless submission into one DEX API surface. This reduces the work required to integrate individual liquidity venues while keeping route and cost data available to the application.
Explore the JarvisClaw API Marketplace and review the DEX Trading API documentation before deploying live trades.
FAQ
What is a DEX swap routing API?
A DEX swap routing API searches liquidity across decentralized exchanges and returns an estimated or executable route for exchanging one token for another.
What is the difference between a price and a quote?
A price is an indicative estimate used for display or comparison. A quote includes time-sensitive transaction data that can be signed and executed.
Does the route with the highest buy amount always offer the best execution?
No. Gas, price impact, protocol costs, approval requirements and failure risk can make a slightly lower-output route cheaper overall.
How long is a JarvisClaw DEX quote valid?
The current documentation states that quotes expire after 30 seconds. Applications should request a new quote after expiration.
Can the API split a trade across multiple liquidity sources?
Yes. A price response can show several sources and the proportion of the trade allocated to each one.
Does JarvisClaw support gasless swaps?
Yes. Supported trades can be signed with Permit2 data and submitted to a relayer that pays the network gas.
Are gasless swaps free?
No. Gasless means the taker does not directly pay native network gas. API fees, price impact and other execution costs may still apply.
How should an AI agent select a swap route?
The agent should compare net output and enforce hard limits for trade value, approved tokens, chain, price impact, slippage and quote age before signing.