Intent Markets

Not a bridge. Not an aggregator. Not another API to maintain.

The infrastructure layer for intent markets — declare any outcome, solvers compete to fulfill it, capabilities grow without new integrations.

Explore the Docs →Talk to Us →

No SDK. No API keys. First intent in 5 minutes.

40+

Chains

10K+

Assets

150+

DEXes

~5s

Avg Swap Time

What You Can Build

Dozens of intent types already live. Declare what you want, solvers compete to deliver.

Cross-chain Execution

Swaps, bridges, transfers. One integration, competitive rates, every chain. Users sign once.

Any-chain Deposits

Accept deposits from any chain. Users interact with your protocol from wherever their assets are.

Multi-step Flows

Swap → bridge → deposit → stake. One intent, multiple markets, atomic execution.

Off-chain Services

Connect on-chain apps to off-chain compute, data, or APIs. Become a solver, access every integrated app.

New Markets

Anyone can create an intent market. Define the intent type, attract solvers, plug into the network. Intents settle across markets — that's the composability.

Why teams integrate

→

Better rates

Solvers compete on every intent

→

One integration

40+ chains, no per-chain work

→

Zero stuck funds

Atomic execution or full refund

→

Future-proof

New chains and capabilities, no code changes

Capabilities That Compound

Most infrastructure is static. Khalani is a network that evolves — new chains, new markets, better rates — and your integration gains these capabilities automatically.

How It Compounds

→New chains appear as solvers add support
→New intent types emerge as markets are created
→Rates improve as solvers compete
→Complex flows become possible as markets compose

Why It Works

•Anyone can create intent markets — permissionless by design
•Intents settle across markets — swap in one, bridge in another, deposit in a third
•Deterministic state machines — composable, verifiable execution

Aggregation, optimization, routing, reconciliation — all the hard orchestration problems are solved by solvers. For integrators, the interface is fixed and predictable.

You declare outcomes. They figure out how.

Integrate

Call the API, access the network of markets, ship your product. Fixed interface, predictable lifecycle.

JavaScript

const BASE_URL = "https://api.khalani.network";

// 1. Request a quote
const quote = await fetch(`${BASE_URL}/v1/quotes`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    fromAddress: userAddress,
    tradeType: "EXACT_INPUT",
    fromChainId: 1,        // Ethereum
    fromToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    toChainId: 8453,       // Base
    toToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    amount: "1000000",     // 1 USDC
  }),
}).then(res => res.json());

// 2. Build the deposit transaction
const deposit = await fetch(`${BASE_URL}/v1/deposit/build`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    from: userAddress,
    quoteId: quote.quoteId,
    routeId: quote.routes[0].routeId,
  }),
}).then(res => res.json());

// 3. User signs, solvers execute, settlement is atomic

Quick Start Guide →

Extend

Khalani is programmable. Go beyond integration — become part of the infrastructure.

•

Create new intent markets

Define intent types, set rules, attract solvers

•

Run solvers

Serve your users or the broader network

•

Compose markets

Combine existing markets in novel ways

•

Bring new capabilities

On-chain or off-chain, into the ecosystem

Start as an integrator. Become a market creator.

Developer Docs →

For Solvers & Service Providers

Own the complexity, capture the value.

→Focus on your specialty — other solvers handle the rest

→Intents come to you — access flow from every integrated app

→Compose, don't compete on everything — the market coordinates

→Grow with demand — your surface area expands automatically

Solver Documentation →

Atomic

Constraints met or nothing moves

Non-custodial

Users sign from their wallets

Clean failures

Refunds go where they should

Redundant

No single point of failure

Composable

Markets extend, not fragment

Predictable

Stable interface, growing capabilities

Start Building Now

The markets are live. Solvers are competing. The API is open — no keys required.

Start Building →Talk to Us →

JavaScript

const BASE_URL = "https://api.khalani.network";

// 1. Request a quote
const quote = await fetch(`${BASE_URL}/v1/quotes`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    fromAddress: userAddress,
    tradeType: "EXACT_INPUT",
    fromChainId: 1,        // Ethereum
    fromToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    toChainId: 8453,       // Base
    toToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    amount: "1000000",     // 1 USDC
  }),
}).then(res => res.json());

// 2. Build the deposit transaction
const deposit = await fetch(`${BASE_URL}/v1/deposit/build`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    from: userAddress,
    quoteId: quote.quoteId,
    routeId: quote.routes[0].routeId,
  }),
}).then(res => res.json());

// 3. User signs, solvers execute, settlement is atomic