API Reference

Networks and Tokens

List networks

Retrieve a list of all blockchain networks supported by the platform.

GET /affiliate/v1/networks

Response Example:

application/json

[
  {
    "id": 1,
    "name": "Ethereum",
    "type": "EVM",
    "supports_optimized_swap": false,
    "icon_url": "https://cdn.changelly.com/defi/icons/1/tokens/usdt.png",
    "supports_custom_tokens": false
  }
]

Note: If supports_custom_tokens is set to true for a network, users can exchange custom tokens on that network. In this case, tokens returned by the API for the selected network represent popular tokens, but they do not form a complete list of all supported tokens.

List all tokens

Retrieve a paginated list of all tokens supported by the platform across all blockchain networks. This endpoint supports pagination, filtering by network and searching by token symbol, token name or contract address.

GET /affiliate/v1/tokens

Query Params:

Name	Type	Required	Description
limit	integer	false	Maximum number of tokens to return
offset	integer	false	Number of tokens to skip before starting to return results
q	string	false	Search query for token symbol, token name or contract address
network_id	integer	false	Filter tokens by network

Response example:

application/json

{
  "data": [
    {
      "network_id": 1,
      "name": "Tether USD",
      "contract_address": "0xdac17f958d2ee523a2206206994597c13d831ec7",
      "symbol": "USDT",
      "icon_url": "https://cdn.changelly.com/defi/icons/1/tokens/usdt.png",
      "wrapped_token_address": null
    }
  ],
  "pagination": {
    "limit": 10,
    "offset": 0,
    "pages": 10,
    "total": 500
  }
}

Note: If a token has a non-empty wrapped_token_address in the response, the token must be wrapped before use.

---

Quotes

Get the Best Quote

Retrieve the best available swap quote for a given source token, destination token, and amount. This endpoint returns pricing details, limits, and metadata required to proceed with a swap.

Quotes are time-limited and must be executed before they expire.

POST /affiliate/v1/quotes/best

Request example:

application/json

{
  "source_chain": 1,
  "source_token": "0xc02aaa3********9083c756cc2",
  "dest_chain": 4,
  "dest_token": "So11111111111111111111111111111111111111112",
  "amount": 100,
  "slippage_bps": "50",
  "swap_type": "standard",
  "retail_user_id": "fe5601fb-60f2-4cb0-8a67-c55bd3640411"
}

Request Notes:

• amount must be specified in decimal-adjusted format.
• slippage_bps is expressed in basis points and must be sent as a string.
• retail_user_id is optional and can be used for analytics and user-level tracking.

Response example:

application/json

{
  "id": "bea66e69-64c3-4b88-96ac-29f1ce7d454d",
  "source_chain": 1,
  "source_token": "0xdac17f9********13d831ec7",
  "dest_chain": 4,
  "dest_token": "So11111111111111111111111111111111111111112",
  "intermediate_token": null,
  "intermediate_token_amount_min": null,
  "intermediate_token_amount_max": null,
  "intermediate_token_decimals": null,
  "source_amount_lots": "100000000",
  "source_amount_decimals": 6,
  "min_dest_amount_lots": "857382336",
  "max_dest_amount_lots": "861690790",
  "dest_amount_decimals": 9,
  "slippage_bps": "50",
  "expiry": 1769777954084,
  "swap_type": "standard"
}

Quote Expiry:

The expiry field is a Unix timestamp in milliseconds (ms since epoch). After this timestamp, the quote is no longer valid and must be refreshed. Quotes should always be executed before expiry to guarantee pricing.

Intermediate Token Routing:

If the user attempts to swap a volatile token, the system may automatically route the swap through a highly liquid intermediate token, typically USDC, to improve execution reliability and manage price volatility. All fields prefixed with intermediate_ describe this routing behavior and the token used internally.

---

Intents

An intent represents a user's request to perform a swap and can only be created based on a quote, to which it is attached. It defines what the user wants to do, while the protocol handles how it gets executed.

Intents are chain-agnostic and support multiple blockchains and approval mechanisms.

