Early AlphaConduit is in early alpha testing. Some bugs and issues may occur.

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.

Free discovery endpointsx402 micropaymentsNon-custodial signingMIT-licensed SDKHMAC-signed quotes
12Endpoints
13Chains
110+Tokens
Conduit Connect SDK

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.

Base URLhttps://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

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

Response

json
{
  "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)

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)

typescript
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?

Portfolio Rebalancing

Auto-swap assets to maintain target allocations across chains

Cross-Chain Payments

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

Execution Agents

Route swaps and bridges from MCP tools, assistants, or custom planners

Treasury Management

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.

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

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

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.

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 build endpoint

2

Receive 402

Conduit responds with payment requirements and accepted settlement networks

3

Pay via USDC

Your agent signs a USDC micropayment on Base or Solana

4

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 tx

Install: 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.

GET/api/agents/tokens

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.

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.

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.

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+
StablecoinsCore liquidity
USDCsolana, ethereum, base, polygon, arbitrum, avalanche, bsc
USDTsolana, ethereum, polygon, arbitrum, avalanche, bsc
JupUSDsolana
Native tokensGas + routing
SOLsolana
ETHethereum, base, arbitrum, optimism
AVAXavalanche
BNBbsc
POLpolygon
HYPEhyperliquid
KASkaspa
BTCbitcoin

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 and provider-routed chains (Kaspa, Bitcoin, Tron, Monero) via deposit-based providers

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

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 → 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
Cross-chain with exotic chains (XMR, KAS, BTC)/bridgeBridge XMR from Monero — sign the returned tx, track via tx-status
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 a ready-to-sign tx

2

Sign & Submit

Sign and submit on-chain — Conduit handles the rest

3

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.

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