List all blockchain networks supported by Relay for bridging and swapping. Returns chain IDs, names, native currencies, and status. Use this to resolve chain names to chain IDs before calling other tools.

Search for tokens supported by Relay across chains. Use this to find token contract addresses before getting quotes. Returns token symbol, name, address, and chain availability.

Get a quote for bridging the SAME token from one chain to another (e.g. ETH on Ethereum → ETH on Base).

Use this for same-token cross-chain transfers. For different tokens (same or cross-chain), use get_swap_quote instead.

Returns execution steps — each step contains ready-to-sign transaction data (to, data, value, chainId, gas). An agent with wallet tooling can sign and submit these directly. Also returns a relay.link deep link as a fallback for manual execution.

Amounts must be in the token's smallest unit (wei, satoshis, lamports). Examples: 1 ETH = "1000000000000000000" (18 decimals), 1 USDC = "1000000" (6 decimals), 1 BTC = "100000000" (8 decimals), 1 SOL = "1000000000" (9 decimals). Use convert_amount or get_supported_tokens to look up decimals. Chain IDs can be numbers (8453) or names ('base', 'ethereum', 'arb', 'bitcoin', 'solana').

Get a quote for swapping between DIFFERENT tokens, same-chain or cross-chain (e.g. ETH → USDC on Base, or ETH on Ethereum → USDC on Base).

Use when input and output tokens differ. Works same-chain and cross-chain. For same-token bridging (e.g. ETH on Ethereum → ETH on Base), use get_bridge_quote instead — it's simpler.

Returns execution steps — each step contains ready-to-sign transaction data (to, data, value, chainId, gas). An agent with wallet tooling can sign and submit these directly. Also returns a relay.link deep link as a fallback for manual execution.

Amounts must be in the token's smallest unit (wei, satoshis, lamports). Examples: 1 ETH = "1000000000000000000" (18 decimals), 1 USDC = "1000000" (6 decimals), 1 BTC = "100000000" (8 decimals), 1 SOL = "1000000000" (9 decimals). Use convert_amount or get_supported_tokens to look up decimals. Chain IDs can be numbers (8453) or names ('base', 'ethereum', 'arb', 'bitcoin', 'solana').

Estimate the fees for a specific bridge or swap route without committing to execution. Returns a breakdown of gas fees, relayer fees, and total cost impact.

Use this for comparing route costs or showing users expected fees. For standalone token pricing (not route-specific), use get_token_price instead.

Amounts must be in the token's smallest unit (wei, satoshis, lamports). Examples: 1 ETH = "1000000000000000000" (18 decimals), 1 USDC = "1000000" (6 decimals), 1 BTC = "100000000" (8 decimals), 1 SOL = "1000000000" (9 decimals). Use convert_amount or get_supported_tokens to look up decimals. Chain IDs can be numbers (8453) or names ('base', 'ethereum', 'arb', 'bitcoin', 'solana').

Check the status of a Relay bridge or swap transaction. Returns rich data including fees, token amounts, fail reasons, and route details.

Accepts either a requestId (from a previous quote/execution) or a txHash (on-chain transaction hash) to look up the request.

Note: Quotes expire in ~30 seconds. If tracking a completed transaction, use the requestId from the execution response or the on-chain txHash — not the quote ID.

If get_transaction_status returns "not found" for a tx you know exists on-chain, use index_transaction to tell Relay to index it.

Statuses: waiting (broadcast, not confirmed) → pending (relay processing) → success (funds arrived) | failure | refund.

Get past Relay bridge and swap transactions for a wallet address. Returns transaction IDs, statuses, chains, and timestamps. Supports pagination via cursor.

Filter by time range, origin/destination chain, or deposit address to narrow results.

Generate a deep link to the Relay web app with pre-filled bridge/swap parameters. The user can open this URL in their browser to START a new transaction via the Relay UI. This is NOT a transaction tracking URL — do NOT use it to check on an in-progress transaction. For tracking, use get_transaction_status with the requestId.

Discover Relay API endpoints and their schemas. Two modes:

1. No arguments → lists all public endpoints (method, path, summary).

2. With endpoint → shows detailed parameter and response schemas.

Use this to explore what the API offers before calling other tools.

Check if a chain is healthy, view available solver liquidity, solver wallet addresses, depository contracts, and optionally check route configuration between two chains.

Use this before quoting to verify a route is viable:

• Is the chain healthy and operational?

• How much solver liquidity is available?

• What are the solver EOA addresses and Relay contracts on this chain?