Intent lifecycle

A typical intent goes through the following steps:

1. Creation - An intent is created via the API with swap parameters such as source chain, destination chain, tokens, and amounts.
2. Approval - The user authorizes fund usage using a chain-specific approval mechanism (for example, Permit2 on EVM, PSBT on Bitcoin, Cosigned transaction on Solana).
3. Execution - Once approved, the resolver processes the intent and executes the swap.
4. Status tracking - The intent status can be queried at any time to track progress or final outcome.

---

Create Intent

Create a new swap intent that describes what the user wants to swap. An intent is created off-chain and later executed on-chain by a resolver.

POST /affiliate/v1/intents

Request:

application/json

{
  "quote_id": "fe5601fb-60f2-4cb0-8a67-c55bd3640411",
  "refund_address": "0x000000000000000000000000000000000000000",
  "retail_user_id": "fe5601fb-60f2-4cb0-8a67-c55bd3640411",
  "user_destination_address": "0x000000000000000000000000000000000000000",
  "user_source_address": "0x000000000000000000000000000000000000000",
  "user_source_public_key": "00000000000000000000000000000000000000"
}

Request notes:

• retail_user_id is optional and can be used for analytics and user-level tracking.
• user_source_public_key is a required field only if source chain is Bitcoin or Solana.

Response example (EVM and Tron):

application/json

{
  "intent_id": "8a2d3f92-2a2b-4e4c-9d8a-3c9f92e4a111",
  "deadline_secs": 1761545456,
  "secret_hash": "0x000000000000000000000000000000000000000000000000000000000000000",
  "approval_mechanism": "permit2",
  "params_to_sign": {
    "escrow_contract_address": "0x000000000000000000000000000000000000000",
    "permit2_contract_address": "0x000000000000000000000000000000000000000",
    "resolver_deposit_address": "0x000000000000000000000000000000000000000",
    "nonce": 10000,
    "additional_data": {
      "domain": { /* EIP-712 domain data */ },
      "types": { /* EIP-712 types */ },
      "witness": { /* witness data */ },
      "witness_type_string": "ExampleTrade witness)ExampleTrade(address exampleTokenAddress,uint256 exampleMinimumAmountOut)",
      "witness_hash": "0x000000000000000000000000000000000000000000000000000000000000000"
    }
  }
}

Approval Mechanism

The approval flow depends on the blockchain and swap type. The value of approval_mechanism may change, and the structure of params_to_sign depends on the selected approval mechanism. Clients must always check approval_mechanism and handle params_to_sign accordingly.

Approval Mechanism Examples:

Permit2 (used for EVM-based blockchains):

application/json

{
  "intent_id": "528d72ae-61cd-4fbc-9940-48ce4104abbb",
  "deadline_secs": 1772124002,
  "secret_hash": "0x19875e12d834bc24********44dd26f37d367a44926",
  "approval_mechanism": "permit2",
  "params_to_sign": {
    "escrow_contract_address": "0x8DcbE1aCf********18F8e8836",
    "permit2_contract_address": "0x0000000********6B43aC78BA3",
    "resolver_deposit_address": "0xF3B3a4edB********f69f557029",
    "nonce": 499,
    "additional_data": {
      "domain": { /* EIP-712 domain data */ },
      "types": { /* EIP-712 types */ },
      "witness": { /* witness data */ },
      "secretHash": "0xabcde...",
      "witness_type_string": "DepositWitness witness)DepositWitness(address resolverDepositAddress,bytes32 secretHash,uint256 deadline)TokenPermissions(address token,uint256 amount)",
      "witness_hash": "0xc77ff4a96e********b8c12636c39f7f"
    }
  }
}

HTLC (used for Bitcoin blockchain):

application/json

{
  "approval_mechanism": "htlc",
  "params_to_sign": {
    "psbt": "cHNidP8BAJ0CAAAAAQEBAQEB...",
    "inputs": [0, 1, 2]
  }
}

Cosigned transaction (used for Solana blockchain):

application/json

