CONDUIT API

Build with cross-chain intelligence.

Non-custodial transaction API for AI agents. 11 endpoints, 13 chains, 110+ tokens — quote, swap, bridge, and track from a single integration.

11Endpoints
13Chains
110Tokens

Getting Started

Start building with the Conduit API in under a minute. No API keys needed for free endpoints.

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.

Base URLhttps://api.conduit.exchange/api/agents/

3-Step Walkthrough

Query supported tokens and check balances — completely free, no auth needed.

Request

bash
curl https://api.conduit.exchange/api/agents/tokens

Response

json
{
  "ok": true,
  "chains": ["solana", "ethereum", "base", "polygon", ...],
  "tokens": [
    { "symbol": "SOL", "chains": ["solana"], "decimals": 9 },
    { "symbol": "USDC", "chains": ["solana", "ethereum", "base", ...], "decimals": 6 },
    { "symbol": "ETH", "chains": ["ethereum", "base", "arbitrum", ...], "decimals": 18 }
  ]
}

What can you build?

Portfolio Rebalancing

Auto-swap assets to maintain target allocations across chains

Cross-Chain Payments

Send value between any chains — Solana, EVM, Bitcoin, Kaspa

DCA & Limit Orders

Build automated buy/sell strategies with scheduled transactions

Treasury Management

Multi-chain balance monitoring and automated fund movements

Architecture

How Conduit works — non-custodial design and the transaction lifecycle.

Non-Custodial Model

Your AgentConduit APIUnsigned TXSign & SendBroadcast

Conduit never sees your private key. We return unsigned transactions — you sign locally and broadcast.

Transaction Lifecycle

1Discover

Check tokens, balances, gas

FREE
2Quote

Aggregated multi-provider quotes

FREE
3Build

Build unsigned transaction

PAID
4Sign

Sign locally with your key

LOCAL
5Track

Monitor until confirmed

FREE
Non-Custodial

We build transactions, you sign them. Private keys never leave your device.

No API Keys for Free Endpoints

Discovery, quotes, balances, and gas checks require zero authentication.

Pay-Per-Call for Build Endpoints

Only transaction building costs money — via x402 USDC micropayments.

Authentication & Payments

Free endpoints need no auth at all. Paid endpoints use x402 micropayments — USDC on Base or Solana. Optional wallet-signature auth for verified identity.

FREENo auth required
/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
PAIDx402 USDC micropayment
/agents/swap$0.01
/agents/bridge$0.02
/agents/transfer$0.005
/agents/multihop$0.03

How x402 Works

1

Call Endpoint

Make a normal HTTP request to a paid endpoint

2

Receive 402

Get a 402 Payment Required response with payment details

3

Pay via USDC

Sign a USDC permit/transfer on Base or Solana

4

Retry with Header

Resend request with the X-PAYMENT header — get your transaction

Think of it like a toll booth — you pay once per build request. Payments are USDC on Base (chain 8453) or Solana. No API keys, no subscriptions, no accounts to create.

SDK Integration

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.transaction contains the unsigned swap tx

Install: npm install @x402/fetch

Discovery

Explore tokens, chains, balances, and gas costs

Execution

Swap, bridge, transfer, and multihop routes

Monitoring

Track transactions and agent usage

Try it Live

Test endpoints directly — no setup required

Discover all supported tokens and chains

GET/api/agents/tokens

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

TokenDecimals1.0 human = raw
SOLSolana
91000000000
ETHEthereum
181000000000000000000
USDCUSD Coin
61000000
USDTTether
61000000
BTCBitcoin
8100000000
POLPolygon
181000000000000000000
BNBBNB Chain
181000000000000000000
AVAXAvalanche
181000000000000000000
KASKaspa
8100000000
HYPEHyperliquid
181000000000000000000
XMRMonero
121000000000000
TRXTron
61000000

Conversion 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
Common Mistakes
x
"amount": "1" — This is 0.000000001 SOL (1 lamport), not 1 SOL
"amount": "1000000000" — This is 1.0 SOL (10^9 lamports)
xUsing 18 decimals for USDC — USDC has 6 decimals, not 18
xSending amounts as numbers — always send as strings to avoid precision loss

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

200
OK (with ok: false)

Soft errors — no route found, insufficient balance, provider down

400
Bad Request

Invalid parameters — missing fields, wrong types, bad addresses

402
Payment Required

x402 payment needed — sign USDC micropayment and retry

429
Rate Limited

Too many requests — back off and retry after Retry-After header

500
Server Error

Internal error — retry with exponential backoff

502
Bad Gateway

Upstream provider unreachable — try again or use a different route

504
Gateway Timeout

Request timed out — retry, provider may be slow

Rate Limits

Relaxed30 req/s

tokens, balances, gas

Standard10 req/s

quote, tx-status, status

Build2 req/s

swap, bridge, transfer, multihop

Response Headers

X-RateLimit-LimitMax requests per window
X-RateLimit-RemainingRequests left in window
Retry-AfterSeconds to wait before retrying (on 429)

Recommended Retry Strategy

429Wait for Retry-After seconds, then retry
402Sign USDC payment, immediately retry with Payment header
5xxExponential backoff: 1s → 2s → 4s → 8s (max 3 retries)
200Check ok: false — don't retry soft errors (no route, bad params)

Supported Chains

