Integrate any bot: keyless, keyed, ethers, viem, Python, and AI agents

The quote API is a plain HTTPS GET with open CORS and no key, so every bot runtime that can make an HTTP request is already compatible. Below is the same swap — WETH → USDC on Base — in every shape a bot might take. Pick your stack; the response is identical.

Keyless bot (any language, zero dependencies)

The lowest common denominator: plain fetch, no SDK, no key — any public RPC endpoint is enough for the one eth_call. Perfect for serverless functions, Telegram/Discord webhooks and edge workers.

const API = 'https://blazephoenix.xyz/api/quote';
const post = (u, b) => fetch(u, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(b) }).then(r => r.json());
const prep = await fetch(API + '/prepare?chain=base&in=WETH&out=USDC&amountIn=1000000000000000000').then(r => r.json());
const { result } = await post(RPC_URL, prep.rpcRequest);              // the eth_call, on your RPC
const q = await post(API + '/decode', { request: prep.request, result });
console.log(q.amountOut, q.checks.verdict);   // net output + Phoenix Check

Keyed-RPC server bot (your own node, signing server-side)

Bots that sign with their OWN funds keep their existing keyed RPC: your node runs the quote call and broadcasts the swap, the API only prepares and decodes. Add recipient to get a ready tx; your provider key never touches us.

const API = 'https://blazephoenix.xyz/api/quote';
const prep = await fetch(API + '/prepare?chain=base&in=WETH&out=USDC'
  + '&amountIn=1000000000000000000&recipient=' + wallet.address + '&slippageBps=50'
).then(r => r.json());
const result = await provider.send('eth_call', prep.rpcRequest.params);   // YOUR keyed node
const q = await fetch(API + '/decode', { method: 'POST', headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ request: prep.request, result }) }).then(r => r.json());
// q.tx = { to, data, value } — broadcast with YOUR keyed provider:
const hash = await wallet.sendTransaction(q.tx);

ethers v6 / viem (modern signers)

The tx object the API returns is provider-agnostic — it drops straight into ethers v6 (wallet.sendTransaction), viem (walletClient.sendTransaction), or ethers v5 with the same shape. No adapter needed.

// viem
import { createWalletClient, http } from 'viem';
import { base } from 'viem/chains';
const client = createWalletClient({ account, chain: base, transport: http() });
await client.sendTransaction(q.tx);
// ethers v6:  await signer.sendTransaction(q.tx);

Python (web3.py, trading & research bots)

Python bots run the same three steps with requests; the decoded tx dict is consumed directly by web3.py. Ideal for screeners and quant research where the data, not the signing, is the point.

import requests
B = 'https://blazephoenix.xyz/api/quote'
prep = requests.get(B + '/prepare', params={
  'chain': 'base', 'in': 'WETH', 'out': 'USDC', 'amountIn': 10**18,
  'recipient': acct.address, 'slippageBps': 50,
}).json()
result = '0x' + w3.eth.call(prep['call']).hex().removeprefix('0x')   # the eth_call, on YOUR node
q = requests.post(B + '/decode', json={'request': prep['request'], 'result': result}).json()
tx = q['tx']; tx['nonce'] = w3.eth.get_transaction_count(acct.address)
signed = acct.sign_transaction(tx); w3.eth.send_raw_transaction(signed.rawTransaction)

AI agents (LLM function-calling — a first-class citizen)

Autonomous agents do not read docs; they read tool schemas. The shortest route is the hosted MCP server at https://blazephoenix.xyz/mcp, whose prepare_quote and decode_quote tools carry their own schemas. For plain function-calling, this definition wraps the prepare step and leaves the eth_call to the agent's own node; the discovery root (/api), the OpenAPI spec (/api/openapi.json) and /llms.txt let it self-configure the rest.

{
  "name": "blazephoenix_prepare_quote",
  "description": "Prepare an on-chain DEX aggregator quote (no key): returns the eth_call to run on your own node and a request object to POST with the result to /api/quote/decode.",
  "parameters": { "type": "object", "required": ["chain","in","out","amountIn"], "properties": {
    "chain": { "type": "string", "enum": ["base","eth","optimism","arbitrum","robinhood"] },
    "in":  { "type": "string", "description": "0x token address, or ETH/WETH/USDC/BZPX" },
    "out": { "type": "string" },
    "amountIn": { "type": "string", "description": "integer base units (wei-style)" },
    "recipient": { "type": "string", "description": "0x address: the decoded quote then includes tx {to,data,value}" }
  } },
  "url": "https://blazephoenix.xyz/api/quote/prepare"
}

One rule for every runtime

Whatever the stack: preview freely (identical concurrent requests coalesce, previews edge-cache ~1 block), but the number you SIGN should be a fresh request carrying recipient and, for size, exact=1 — those are never TTL-cached, because anything executable must never be stale. Zero-custody bots skip signing entirely and hand the user a deep link. The API does not care which you are; it answers all of them the same.