{
  "intent_id": "0a47fbd6-056a-4e4d-a1e3-9b9a1bf947e5",
  "deadline_secs": 1772124152,
  "secret_hash": "0x84edcf7********dd0fb60baccf",
  "approval_mechanism": "cosign",
  "params_to_sign": {
    "transaction": "02000..."
  }
}

---

Approvals

After an intent is created, an approval must be added before it can be executed. This endpoint attaches a signed approval to an existing intent. The approval proves the user has authorized the swap and allows it to proceed.

POST /affiliate/v1/intents/{intent_id}/approvals

Request Body

The request body depends on the approval mechanism. It includes the approval type and the signed data generated by the user.

Permit2 (EVM):

application/json

{
  "type": "permit2",
  "signed_data": "0x..."
}

signed_data is the Permit2 signature.

Possible errors: If the backend returns error code 25, the user has not approved Permit2 yet for the selected token. The user must approve Permit2 on-chain before continuing.

PSBT (Bitcoin):

application/json

{
  "type": "psbt",
  "signed_data": "cHNid..."
}

signed_data is a signed PSBT.

Cosign (Solana):

application/json

{
  "type": "cosign",
  "signed_data": {
    "transaction": "02000...",
    "user_address": "F8ZRdxv********ETTDFg"
  }
}

signed_data.transaction is a signed versioned transaction.

---

Signing an Intent for EVM

Permit2 lets the user lock tokens and generate a signature to authorize a swap. Tokens stay secure until the swap is executed, either on the same chain or across chains. The resolver uses this signature to move funds into escrow and complete the swap.

Script to create a Permit2 signature:

import { privateKeyToAccount } from 'viem/accounts';
import { ChangellyDeFiClient } from '@changelly/defi-api-sdk-ts';
import { preparePermit2Approval } from '@changelly/defi-api-sdk-ts';
import {
  type DepositType,
  type Permit2ApprovalToSign,
  type SignedApproval,
  SwapType,
} from '@changelly/defi-api-sdk-ts';

async function main() {
  const apiKey = process.env['API_KEY'];
  const privateKey = process.env['PRIVATE_KEY'];
  const destinationAddress = process.env['DESTINATION_ADDRESS'];

  if (!apiKey) {
    throw new Error('API_KEY environment variable is not set');
  }
  if (!privateKey) {
    throw new Error('PRIVATE_KEY environment variable is not set');
  }
  if (!destinationAddress) {
    throw new Error('DESTINATION_ADDRESS environment variable is not set');
  }

  const account = privateKeyToAccount(privateKey as `0x${string}`);

  // Initialize the Changelly DeFi API client with the API key
  const client = new ChangellyDeFiClient(
    'https://dex-api.changelly.com/affiliate',
    apiKey
  );

  // Example parameters for getting a quote
  const sourceChain = 1;        // Ethereum mainnet
  const sourceToken = '0xc02aaa39********83c756cc2'; // WETH
  const destChain = 2;          // Tron mainnet
  const destToken = 'TR7NHq********8otSzgjLj6t';          // USDT on Tron
  const amount = 0.001;         // Amount in WETH
  const slippageBps = 50n;      // 0.5% slippage
  const swapType = SwapType.Standard;
  const depositType: DepositType = 'escrowed';

  // Get a quote for the swap
  console.log('Getting quote...');
  const quote = await client.getQuote(
    sourceChain,
    sourceToken,
    destChain,
    destToken,
    amount,
    slippageBps,
    swapType,
    null,  // retail user id
    depositType,
  );
  console.log('Quote received:', quote);

  // Set user addresses
  const userSourceAddress = account.address;
  const userDestinationAddress = destinationAddress;
  const refundAddress = account.address;

  // Create an intent based on the quote
  console.log('Creating intent...');
  const intentData = await client.createIntent(
    quote.id,
    null,  // userSourcePublicKey (null for EVM)
    userSourceAddress,
    userDestinationAddress,
    refundAddress,
  );
  console.log('Intent created:', intentData);

  // Prepare the permit2 approval for signing
  const permit2Approval = preparePermit2Approval(
    intentData.params_to_sign as Permit2ApprovalToSign,
    quote,
    userSourceAddress,
    intentData.deadline_secs,
  );
  console.log('Permit2 approval prepared:', permit2Approval);

  const signature = await account.signTypedData(permit2Approval);
  const signedApproval: SignedApproval = {
    type: 'permit2',
    signed_data: signature,
  };

  // Add the approval to the intent
  console.log('Adding approval...');
  await client.addApproval(signedApproval, intentData.intent_id);
  console.log('Approval added');
}