• Is the route between origin and destination enabled?

If a chain is unhealthy or has low liquidity, bridging may fail or be slow.

Get the current USD price of a token on a specific chain.

For just the price, use this tool. For full fundamentals (marketCap, volume, liquidity, chart), use get_token_details instead.

For fee estimates on a specific bridge/swap route, use estimate_fees — this tool is for standalone token pricing only.

Get detailed information about a token: price, market cap, volume, liquidity, and optionally a price chart.

For just the USD price, use get_token_price instead — it's faster and simpler. For trending tokens (discovery), use get_trending_tokens first, then this tool for deep-dives.

When includeChart is true, returns a slimmed price chart (~50 data points with close prices, volumes, and summary stats). Raw chart data is ~21KB; this tool reduces it to ~3KB.

List currently trending tokens across Relay-supported chains.

Returns token identities only (symbol, name, address, chainId) — NOT prices or volumes. To get pricing for a trending token, follow up with get_token_price or get_token_details.

Use this to answer "what tokens are trending?" or "what's popular on Base right now?"

List all DEX aggregators and AMMs that Relay routes swaps through (e.g. Uniswap, Jupiter, SushiSwap).

Use this to answer "what DEX sources does Relay support?" or to verify which protocols are available for swap routing. No parameters needed.

Check claimable app fee balances and past claim history for an integrator wallet.

Use this to answer "how much have I earned?" or "what fees are claimable?" App fees are earned by integrators who route swaps/bridges through Relay with a referral fee configured.

Returns both current claimable balances and historical claims in one call.

Tell Relay to index a transaction it may have missed. Use this when a bridge or swap transaction exists on-chain but doesn't appear in Relay's system (e.g. get_transaction_status returns "not found").

This is a write operation — it tells Relay's indexer to look at a specific transaction. The response confirms whether indexing was accepted.

Get a quote for consolidating tokens from MULTIPLE origin chains into a single destination (e.g. USDC from Ethereum + Arbitrum + Optimism → USDC on Base).

Use this for portfolio consolidation, rebalancing, or collecting scattered funds. Each origin specifies its own chain, token, and amount. All origins settle to one destination chain and token.

Amounts must be in the token's smallest unit (wei, satoshis, lamports). Examples: 1 ETH = "1000000000000000000" (18 decimals), 1 USDC = "1000000" (6 decimals), 1 BTC = "100000000" (8 decimals), 1 SOL = "1000000000" (9 decimals). Use convert_amount or get_supported_tokens to look up decimals. Chain IDs can be numbers (8453) or names ('base', 'ethereum', 'arb', 'bitcoin', 'solana').

Convert between human-readable token amounts and smallest-unit values (wei, lamports, satoshis).

Use this before calling quote/bridge/swap tools which require amounts in smallest units.

Examples:

• 1.5 ETH (18 decimals) → "1500000000000000000"

• 100 USDC (6 decimals) → "100000000"

• 0.001 BTC (8 decimals) → "100000"

• "1000000000000000000" → 1.0 (18 decimals)

Common decimals: ETH/WETH = 18, USDC/USDT = 6, BTC = 8, SOL = 9. Use get_supported_tokens or get_token_details to look up decimals for other tokens.

Check a user's balance for a specific token on a route. Returns how much of the token the user holds on the origin chain and the maximum amount they can bridge/swap on this route.

Use this before quoting to verify the user has sufficient funds, or to show available balance context. Requires specifying both origin and destination chains since max bridgeable amount depends on the route.

Chain IDs can be numbers (8453) or names ('base', 'ethereum', 'arb', 'bitcoin', 'solana').

Call any public Relay API endpoint with full parameters and get the raw, unfiltered response.

Use get_api_schema first to discover endpoints and their parameter schemas, then use this tool to call them. This gives you access to all API features that the dedicated tools simplify away — for example:

• Full /quote/v2 params: slippageTolerance, appFees, includedSwapSources, useExternalLiquidity, topupGas, maxRouteLength, etc.

• Full response data: detailed fee breakdowns, route objects, slippage details, protocol data, swap impact

• Endpoints without dedicated tools: /price (lightweight pricing), /currencies/v2, /execute/* (with pre-signed data)

• Advanced /requests/v2 query params: sortBy, sortDirection, includeOrderData, referrer, includeChildTxs

For common operations (simple quotes, token search, chain status), prefer the dedicated tools — they validate inputs, resolve chain names/token symbols, and format responses. Use this tool when you need parameters or response fields those tools don't expose.