Conduit Developer Docs
Build on Conduit’s cross-chain execution layer.
Two developer surfaces on the same rails. The Agent API: 12 REST endpoints across 13 chains and 110+ tokens for AI agents via MCP, OpenAPI, A2A, or direct REST. And Conduit Connect: a drop-in React checkout that accepts crypto from any wallet on any chain and settles to the merchant on Solana in ~400ms.
Getting Started
Start with discovery, then quote, then build. Free endpoints need no API keys. Paid endpoints only charge when you ask Conduit to construct execution payloads.
What is Conduit?
Conduit is a non-custodial, multi-chain transaction API designed for AI agents. Your agent discovers tokens, gets quotes, and builds transactions through our endpoints — then signs locally and broadcasts. We never touch private keys.
https://api.conduit.exchange/api/agentsCanonical field names work. Quote and swap also accept compact aliases for WAF-safe agent traffic.All Routes Return Transactions
Every bridge route returns a ready-to-sign transaction. No deposit addresses are exposed. Sign and submit the transaction, then track via/api/agents/tx-status/{txHash}?chain=....
Monero
Monero support on the agent/backend surface is currently provider-backed. Expect roughly 20-40 minutes because the provider waits for XMR confirmations before payout.
3-Step Walkthrough
Query supported tokens and check balances — completely free, no auth needed.
Request
curl https://api.conduit.exchange/api/agents/tokens
Response
{
"ok": true,
"count": 110,
"tokens": [
{ "symbol": "SOL", "name": "Solana", "type": "native", "chains": { "solana": { "address": "So111...112", "decimals": 9 } } },
{ "symbol": "USDC", "name": "USD Coin", "type": "stablecoin", "chains": { "solana": { "decimals": 6 }, "ethereum": { "decimals": 6 }, "base": { "decimals": 6 } } },
{ "symbol": "ETH", "name": "Ethereum", "type": "native", "chains": { "ethereum": { "decimals": 18 }, "base": { "decimals": 18 } } }
],
"pricing": { "swap": "$0.01", "bridge": "$0.02", "transfer": "$0.005" }
}Sign & Submit
Solana (TypeScript)
const txEntry = data.swap.transactions[0]; const tx = VersionedTransaction.deserialize( Buffer.from(txEntry.data, "base64") ); tx.sign([keypair]); const sig = await connection.sendRawTransaction( tx.serialize() );
EVM (viem)
const txEntry = data.swap.transactions[0];
const hash = await walletClient.sendTransaction({
to: txEntry.to,
data: txEntry.data,
value: BigInt(txEntry.value || "0"),
chainId: txEntry.chainId,
});Full working examples: examples/ — TypeScript and Python scripts for every endpoint.
What can you build?
Auto-swap assets to maintain target allocations across chains
Send value between any chains — Solana, EVM, Bitcoin, Kaspa
Route swaps and bridges from MCP tools, assistants, or custom planners
Monitor balances, reserve gas, and automate fund movements from one API
Agent Integration
Pick the integration surface that matches how your agent already works: MCP for tool calling, OpenAPI for framework import, A2A for discovery, or raw REST when you want full transport control.
Discovery Endpoints
These URLs are the fastest way to make Conduit legible to agent frameworks without writing custom glue code.
https://api.conduit.exchange/api/mcp/mcphttps://api.conduit.exchange/.well-known/openapi.jsonhttps://api.conduit.exchange/.well-known/agent-card.jsonhttps://api.conduit.exchange/.well-known/ai-plugin.jsonhttps://api.conduit.exchange/.well-known/conduit-skill.mdDiscovery endpoints are free. Use them to inspect tokens, balances, quotes, gas, status, and agent profile data before spending.
Paid build endpoints only charge when Conduit constructs an execution payload. Agents should quote first, then pay x402 only for the chosen route.
All routes return ready-to-sign transactions. Sign and submit — Conduit handles everything else. Track via /api/agents/tx-status/{txHash}?chain=...
Best path for tool-using agents. Connect from Claude Code, Claude Desktop, or any MCP-compatible runtime and expose Conduit as discovered tools instead of hand-written REST wrappers.
// Claude Code CLI
claude mcp add --transport http conduit https://api.conduit.exchange/api/mcp/mcp
// Or add to .mcp.json in your project root:
{
"mcpServers": {
"conduit": {
"type": "http",
"url": "https://api.conduit.exchange/api/mcp/mcp"
}
}
}
// Claude Desktop (claude_desktop_config.json):
{
"mcpServers": {
"conduit": {
"type": "http",
"url": "https://api.conduit.exchange/api/mcp/mcp"
}
}
}Authentication & Payments
Separate discovery from execution. Free reads need no auth. Paid build endpoints use x402 USDC micropayments. Optional wallet auth adds verified identity for leaderboards and usage tracking.
/agents/tokensSupported Tokens & Chains/agents/quoteMulti-Provider Quotes/agents/balancesMulti-Chain Balances/agents/gasGas Estimation/agents/tx-status/{id}Transaction Status/agents/statusAgent Usage Stats/agents/leaderboardAgent Leaderboard/agents/authWallet Authentication/agents/swap$0.01/agents/bridge$0.02/agents/transfer$0.005/agents/multihop$0.03How x402 Works
Call Endpoint
Make a normal HTTP request to a paid build endpoint
Receive 402
Conduit responds with payment requirements and accepted settlement networks
Pay via USDC
Your agent signs a USDC micropayment on Base or Solana
Retry with Header
Resend the request with X-PAYMENT and receive the unsigned execution payload
Conduit only charges when it constructs execution payloads. Discovery-heavy agents can quote, inspect balances, estimate gas, and track transactions without spending. Payments settle in USDC on Base or Solana.
That means Monero route discovery and status polling stay free. The x402 charge only applies when you ask Conduit to build the provider-backed bridge execution payload.
SDK Integration
For most agents, let an x402 client handle the 402 challenge-response cycle automatically. If you manage transport manually, retry the same request with the `X-PAYMENT` header after signing the payment proof.
import { wrapFetch } from "@x402/fetch";
// Wrap fetch with x402 payment support
const payFetch = wrapFetch(fetch, {
// Your wallet/signer for USDC payments
paymentSigner: yourWalletSigner,
// Network: "base" or "solana"
network: "base",
});
// Use exactly like fetch — x402 is handled automatically
const res = await payFetch(
"https://api.conduit.exchange/api/agents/swap",
{
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
fromToken: "SOL",
toToken: "USDC",
amount: "1000000000",
chain: "solana",
userAddress: "YourSolanaKey...",
}),
}
);
const data = await res.json();
// → data.swap.transactions[0].data contains the unsigned swap txInstall: npm install @x402/fetch
Try it Live
Test free endpoints directly in the browser before wiring x402 or signing flows
Discover all supported tokens and chains
These presets only use free endpoints so they run in-browser without x402 setup. For paid build flows, use the SDK and example scripts below.
/api/agents/tokensArchitecture
How Conduit works — non-custodial design and the transaction lifecycle.
Non-Custodial Model
Conduit never sees your private key. We return unsigned transactions — you sign locally and broadcast.
Transaction Lifecycle
Check tokens, balances, gas
FREEAggregated multi-provider quotes
FREEBuild unsigned transaction
PAIDSign locally with your key
LOCALMonitor until confirmed
FREEWe build transactions, you sign them. Private keys never leave your device.
Discovery, quotes, balances, and gas checks require zero authentication.
Only transaction building costs money — via x402 USDC micropayments.
Discovery
Explore tokens, chains, balances, and gas costs
Execution
Swap, bridge, transfer, and multihop routes
Monitoring
Track transactions and agent usage
Pricing
Pay-per-call via the x402 protocol. Free endpoints have no cost. Paid endpoints accept USDC on Base or Solana.
| Endpoint | Method | Price | Payment Networks |
|---|---|---|---|
Supported Tokens & Chains/api/agents/tokens | GET | FREE | -- |
Multi-Provider Aggregated Quotes/api/agents/quote | POST | FREE | -- |
Aggregated Swap Execution/api/agents/swap | POST | $0.01 | Base + Solana |
Cross-Chain Bridge/api/agents/bridge | POST | $0.02 | Base + Solana |
Same-Chain Token Transfer/api/agents/transfer | POST | $0.005 | Base + Solana |
Multi-Hop Cross-Chain Route/api/agents/multihop | POST | $0.03 | Base + Solana |
Multi-Chain Balance Oracle/api/agents/balances | GET / POST | FREE | -- |
Gas Estimation & Preflight Check/api/agents/gas | GET / POST | FREE | -- |
Transaction Status Tracker/api/agents/tx-status/{id} | GET | FREE | -- |
Agent Usage, Stats & Profile/api/agents/status | GET / POST | FREE | -- |
Agent Leaderboard/api/agents/leaderboard | GET | FREE | -- |
Agent Wallet Authentication/api/agents/auth | POST | FREE | -- |
Payments via x402 protocol -- USDC on Base or Solana. No API keys needed.
Amount Formatting
All amounts in the API use the smallest unit (raw). Understanding decimals is critical for correct transactions.
The Rule: Multiply the human-readable amount by 10^decimals to get the raw amount. Always send raw amounts as strings in API requests.
Token Decimals Reference
1000000000100000000000000000010000001000000100000000100000000000000000010000000000000000001000000000000000000100000000100000000000000000010000000000001000000Conversion Examples
// Human-readable → Raw (for API requests) const solAmount = 1.5; const rawAmount = Math.floor(solAmount * 10 ** 9); // → 1500000000 (send this string to the API) const usdcAmount = 100; const rawUsdc = Math.floor(usdcAmount * 10 ** 6); // → 100000000 // Raw → Human-readable (from API responses) const rawOutput = "185420000"; // USDC const humanOutput = Number(rawOutput) / 10 ** 6; // → 185.42 USDC
"amount": "1" — This is 0.000000001 SOL (1 lamport), not 1 SOL"amount": "1000000000" — This is 1.0 SOL (10^9 lamports)Error Handling
Error response format, HTTP status codes, rate limits, and retry strategies.
Error Response Format
{
"ok": false,
"error": "Human-readable error message",
"code": "INSUFFICIENT_BALANCE" // optional error code
}All endpoints return ok: true on success and ok: false on failure. Soft errors (no route, etc.) return HTTP 200 with ok: false.
HTTP Status Codes
Soft errors — no route found, insufficient balance, provider down
Invalid parameters — missing fields, wrong types, bad addresses
x402 payment needed — sign USDC micropayment and retry
Too many requests — back off and retry after Retry-After header
Internal error — retry with exponential backoff
Upstream provider unreachable — try again or use a different route
Request timed out — retry, provider may be slow
Rate Limits
tokens, balances, gas
quote, tx-status, status
swap, bridge, transfer, multihop
Response Headers
X-RateLimit-LimitMax requests per windowX-RateLimit-RemainingRequests left in windowRetry-AfterSeconds to wait before retrying (on 429)Recommended Retry Strategy
Retry-After seconds, then retryPayment headerok: false — don't retry soft errors (no route, bad params)Supported Chains
13+Supported Tokens
110+Basic Swap
Single-chain token swap via the best available DEX provider
Cross-Chain Bridge
Transfer tokens from one chain to another via the best bridge provider
Multihop Route
Complex cross-chain route through intermediate chains (e.g. AVAX -> SOL -> KAS)
Deposit-Based Exchange
Exchange flow for non-smart-contract and provider-routed chains (Kaspa, Bitcoin, Tron, Monero) via deposit-based providers
AI Agent Guide
System prompts, decision trees, and tool definitions for integrating Conduit into AI agents and LLMs.
System Prompt Template
Add this to your agent's system prompt to teach it how to use the Conduit API.
You have access to the Conduit API for executing crypto transactions across 13+ blockchains through 12 agent endpoints.
Base URL: https://api.conduit.exchange/api/agents
## Available Actions (free, no auth):
- GET /tokens — List supported tokens, chains, and decimals
- POST /quote — Get swap/bridge quotes from multiple providers
- GET /balances?chains=solana:ADDRESS,base:ADDRESS — Check balances
- GET /gas?chain=solana — Estimate gas costs
- GET /tx-status/{id} — Track transaction status
- GET /status — Check your usage stats
- GET /leaderboard — View ranked agent leaderboard
- POST /auth — Authenticate via wallet signature (verified identity)
## Build Actions (paid via x402 USDC micropayment):
- POST /swap ($0.01) — Build a swap transaction (same chain)
- POST /bridge ($0.02) — Build a cross-chain bridge transaction
- POST /transfer ($0.005) — Build a same-chain token transfer
- POST /multihop ($0.03) — Build a multi-hop cross-chain route
## Critical Rules:
1. All amounts are in SMALLEST UNIT (raw). 1 SOL = "1000000000", 1 USDC = "1000000"
2. Conduit returns unsigned transactions. Sign locally with your private key, then broadcast.
3. Always get a quote first, then build. Never build without quoting.
4. Free endpoints need no auth. Paid endpoints return 402 → pay USDC → retry.
5. After building a tx, sign and submit it on-chain. Track with GET /tx-status/{txHash}?chain=... until confirmed.
6. All swap and bridge routes return a transactions[] array. No deposit addresses are exposed. Sign and submit each transaction — Conduit handles everything else.
7. For EVM bridge routes needing ERC-20 approval, bridge.approval contains { needed: true, spender: "0x..." }. Send approval before the bridge transactions.
8. Bridge and transfer endpoints reject burn/system addresses (Solana system program, EVM zero address) with 400.
9. Provider-backed Monero routes are slower than smart-contract routes. Expect roughly 20-40 minutes because the provider waits for XMR confirmations.
10. Follow the returned instructions field exactly. Do not invent unsupported execution endpoints.
11. Never send your private key to any API. All signing happens locally.
12. Optional: POST /auth with wallet signature for verified leaderboard identity.
13. Quote and swap also accept compact aliases (p1/p2/p3/p4) when needed for bot traffic.
## Workflow: Discover → Quote → Build → Sign → Broadcast → TrackEndpoint Decision Tree
/transferSend 10 USDC from Alice to Bob on Solana/swapSwap 1 SOL for USDC on Solana/bridgeBridge USDC from Ethereum to Solana/bridgeBridge XMR from Monero — sign the returned tx, track via tx-status/multihopMove AVAX on Avalanche to KAS on Kaspa/tokensCheck which chains support USDCSigning Flow
Conduit never sees your private key. Sign transactions locally, then broadcast.
Agent Builds
POST /swap returns a ready-to-sign tx
Sign & Submit
Sign and submit on-chain — Conduit handles the rest
Agent Tracks
Track via /tx-status/{txHash}?chain=...
All routes return a ready-to-sign transaction. Sign and submit the transaction — Conduit handles everything else. Track progress via /api/agents/tx-status/{txHash}?chain=....
Tool Definitions
from langchain.tools import tool
import requests
BASE = "https://api.conduit.exchange/api/agents"
@tool
def get_swap_quote(from_token: str, to_token: str, amount: str, chain: str) -> dict:
"""Get a swap quote from multiple DEX providers.
Amount must be in smallest unit (e.g., 1 SOL = '1000000000').
Returns: best quote with provider, output amount, and price impact."""
resp = requests.post(f"{BASE}/quote", json={
"fromToken": from_token,
"toToken": to_token,
"amount": amount,
"chain": chain,
})
return resp.json()
@tool
def check_balances(chains_and_addresses: str) -> dict:
"""Check token balances across chains.
Format: 'solana:ADDRESS,base:ADDRESS,ethereum:ADDRESS'
Returns: balances for each chain with native and token amounts."""
resp = requests.get(f"{BASE}/balances", params={"chains": chains_and_addresses})
return resp.json()
@tool
def get_supported_tokens() -> dict:
"""List all supported tokens, their chains, and decimal counts."""
return requests.get(f"{BASE}/tokens").json()Network Topology
Conduit connects to 13+ chains through a unified hub. Hover a chain to see its connection.