await main()
  .then(() => console.log('Example completed'))
  .catch(console.error);

---

Signing an Intent for Tron

Permit2 on Tron lets the user lock tokens and generate a signature to authorize a swap. Tokens remain secure until the resolver executes the swap, either on Tron or across chains, using the signature to move funds into escrow.

Script to create a Permit2 signature:

import { TronWeb } from 'tronweb';
import { ChangellyDeFiClient } from '@changelly/defi-api-sdk-ts';
import { preparePermit2Approval } from '@changelly/defi-api-sdk-ts';
import {
  type DepositType,
  type Permit2ApprovalToSign,
  type SignedApproval,
  SwapType,
} from '@changelly/defi-api-sdk-ts';

async function main() {
  const apiKey = process.env['API_KEY'];
  const privateKey = process.env['PRIVATE_KEY'];
  const destinationAddress = process.env['DESTINATION_ADDRESS'];

  if (!apiKey) {
    throw new Error('API_KEY environment variable is not set');
  }
  if (!privateKey) {
    throw new Error('PRIVATE_KEY environment variable is not set');
  }
  if (!destinationAddress) {
    throw new Error('DESTINATION_ADDRESS environment variable is not set');
  }

  const tronWeb = new TronWeb({
    fullHost: 'https://api.trongrid.io',
    privateKey: privateKey,
  });

  // Initialize the Changelly DeFi API client with the API key
  const client = new ChangellyDeFiClient(
    'https://dex-api.changelly.com/affiliate',
    apiKey
  );

  // Example parameters for getting a quote
  const sourceChain = 2;        // Tron mainnet
  const sourceToken = 'TR7********Lj6t'; // USDT on Tron
  const destChain = 1;          // Ethereum mainnet
  const destToken = '0xc02a********c756cc2'; // WETH
  const amount = 2;             // Amount in USDT
  const slippageBps = 50n;      // 0.5% slippage
  const swapType = SwapType.Standard;
  const depositType: DepositType = 'escrowed';

  // Get a quote for the swap
  console.log('Getting quote...');
  const quote = await client.getQuote(
    sourceChain,
    sourceToken,
    destChain,
    destToken,
    amount,
    slippageBps,
    swapType,
    null,  // retail user id
    depositType,
  );
  console.log('Quote received:', quote);

  // Set user addresses
  const userSourceAddress = tronWeb.address.fromPrivateKey(privateKey);
  const userDestinationAddress = destinationAddress;
  const refundAddress = tronWeb.address.fromPrivateKey(privateKey);

  if (!userSourceAddress || !refundAddress) {
    throw new Error('User source address or refund address is invalid');
  }

  // Create an intent based on the quote
  console.log('Creating intent...');
  const intentData = await client.createIntent(
    quote.id,
    null,
    userSourceAddress,
    userDestinationAddress,
    refundAddress,
  );
  console.log('Intent created:', intentData);

  // Prepare the permit2 approval for signing
  const permit2Approval = preparePermit2Approval(
    intentData.params_to_sign as Permit2ApprovalToSign,
    quote,
    userSourceAddress,
    intentData.deadline_secs,
  );
  console.log('Permit2 approval prepared:', permit2Approval);

  const signature = tronWeb.trx.signTypedData(
    permit2Approval.domain,
    permit2Approval.types,
    permit2Approval.message,
    privateKey,
  );

  const signedApproval: SignedApproval = {
    type: 'permit2',
    signed_data: signature,
  };

  // Add the approval to the intent
  console.log('Adding approval...');
  await client.addApproval(signedApproval, intentData.intent_id);
  console.log('Approval added');
}