13+
solana
Solana
solana
SOLsolana
ethereum
Ethereum
1
ETHevm
base
Base
8453
ETHevm
polygon
Polygon
137
POLevm
arbitrum
Arbitrum
42161
ETHevm
optimism
Optimism
10
ETHevm
avalanche
Avalanche
43114
AVAXevm
bsc
BNB Chain
56
BNBevm
hyperliquid
Hyperliquid
999
HYPEevm
kaspa
Kaspa
KAS
KASother
bitcoin
Bitcoin
BTC
BTCutxo
tron
Tron
TRX
TRXother
monero
Monero
XMR
XMRother

Supported Tokens

110+

Basic Swap

Single-chain token swap via the best available DEX provider

Get Quote
API
Select Best
ACT
Build Swap
API
Sign & Submit
ACT
Track Status
API

Cross-Chain Bridge

Transfer tokens from one chain to another via the best bridge provider

Check Balances
API
Check Gas
API
Get Bridge Quote
API
Approve (EVM)
ACT
Execute Bridge
ACT
Track Status
API

Multihop Route

Complex cross-chain route through intermediate chains (e.g. AVAX -> SOL -> KAS)

Discover Routes
ACT
Get Multihop Quote
API
Execute Hop 1
ACT
Wait for Confirmation
API
Execute Hop 2
ACT
Final Confirmation
API

Deposit-Based Exchange

Exchange flow for non-smart-contract chains (Kaspa, Bitcoin, Tron) via deposit-based providers

Get Exchange Quote
API
Send Deposit
ACT
Exchange Processing
ACT
Track Exchange
API
Receive Tokens
ACT

Pricing

Pay-per-call via the x402 protocol. Free endpoints have no cost. Paid endpoints accept USDC on Base or Solana.

EndpointMethodPricePayment Networks
Supported Tokens & Chains/api/agents/tokens
GETFREE--
Multi-Provider Aggregated Quotes/api/agents/quote
POSTFREE--
Aggregated Swap Execution/api/agents/swap
POST$0.01Base + Solana
Cross-Chain Bridge/api/agents/bridge
POST$0.02Base + Solana
Same-Chain Token Transfer/api/agents/transfer
POST$0.005Base + Solana
Multi-Hop Cross-Chain Route/api/agents/multihop
POST$0.03Base + Solana
Multi-Chain Balance Oracle/api/agents/balances
GET / POSTFREE--
Gas Estimation & Preflight Check/api/agents/gas
GET / POSTFREE--
Transaction Status Tracker/api/agents/tx-status/{id}
GETFREE--
Agent Usage, Stats & Profile/api/agents/status
GET / POSTFREE--
Agent Leaderboard/api/agents/leaderboard
GETFREE--
Agent Wallet Authentication/api/agents/auth
POSTFREE--

Payments via x402 protocol -- USDC on Base or Solana. No API keys needed.

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.
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, track it with GET /tx-status/{id} until confirmed.
6. Never send your private key to any API. All signing happens locally.
7. Optional: POST /auth with wallet signature for verified leaderboard identity.

## Workflow: Discover → Quote → Build → Sign → Broadcast → Track

Endpoint Decision Tree

Same chain, same token, different address/transferSend 10 USDC from Alice to Bob on Solana
Same chain, different tokens/swapSwap 1 SOL for USDC on Solana
Different chains/bridgeBridge USDC from Ethereum to Solana
No direct route available/multihopMove AVAX on Avalanche to KAS on Kaspa
Not sure what's available/tokensCheck which chains support USDC

Signing Flow

Conduit never sees your private key. Sign transactions locally, then broadcast.

1

Agent Builds

POST /swap returns base64 unsigned tx

2

Agent Signs

Sign locally with your private key

3

Broadcast

Submit signed tx to the network

4

Agent Tracks

GET /tx-status/{id} until confirmed

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()

Agent Integration

Connect via MCP, OpenAPI, A2A, or direct REST. Zero-friction setup for AI agents.

Discovery Endpoints

MCP Server
/api/mcp/mcp
Streamable HTTP
OpenAPI Spec
/.well-known/openapi.json
OpenAPI 3.1
Agent Card
/.well-known/agent-card.json
A2A v0.3
Plugin Manifest
/.well-known/ai-plugin.json
OpenAI Plugin
Agent Skill
/.well-known/conduit-skill.md
AgentSkills

Connect directly from Claude Code, Claude Desktop, OpenAI SDK, or any MCP-compatible client. All tools auto-discovered.

// 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"
    }
  }
}
Claude CodeClaude DesktopOpenClawOpenAI SDKVercel AI SDKLangChainLlamaIndexGoogle ADKCrewAICursorGitHub CopilotChatGPT Actions

Network Topology

Conduit connects to 13+ chains through a unified hub. Hover a chain to see its connection.

solana
SOL
SOL
ethereum
ETH
ETH
base
BASE
ETH
polygon
POL
POL
arbitrum
ARB
ETH
optimism
OP
ETH
avalanche
AVAX
AVAX
bsc
BNB
BNB
hyperliquid
HYPE
HYPE
kaspa
KAS
KAS
bitcoin
BTC
BTC
tron
TRX
TRX
monero
XMR
XMR
Conduit Hub
Conduit API — Non-custodial multi-chain transactions for AI agents
x402 Payment ProtocolBase + Solana
Builderby Labs·2026
Non-custodial
·
Audited
·GitHub
Fast·Cheap·Just works