await main()
  .then(() => console.log('Example completed'))
  .catch(console.error);

---

Signing an Intent for Solana

Versioned transaction cosigning allows the user to authorize a swap by signing a prebuilt Solana transaction that encodes the exact execution parameters. The transaction is generated from a quote, signed locally by the user while preserving required signature order, and returned as an approval for execution. Funds remain secure until the resolver executes the swap according to the authorized transaction.

Script to cosign a versioned transaction on Solana:

import { Keypair, VersionedTransaction } from '@solana/web3.js';
import bs58 from 'bs58';
import { ChangellyDeFiClient } from '@changelly/defi-api-sdk-ts';
import {
  type CosignApprovalToSign,
  type DepositType,
  type SignedApproval,
  SwapType,
} from '@changelly/defi-api-sdk-ts';

async function main() {
  const apiKey = process.env['API_KEY'];
  const privateKey = process.env['PRIVATE_KEY'];
  const destinationAddress = process.env['DESTINATION_ADDRESS'];

  if (!apiKey) {
    throw new Error('API_KEY environment variable is not set');
  }
  if (!privateKey) {
    throw new Error('PRIVATE_KEY environment variable is not set');
  }
  if (!destinationAddress) {
    throw new Error('DESTINATION_ADDRESS environment variable is not set');
  }

  const secretKeyBytes = bs58.decode(privateKey);
  const keypair = Keypair.fromSecretKey(secretKeyBytes);

  // Initialize the Changelly DeFi API client with the API key
  const client = new ChangellyDeFiClient(
    'https://dex-api.changelly.com/affiliate',
    apiKey
  );

  // Example parameters for getting a quote
  const sourceChain = 4;        // Solana mainnet
  const sourceToken = 'So11111111111111111111111111111111111111112'; // WSOL
  const destChain = 1;          // Ethereum mainnet
  const destToken = '0xc02aaa3********9083c756cc2'; // WETH
  const amount = 0.01;          // Amount in WSOL
  const slippageBps = 50n;      // 0.5% slippage
  const swapType = SwapType.Standard;
  const depositType: DepositType = 'escrowed';

  // Get a quote for the swap
  console.log('Getting quote...');
  const quote = await client.getQuote(
    sourceChain,
    sourceToken,
    destChain,
    destToken,
    amount,
    slippageBps,
    swapType,
    null,  // retail user id
    depositType,
  );
  console.log('Quote received:', quote);

  // Set user addresses
  const userSourceAddress = keypair.publicKey.toBase58();
  const userDestinationAddress = destinationAddress;
  const refundAddress = keypair.publicKey.toBase58();

  // Create an intent based on the quote
  console.log('Creating intent...');
  const intentData = await client.createIntent(
    quote.id,
    null,  // userSourcePublicKey (null for Solana)
    userSourceAddress,
    userDestinationAddress,
    refundAddress,
  );
  console.log('Intent created:', intentData);

  const { transaction } = intentData.params_to_sign as CosignApprovalToSign;

  // Decode hex-encoded transaction from the backend
  const bytes = Uint8Array.from(Buffer.from(transaction, 'hex'));

  // Construct VersionedTransaction
  const tx = VersionedTransaction.deserialize(bytes);

  // Save old signatures that might be overwritten by `tx.sign`
  const signatures = [...tx.signatures];
  tx.sign([keypair]);

  // Adjust signature positions: user's signature must appear at position 1,
  // resolver's signature must appear at position 0,
  // and optionally backend signature must appear at position 2.
  tx.signatures[0] = signatures[0];
  if (tx.signatures[2] !== undefined) {
    tx.signatures[2] = signatures[2];
  }

  const signedApproval: SignedApproval = {
    type: 'cosign',
    signed_data: {
      transaction: Buffer.from(tx.serialize()).toString('hex'),
      user_address: keypair.publicKey.toBase58(),
    },
  };

  // Add the approval to the intent
  console.log('Adding approval...');
  await client.addApproval(signedApproval, intentData.intent_id);
  console.log('Approval added');
}

await main()
  .then(() => console.log('Example completed'))
  .catch(console.error);

---

Signing an Intent for Bitcoin

PSBT cosigning allows a user to authorize a Bitcoin HTLC deposit by signing only the inputs they control. The transaction is generated by the protocol, and the user signs it locally while preserving any existing partial signatures. The signed PSBT is returned as an approval, keeping funds secure until the resolver executes the swap according to the authorized transaction parameters.

PSBT Signing Process:

The signing procedure consists of the following steps:

1. Parse the Base64-encoded PSBT into a structured PSBT object.
2. Decode the private key from its serialized format (e.g., hex) into a usable signing key.
3. Iterate over the specified input indices that require signing.
4. For each input, obtain the referenced UTXO information directly from the PSBT (amount, script, and Taproot-related data if applicable).
5. For each selected input, compute the appropriate signature hash and produce a Taproot (Schnorr) witness signature.
6. Insert the generated signatures into the corresponding input fields without modifying other transaction data.
7. Serialize the updated PSBT back into Base64 format for further processing or submission.

Script to sign a PSBT with Changelly DeFi Golang SDK:

package main

import (
	"fmt"
	"log"

	"github.com/changelly/defi-api-sdk-go/crypto/bitcoin"
	"github.com/changelly/defi-api-sdk-go/types"
)

func main() {
	var (
		signerPrivateKeyHex = os.Getenv("PRIVATE_KEY")

		// NOTE: mocking createIntent response since psbt and inputs are part of it.
		approvalToSign = types.ApprovalToSign{
			ApprovalMechanism: types.ApprovalToSignTypeHtlc,
			Htlc: &types.ApprovalToSignHtlc{
				Psbt:   "your-psbt-base64",    // Replace with your base64-encoded PSBT.
				Inputs: []int{0, 1, 2},         // Indices of the inputs you need to sign.
			},
		}
	)

	// 1. Initialize the signer
	signer, err := bitcoin.NewSigner(signerPrivateKeyHex)
	if err != nil {
		log.Fatalf("failed to create signer: %v", err)
	}

	// 2. Sign the deposit transaction
	signedPsbtBase64, err := bitcoin.SignDepositTx(
		signer,
		approvalToSign.Htlc.Psbt,
		approvalToSign.Htlc.Inputs,
	)
	if err != nil {
		log.Fatalf("failed to sign deposit tx: %v", err)
	}

	// 3. Use the signed PSBT as an approval.
	// NOTE: signedPsbtBase64 should be provided back to the protocol
	// via `add-approval` API call.
	fmt.Println("Signed PSBT Base64:", signedPsbtBase64)
	intentApproval = types.NewHtlcIntentApproval(signedPsbtBase64)

	// Propagate approval to the Changelly DeFi API and fetch the status.
}

Signing with TypeScript:

Most wallets provide a signPsbt method that handles all cryptographic operations internally. Using Sats Connect, you can sign a Base64-encoded PSBT for the inputs you control and receive a signed PSBT ready to return to the protocol.

import { request, RpcErrorCode } from "sats-connect";

/**
 * Signs a Base64 PSBT (or with another Sats Connect compatible wallet).
 *
 * @param psbtBase64  Base64-encoded PSBT from the API response
 * @param signInputs  Map: address -> input indexes to sign, from the API response
 * @returns signed PSBT (Base64)
 */
export async function signPsbt(
  psbtBase64: string,
  signInputs: Record<string, number[]>
): Promise<string> {
  const response = await request("signPsbt", {
    psbt: psbtBase64,
    signInputs,
    broadcast: false,
  });

  if (response.status === "success") {
    return response.result.psbt;
  }

  throw new Error(
    `PSBT signing failed: ${response.error.message ?? "Unknown error"}`
  );
}

---

Retrieving Intent Status

This endpoint allows you to check the current status of a swap intent. It provides the intent's lifecycle state, associated transactions, and additional metadata.

GET /affiliate/v1/intents/{intent_id}/status

Response Example:

application/json

{
  "intent_id": "fe5601fb-60f2-4cb0-8a67-c55bd3640411",
  "status": "UserDeposited",
  "swap_metadata": {
    "id": "19b44362-bc4d-4b2e-824f-f712c6c80eff",
    "proxy_address": "0x000000000000000000000000000000000000000",
    "user_deposit_tx": "0x000000000000000000000000000000000000000",
    "fulfill_tx": null,
    "swap_tx": null,
    "created_at": "2026-01-15T12:00:00Z",
    "user_deposited_at": "2026-01-15T12:05:00Z",
    "fulfilled_at": null,
    "swapped_at": null,
    "refunded_at": null
  },
  "source_amount_decimals": 18,
  "source_amount_lots": "123456",
  "source_chain": 1,
  "source_token": "0x000000000000000000000000000000000000000",
  "dest_amount_decimals": 6,
  "dest_chain": 2,
  "dest_token": "0x000000000000000000000000000000000000000",
  "min_dest_amount_lots": "123456",
  "max_dest_amount_lots": "123456"
}

The status field represents the overall progress of the swap, combining both intent and swap state.

Possible swap statuses:

Status	Description
Initiated	The intent has been created but no approval has been added yet.
ApprovalAdded	User has added approval/signature for the swap.
Accepted	Resolver has accepted the intent and is ready to execute.
Declined	The intent was declined by the resolver.
UserDeposited	Resolver has deposited user tokens on source network into the escrow.
Fulfilled	User has received funds on destination network in target token.
Expired	The intent expired before execution.
RefundRequested	A refund has been requested for this intent.
Refunded	Tokens have been refunded to the user.

Additional Notes:

• Use this endpoint to poll the status of an intent or check its progress.
• swap_metadata provides transaction hashes and timestamps to track each stage.

---

Swap History

Retrieve the swap history for specific wallet addresses or retail user. This endpoint returns a paginated list of swaps along with their current status and metadata.

GET /affiliate/v1/swaps/history

Query Params:

Name	Type	Required	Description
limit	integer	false	Maximum number of swaps to return
offset	integer	false	Number of swaps to skip before starting to return results
active	bool	false	Filter for active swaps
wallet	string[]	false	Wallets to query history for. Example: wallet=1&wallet=2
retail_id	string	false	Retail user ID to query history for

Note: Either wallet array or retail_id must be specified. Failing to specify either will result in a client error.

Response Example:

application/json

{
  "items": [
    {
      "intent_id": "fe5601fb-60f2-4cb0-8a67-c55bd3640411",
      "status": "UserDeposited",
      "swap_metadata": {
        "id": "19b44362-bc4d-4b2e-824f-f712c6c80eff",
        "proxy_address": "0x000000000000000000000000000000000000000",
        "user_deposit_tx": "0x000000000000000000000000000000000000000",
        "fulfill_tx": null,
        "swap_tx": null,
        "created_at": "2026-01-15T12:00:00Z",
        "user_deposited_at": "2026-01-15T12:05:00Z",
        "fulfilled_at": null,
        "swapped_at": null,
        "refunded_at": null
      },
      "source_amount_decimals": 18,
      "source_amount_lots": "123456",
      "source_chain": 1,
      "source_token": "0x000000000000000000000000000000000000000",
      "dest_amount_decimals": 6,
      "dest_chain": 2,
      "dest_token": "0x000000000000000000000000000000000000000",
      "min_dest_amount_lots": "123456",
      "max_dest_amount_lots": "123456"
    }
  ],
  "limit": 20,
  "offset": 0,
  "total": 1,
  "pages": 1
}

---

System Health Check

Use this endpoint to verify that the system is up and ready to accept requests. It does not return any data, it only confirms that the API is healthy and responsive.

GET /v1/system/live

Response:

Status	Meaning
200 OK	System is healthy and ready to process requests
500 Internal Server Error	The system is experiencing issues