LLM for Agents API

Getting Started

1. Register your agent

   Create an agent account and receive your API key. Store it securely -- it is shown only once.

   Copycurl -X POST https://api.llm4agents.com/api/v1/agents/register \
     -H "Content-Type: application/json" \
     -d '{"name": "my-agent"}'

   Response:

   Copy{
     "uuid": "a1b2c3d4-...",
     "apiKey": "sk-proxy-abc123...",
     "name": "my-agent",
     "createdAt": "2026-04-14T12:00:00.000Z",
     "requestId": "req_..."
   }

2. Add funds

   Generate a deposit wallet, then send USDT or USDC on Solana or Polygon. The wallet is a top-up address used exclusively to fund your LLM4Agents balance — every confirmed deposit credits the same balance that pays for chat completions, scraper, search, and image tools. Funds are credited automatically after on-chain verification. Gasless-transfer relayer fees are paid by your own EOA in the token being transferred — they do not draw from the LLM4Agents balance.

   Copycurl -X POST https://api.llm4agents.com/api/v1/wallets/generate \
     -H "Authorization: Bearer YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"chain": "solana", "token": "USDC"}'

3. Start using the API

   Point any OpenAI-compatible SDK at the proxy and start making requests.

   Python Node.js cURL

   Copyfrom openai import OpenAI
   
   client = OpenAI(
       base_url="https://api.llm4agents.com/v1",
       api_key="your-api-key"
   )
   
   response = client.chat.completions.create(
       model="anthropic/claude-3-haiku",
       messages=[{"role": "user", "content": "Hello!"}]
   )
   print(response.choices[0].message.content)

   Copyimport OpenAI from 'openai';
   
   const client = new OpenAI({
     baseURL: 'https://api.llm4agents.com/v1',
     apiKey: 'your-api-key',
   });
   
   const response = await client.chat.completions.create({
     model: 'anthropic/claude-3-haiku',
     messages: [{ role: 'user', content: 'Hello!' }],
   });
   console.log(response.choices[0].message.content);

   Copycurl https://api.llm4agents.com/v1/chat/completions \
     -H "Authorization: Bearer your-api-key" \
     -H "Content-Type: application/json" \
     -d '{
       "model": "anthropic/claude-3-haiku",
       "messages": [{"role": "user", "content": "Hello!"}]
     }'

Authentication

All authenticated endpoints require an Authorization header with a Bearer token:

CopyAuthorization: Bearer sk-proxy-abc123...

TypeScript SDK

@llm4agents/sdk is the official TypeScript SDK for the platform. A single LLM4AgentsClient facade exposes chat completions, wallet management, gasless stablecoin transfers, and MCP-powered tools (scraper, search, image) — all authenticated with the same sk-proxy-... bearer key.

• Repo: github.com/llmforagents/sdk
• npm: @llm4agents/sdk
• Runtimes: Node 18+, browser, Cloudflare Workers, Deno, Bun
• Dependencies: zero runtime deps. ethers ^6 is an optional peer dep, only required for client.transfer.

Install

Copynpm install @llm4agents/sdk

# Optional — only required for client.transfer (gasless transfers)
npm install ethers

Copypnpm add @llm4agents/sdk
pnpm add ethers   # optional, gasless transfers only

Copyyarn add @llm4agents/sdk
yarn add ethers   # optional, gasless transfers only

Copybun add @llm4agents/sdk
bun add ethers   # optional, gasless transfers only

Initialize

Copyimport { LLM4AgentsClient } from '@llm4agents/sdk';

const client = new LLM4AgentsClient({
  apiKey: process.env.LLM4AGENTS_API_KEY!,
  // Optional overrides:
  baseUrl: 'https://api.llm4agents.com',
  mcpUrl:  'https://mcp.llm4agents.com/mcp',
  timeout: 30_000,
});

Chat — completions, streaming, tool-loop conversations

Thin wrapper over POST /v1/chat/completions, plus a higher-level conversation() helper that maintains history and auto-executes MCP tool calls.

Copy// Single completion
const res = await client.chat.completions.create({
  model: 'anthropic/claude-sonnet-4',
  messages: [{ role: 'user', content: 'Hello' }],
});

// Streaming
const stream = await client.chat.completions.create({
  model: 'anthropic/claude-sonnet-4',
  messages: [{ role: 'user', content: 'Count to 10' }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}

// Conversation with auto tool-execution loop
const conv = client.chat.conversation({
  model:  'anthropic/claude-sonnet-4',
  system: 'You are a research assistant',
  tools:  client.tools,
  onToolCall:   (name, args) => { console.log(`→ ${name}`); return true; },
  onToolResult: (name, result) => { console.log(`✓ ${name} (${result.length} chars)`); },
  maxToolRounds: 5,
});

const answer = await conv.say('Search for Bitcoin news and summarize the top 3');
console.log(answer.content);
console.log(answer.toolCalls); // ToolCallRecord[]

// Streaming conversation — typed StreamEvent
const events = await conv.stream('Now find the current price');
for await (const ev of events) {
  switch (ev.type) {
    case 'text':       process.stdout.write(ev.content); break;
    case 'tool_start': console.log(`\n[tool] ${ev.name}`); break;
    case 'tool_end':   console.log(`[done] ${ev.durationMs}ms`); break;
    case 'done':       console.log('\n', ev.response.usage); break;
  }
}

// History is a JSON-serializable array — persist anywhere
const saved = conv.messages;          // readonly ChatMessage[]
const rehydrated = client.chat.conversation({ model: '...', history: saved });

Wallets — generate, balance, transactions

Generated wallets are deposit-only top-up addresses for your LLM4Agents balance. Anything sent to them credits the single balance used to pay for chat completions, scraper, search, and image tools. Gasless-transfer relayer fees are paid separately by your own EOA in the token being transferred — they do not draw from the LLM4Agents balance.

Copyconst wallet = await client.wallets.generate({
  chain: 'polygon',
  token: 'USDC',
});
console.log(wallet.address);

const balance = await client.wallets.balance();
console.log(balance.availableUsd);
console.log(balance.wallets); // per-chain/token breakdown

const page = await client.wallets.transactions({ limit: 20, type: 'deposit' });
for (const tx of page.transactions) {
  console.log(`${tx.type}: $${tx.amountUsd} — ${tx.description}`);
}

Gasless transfers — non-custodial stablecoin sends

The SDK signs locally with the user's private key (via the ethers peer dep) and submits to POST /v1/tx/send. The platform never touches the key. See Gasless TX for the full flow and supported chains/tokens.

Copy// One-call: quote + sign + submit
const result = await client.transfer.send({
  chain: 'polygon',
  token: 'USDC',
  to: '0xRecipient...',
  amount: '10.50',
  privateKey: process.env.EOA_PRIVATE_KEY!,
});
console.log(result.txHash, result.explorerUrl);

// Two-step: inspect the operator fee before signing
const quote = await client.transfer.quote({
  chain: 'polygon', token: 'USDC',
  from: '0xSender...', to: '0xRecipient...', amount: '10.50',
});
console.log(`Fee: ${quote.feeFormatted}`);
const submitted = await client.transfer.submit(quote, process.env.EOA_PRIVATE_KEY!);

MCP tools — scraper, search, image

Typed wrappers over the MCP Streamable HTTP endpoint at mcp.llm4agents.com/mcp. Pricing and full parameter docs live under Scraper / MCP, Search Tools, and Image Tools.

Copy// Scraper (headless browser)
const html = await client.tools.scraper.fetchHtml({ url: 'https://example.com' });
const md   = await client.tools.scraper.markdown({ url: 'https://example.com' });
const shot = await client.tools.scraper.screenshot({ url: 'https://example.com', fullPage: true });

// Search (Google via Serper)
const results = await client.tools.search.google({ q: 'TypeScript SDK design' });
const news    = await client.tools.search.googleNews({ q: 'Bitcoin', tbs: 'qdr:d' });
const places  = await client.tools.search.googleMaps({ q: 'coffee near me' });

// Image (generate, edit, analyze)
const img      = await client.tools.image.generate({ prompt: 'A robot writing code' });
const edited   = await client.tools.image.edit({ prompt: 'Make it blue', imageUrl: '...' });
const analysis = await client.tools.image.analyze({ prompt: 'What is this?', imageUrl: '...' });

// Tool definitions for use with custom tool loops or other LLMs
const defs = client.tools.definitions; // ToolDefinition[]

Models

Copyconst models = await client.models.list();
for (const m of models) {
  console.log(`${m.slug} — $${m.inputPricePer1m}/1M in, $${m.outputPricePer1m}/1M out`);
}

Error handling

Every failure surfaces as a single LLM4AgentsError with a stable code, the upstream statusCode (when applicable), and the requestId from the x-request-id response header.

Copyimport { LLM4AgentsError } from '@llm4agents/sdk';

try {
  await client.chat.completions.create({ model: '...', messages: [...] });
} catch (err) {
  if (err instanceof LLM4AgentsError) {
    switch (err.code) {
      case 'insufficient_balance': /* top up */ break;
      case 'rate_limited':         /* back off */ break;
      case 'model_not_found':      /* pick fallback */ break;
      case 'gas_spike':            /* re-quote and retry */ break;
      case 'tool_loop_limit':      /* raise maxToolRounds or shorten task */ break;
      default:                       console.error(err.code, err.requestId);
    }
  }
}

Error codes mirror the REST/MCP responses — see Errors for the full list. The @llm4agents/gasless standalone package is superseded by this SDK and uses the same code values, so migrating only requires renaming the import and error class.

Endpoints Reference

Copy{
  "uuid": "a1b2c3d4-e5f6-...",
  "apiKey": "sk-proxy-abc123...",
  "name": "my-agent",
  "createdAt": "2026-04-14T12:00:00.000Z",
  "requestId": "req_...",
  "depositDeadline": "2026-04-14T12:15:00.000Z",
  "depositRequiredWithinMinutes": 15,
  "notice": "Anti-spam protection: this agent will be automatically deleted if no deposit is received within 15 minutes. You can simply register a new agent if that happens. Once the first deposit (any amount) is credited, the agent becomes permanent. This measure exists solely to prevent malicious actors from generating agents indefinitely."
}

Copy{
  "status": "ok",
  "service": "llm-proxy-api",
  "timestamp": "2026-04-14T12:00:00.000Z"
}

Copy{
  "chain": "solana",
  "token": "USDC",
  "address": "7xKX...",
  "createdAt": "2026-04-14T12:00:00.000Z",
  "requestId": "req_..."
}

Copy{
  "uuid": "a1b2c3d4-...",
  "availableUsdCents": 5000,
  "availableUsd": "50.00",
  "totalDepositedUsd": "100.00",
  "totalSpentUsd": "50.00",
  "requestId": "req_..."
}

Copy{
  "models": [
    {
      "slug": "anthropic/claude-3-haiku",
      "displayName": "Claude 3 Haiku",
      "provider": "anthropic",
      "inputPricePer1M": 0.3,
      "outputPricePer1M": 1.5,
      "contextWindow": 200000,
      "lastSyncedAt": "2026-04-14T06:00:00.000Z"
    }
  ],
  "requestId": "req_..."
}

Copy{
  "id": "gen-abc123",
  "object": "chat.completion",
  "model": "anthropic/claude-3-haiku",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! How can I help you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 12,
    "completion_tokens": 9,
    "total_tokens": 21
  }
}

Copy{
  "object": "list",
  "data": [
    { "object": "embedding", "embedding": [0.012, -0.034, ...], "index": 0 }
  ],
  "model": "openai/text-embedding-3-large",
  "usage": { "prompt_tokens": 5, "total_tokens": 5 }
}

Copy{
  "chain": "polygon",
  "chainId": 137,
  "token": "USDC",
  "tokenAddress": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
  "forwarderAddress": "0xba9490B2A5c94AAc18fC7aBf19151757852FB5E7",
  "from": "0x9f...",
  "to": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
  "amount": "1.50",
  "amountBaseUnits": "1500000",
  "fee": "50000",
  "feeFormatted": "0.05 USDC",
  "feeDecimal": "0.05",
  "deadline": 1756000000,
  "nonces": { "token": "3", "forwarder": "7" },
  "typedData": {
    "permit": { "domain": {...}, "types": {...}, "primaryType": "Permit", "message": {...} },
    "transferPermit": { "domain": {...}, "types": {...}, "primaryType": "TransferPermit", "message": {...} }
  },
  "requestId": "req_..."
}

Copy{
  "txHash": "0xab...",
  "explorerUrl": "https://polygonscan.com/tx/0xab...",
  "from": "0x9f...",
  "to": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
  "chain": "polygon",
  "chainId": 137,
  "token": "USDC",
  "tokenAddress": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
  "amount": "1.50",
  "amountBaseUnits": "1500000",
  "feeBaseUnits": "50000",
  "feeDecimal": "0.05",
  "requestId": "req_..."
}

Copy# All transactions
GET /api/v1/transactions

# Only deposits
GET /api/v1/transactions?type=deposit

# Only usage, second page of 20
GET /api/v1/transactions?type=usage&limit=20&offset=20

Copy{
  "transactions": [
    {
      "id": 2,
      "type": "deposit",
      "amountUsdCents": 5000,
      "model": null,
      "promptTokens": null,
      "completionTokens": null,
      "totalTokens": null,
      "chain": "polygon",
      "txHash": "0xabc...",
      "description": "Deposit of 50.00 USDT on polygon",
      "createdAt": "2026-04-15T09:15:00.000Z"
    },
    {
      "id": 1,
      "type": "usage",
      "amountUsdCents": 3,
      "model": "anthropic/claude-3-haiku",
      "promptTokens": 120,
      "completionTokens": 85,
      "totalTokens": 205,
      "chain": null,
      "txHash": null,
      "description": "Chat completion: anthropic/claude-3-haiku",
      "createdAt": "2026-04-14T12:05:00.000Z"
    }
  ],
  "limit": 50,
  "offset": 0,
  "total": 2,
  "requestId": "req_..."
}

Scraper / MCP

A headless browser service exposed via the Model Context Protocol (MCP). Your agent connects to the MCP server and gains access to tools for fetching pages, taking screenshots, extracting data, and running persistent browser sessions — all with optional proxy support (datacenter or residential) and anti-detection stealth.

Connecting

The MCP server is hosted at a separate endpoint. Authenticate with the same API key used for the main API.

CopyMCP Endpoint: https://mcp.llm4agents.com/mcp
Method:       POST
Auth:         Authorization: Bearer YOUR_API_KEY
Protocol:     MCP Streamable HTTP (JSON response mode)

Pricing

All prices shown as fractions of a US cent. Sub-cent billing — you only pay for what you use.

One-Shot Tool Prices

Session Pricing

Sessions are billed based on duration + number of actions. Cost is reserved upfront at worst-case and settled to actual usage when the session is closed.

Session Limits

One-Shot Tools

Each tool opens a browser, performs one action, returns the result, and closes the browser.

Copy{
  "ok": true,
  "tier_used": "datacenter",
  "html": "<html>...</html>",
  "status": 200,
  "finalUrl": "https://...",
  "attempts": [{ "tier": "none", "error": "Navigation timeout of 10000 ms exceeded" }]
}

Copy{
  "ok": false,
  "tier_used": "none",
  "attempts": [
    { "tier": "none",         "error": "..." },
    { "tier": "datacenter",   "error": "..." },
    { "tier": "residential",  "error": "..." }
  ],
  "reason": "All proxy tiers failed. Last error: ...",
  "hint": "The page may be down, blocking automated requests, or unreachable. Consider trying a different URL, a search query, or another tool.",
  "url": "https://..."
}

Copy{ "markdown": "# Page Title\n\nContent...", "title": "Page Title", "url": "https://..." }

Copy{ "links": [{ "href": "https://...", "text": "Link text", "rel": "" }] }

Copy{ "pngBase64": "iVBOR...", "width": 1920, "height": 1080, "bytes": 184320 }

Copy{ "pdfBase64": "JVBERi0...", "bytes": 52480 }

Copy{ "url": "https://example.com", "selectors": { "title": "h1", "prices": ".price" }, "proxy_tier": "none" }

Copy{ "data": { "title": "Example", "prices": ["$10", "$20", "$30"] } }

Session Tools

Persistent browser sessions let you navigate, click, type, and extract across multiple pages without reopening the browser. Sessions last 5 minutes and support a configurable action limit.

Copy{ "session_id": "a1b2c3d4-...", "expires_at": "2026-04-17T12:05:00.000Z" }

Copy{ "duration_ms": 45000, "actions_count": 12, "cost_cents": 1.74 }

Copy{ "expires_at": "2026-04-17T12:05:00.000Z", "actions_count": 5, "status": "active" }

Search Tools

Google search capabilities exposed via the same MCP server as the scraper tools. Your agent can search Google, Google News, and Google Maps and receive structured results — no browser needed.

Connecting

Uses the same MCP endpoint and authentication as scraper tools.

CopyMCP Endpoint: https://mcp.llm4agents.com/mcp
Method:       POST
Auth:         Authorization: Bearer YOUR_API_KEY
Protocol:     MCP Streamable HTTP (JSON response mode)

Pricing

Flat rate per call for all 3 search tools. Billing follows the same reserve-settle pattern as other tools.

Tools

Common Parameters

Copy{
  "results": [
    {
      "title": "Example Domain",
      "link": "https://example.com",
      "snippet": "This domain is for use in examples..."
    }
  ],
  "query": "example domain"
}

Copy{
  "results": [
    {
      "title": "Breaking News Story",
      "link": "https://news.example.com/story",
      "snippet": "A major development...",
      "date": "2 hours ago",
      "source": "Example News"
    }
  ],
  "query": "latest tech news"
}

Copy{
  "results": [
    {
      "title": "Best Coffee Shop",
      "address": "123 Main St, New York, NY",
      "latitude": 40.7128,
      "longitude": -74.006,
      "category": "Coffee shop",
      "rating": 4.7,
      "phone": "+1 212-555-0100",
      "website": "https://bestcoffee.example.com"
    }
  ],
  "query": "coffee shops near me"
}

Copy{
  "queries": [
    { "q": "best restaurants in NYC", "gl": "us" },
    { "q": "weather forecast NYC", "tbs": "qdr:d" },
    { "q": "NYC subway map" }
  ]
}

Copy{
  "results": [
    {
      "results": [{ "title": "...", "link": "...", "snippet": "..." }],
      "query": "best restaurants in NYC"
    },
    {
      "results": [{ "title": "...", "link": "...", "snippet": "..." }],
      "query": "weather forecast NYC"
    },
    {
      "results": [{ "title": "...", "link": "...", "snippet": "..." }],
      "query": "NYC subway map"
    }
  ],
  "queryCount": 3
}

Image Tools

AI-powered image generation, editing, and analysis tools exposed via the same MCP server as scraper and search tools. Your agent can generate images from text, edit existing images, and analyze image content.

Connecting

Uses the same MCP endpoint and authentication as scraper and search tools.

CopyMCP Endpoint: https://mcp.llm4agents.com/mcp
Method:       POST
Auth:         Authorization: Bearer YOUR_API_KEY
Protocol:     MCP Streamable HTTP (JSON response mode)

Pricing

Image inputs accept either a URL or base64-encoded image data. All image outputs are returned as base64. Billing follows the same reserve-settle pattern as other tools.

Tools

Copy{
  "imageBase64": "<base64 PNG data>",
  "width": 1024,
  "height": 1024,
  "megapixels": 1.048,
  "costCents": 1
}

Copy{
  "imageBase64": "<base64 image data>",
  "width": 1344,
  "height": 768,
  "costCents": 2
}

Copy{
  "text": "The image shows a system architecture diagram with three main components...",
  "costCents": 0.6
}

Workspace

A private per-agent file workspace backed by Cloudflare R2. Upload artifacts (markdown, screenshots, PDFs, JSON) and retrieve them later — billed per-MB with per-day storage. Both Bearer auth and x402 walk-up are supported.

Pricing

All paid operations have a 1¢ minimum. Free operations are rate-limited at 60 req/min per agent.

Worked examples

Tools

10 MCP tools, called via the MCP endpoint at https://mcp.llm4agents.com/mcp. Both Bearer and x402 walk-up work on every paid tool. Inline upload/download is capped at 10 MB; larger files use the init/finalize flow.

{ "created": true, "agent_id": "...", "created_at": 1700000000 }

Public Download Endpoint

The token-based proxy endpoint that consumes the URL returned by workspace_download({ format: "url" }). No authentication header is required — the token itself is the authorization.

GET https://api.llm4agents.com/v1/workspace/download/:token

Gasless Stablecoin Transfers (non-custodial)

Send stablecoin transfers on Polygon from your own EOA without holding any native MATIC. You bring the private key; the platform only validates the signatures you produce and relays them to Vexo's StablecoinForwarder. The service is free — the platform holds no funds, signs nothing, and charges nothing. Your API key is used solely to tag the request for rate-limit and audit. Logged as transactions.type = "gas_sponsored" with amount_usd_cents = 0.

Two-step flow

1. POST /v1/tx/quote — ask the relay for fee + nonces + typed data

   Send {chain, token, from, to, amount}. The platform fetches the current Vexo relayer fee (action: "fee-quote"), reads the on-chain nonces(from) from the token and the forwarder, and returns the full EIP-712 payloads (Permit + TransferPermit) pre-filled for you, plus a deadline 10 minutes out. No signatures yet.

2. Sign both typed-data objects locally with your wallet

   Use ethers.Wallet.signTypedData(domain, types, message) (or any EIP-712 signer) on typedData.permit and typedData.transferPermit. Split each raw signature into {v, r, s}. The platform never sees your key.

3. POST /v1/tx/send — submit the signed bundle

   Echo chain, token, from, to, amount, fee, deadline, nonces from the quote and add permitSig + transferPermitSig. The platform re-derives each EIP-712 digest, runs ecrecover, and forwards to Vexo's action: "transfer" only if both recovered signers match from. Vexo broadcasts on-chain and returns the txHash.

What the platform does & does not do

Supported chains & tokens

Example: USDC transfer with your own wallet

Two requests (/quote, /send) bracketing local signing.

Copyimport { ethers } from 'ethers';

const wallet = new ethers.Wallet(process.env.USER_PRIVATE_KEY);
const base = 'https://api.llm4agents.com';
const headers = {
  'Authorization': `Bearer ${process.env.PROXY_KEY}`,
  'Content-Type': 'application/json',
};

// 1. Ask the relay for fee + nonces + typed data
const q = await fetch(`${base}/v1/tx/quote`, {
  method: 'POST', headers,
  body: JSON.stringify({
    chain: 'polygon', token: 'USDC',
    from: wallet.address,
    to: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
    amount: '1.50',
  }),
}).then(r => r.json());

// 2. Sign both typed-data objects locally
const signEip712 = async (td) => {
  const { EIP712Domain, ...types } = td.types; // ethers wants types without EIP712Domain
  const raw = await wallet.signTypedData(td.domain, types, td.message);
  const s = ethers.Signature.from(raw);
  return { v: s.v, r: s.r, s: s.s };
};
const permitSig = await signEip712(q.typedData.permit);
const transferPermitSig = await signEip712(q.typedData.transferPermit);

// 3. Submit signed bundle
const tx = await fetch(`${base}/v1/tx/send`, {
  method: 'POST', headers,
  body: JSON.stringify({
    chain: q.chain, token: q.token, from: q.from, to: q.to, amount: q.amount,
    fee: q.fee, deadline: q.deadline, nonces: q.nonces,
    permitSig, transferPermitSig,
  }),
}).then(r => r.json());

console.log(`Sent: ${tx.txHash} (${tx.explorerUrl})`);

Copy# 1. Get the quote
curl https://api.llm4agents.com/v1/tx/quote \
  -H "Authorization: Bearer sk-proxy-..." \
  -H "Content-Type: application/json" \
  -d '{
    "chain": "polygon",
    "token": "USDC",
    "from": "0x9f...",
    "to": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
    "amount": "1.50"
  }'

# 2. Sign typedData.permit and typedData.transferPermit locally (out-of-band).

# 3. Submit the signed bundle
curl https://api.llm4agents.com/v1/tx/send \
  -H "Authorization: Bearer sk-proxy-..." \
  -H "Content-Type: application/json" \
  -d '{
    "chain": "polygon",
    "token": "USDC",
    "from": "0x9f...",
    "to": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
    "amount": "1.50",
    "fee": "50000",
    "deadline": 1756000000,
    "nonces": { "token": "3", "forwarder": "7" },
    "permitSig": { "v": 27, "r": "0x...", "s": "0x..." },
    "transferPermitSig": { "v": 28, "r": "0x...", "s": "0x..." }
  }'

Notes & gotchas

• You own the EOA. from must hold the USDC and the signatures. The platform has no key that can move your funds — not through this endpoint, not anywhere.
• The Vexo fee is paid in the same stablecoin by from, in addition to amount. Vexo collects it as part of the on-chain transfer; the platform does not touch it.
• deadline is 10 minutes. Sign promptly. If you sign after it passes, /send returns 400 expired_quote — just call /quote again.
• Gas spikes return 409 gasless_gas_spike. If Vexo's fee moved between your quote and your send, safe to retry from /quote.
• Signature recovery is strict. ecrecover on both signatures must equal the checksummed from; mismatches return 400 invalid_signature with the expected and recovered addresses.
• Timeouts may still land. 504 gasless_timeout means the upstream call didn't complete in time; the on-chain transfer can still confirm afterwards. Idempotency is the caller's responsibility.
• amount is a decimal string. JSON numbers lose precision; always pass a string like "1.50". Same for fee (uint base units) and nonces.*.

Billing

The API uses a reserve-proxy-settle pattern for each chat completion request:

1. Reserve

   Before each request, the estimated cost (based on input tokens + max output tokens) is reserved from your balance. If your balance is insufficient, the request is rejected with 402 insufficient_balance.

2. Proxy

   The request is forwarded to the LLM provider.

3. Settle

   After the response completes, the actual cost is calculated from real token counts. Any over-reserved amount is returned to your balance.

Pricing

Each model has per-token pricing (input and output) visible via GET /api/v1/models. These are the final prices you pay.

Billing Headers

Every chat completion response includes billing information in the response headers:

Models

Available models are synced from upstream providers and updated regularly. Use GET /api/v1/models to see current pricing and availability.

Model slugs follow the format: provider/model-name. Examples:

• anthropic/claude-3-haiku
• openai/gpt-4o
• google/gemini-pro
• meta-llama/llama-3-70b-instruct

You can use the search query parameter to filter models by name or slug.

Model Fallbacks

Send a prioritized list of models using the models parameter instead of model. If the primary model fails (rate limits, downtime, context length errors, moderation), the next model in the list is tried automatically.

How It Works

1. Send models array — provide 2-3 model slugs in priority order.
2. Automatic failover — if the first model fails, the next is tried seamlessly.
3. Check which model responded — the X-Model-Used response header tells you which model actually processed the request.

Rules

• models and model are mutually exclusive — use one or the other, not both.
• The array must contain 2 to 3 model slugs.
• All models must be active and approved in the platform.
• No duplicate slugs allowed.
• Billing reserves balance using the most expensive model in the list to prevent under-reservation. The final charge uses the model that actually responded.

Fallback Triggers

Fallback activates when the primary model encounters:

• Context length validation errors
• Rate limiting from the upstream provider
• Provider downtime or errors
• Content moderation rejections

Example

Copycurl https://api.llm4agents.com/v1/chat/completions \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "models": ["anthropic/claude-sonnet-4", "openai/gpt-4o"],
    "messages": [{"role": "user", "content": "Hello"}]
  }'

# Check which model responded:
# Response header X-Model-Used: anthropic/claude-sonnet-4

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.llm4agents.com/v1",
    api_key="your-api-key"
)

response = client.chat.completions.with_raw_response.create(
    model="anthropic/claude-sonnet-4",
    messages=[{"role": "user", "content": "Hello"}],
    extra_body={
        "models": ["anthropic/claude-sonnet-4", "openai/gpt-4o"]
    }
)
print(response.headers["x-model-used"])

Copyimport OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.llm4agents.com/v1',
  apiKey: 'your-api-key',
});

const response = await client.chat.completions.create({
  model: 'anthropic/claude-sonnet-4',
  messages: [{ role: 'user', content: 'Hello' }],
}, {
  body: {
    models: ['anthropic/claude-sonnet-4', 'openai/gpt-4o'],
  },
});

OpenAI Compatibility

The /v1/chat/completions endpoint is fully compatible with OpenAI's API format. Any SDK or tool that supports OpenAI can use this API by changing the base_url.

Supported Parameters

• model -- model slug (required unless using models)
• models -- array of 2-3 model slugs for fallback routing (alternative to model)
• messages -- message array (required)
• temperature -- sampling temperature (0-2)
• max_tokens -- maximum output tokens
• stream -- enable Server-Sent Events streaming

Any additional fields in the request body are passed through to the upstream provider, allowing you to use provider-specific parameters.

SDK Examples

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.llm4agents.com/v1",
    api_key="your-api-key"
)

# Streaming example
stream = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Explain quantum computing"}],
    stream=True
)
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Copyimport OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.llm4agents.com/v1',
  apiKey: 'your-api-key',
});

// Streaming example
const stream = await client.chat.completions.create({
  model: 'openai/gpt-4o',
  messages: [{ role: 'user', content: 'Explain quantum computing' }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}

Copycurl https://api.llm4agents.com/v1/chat/completions \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role": "user", "content": "Explain quantum computing"}],
    "temperature": 0.7,
    "max_tokens": 1000
  }'

Supported Chains

Send stablecoins to your generated deposit wallet address. Deposits are verified on-chain and credited to your LLM4Agents balance — the balance that funds LLM completions, scraper, search, and image tools. Gasless-transfer relayer fees are charged separately by Vexo from the agent's own EOA in the token being transferred and never debit the LLM4Agents balance.

Errors

All error responses include an error field with a machine-readable code and a message field with a human-readable description.

Copy{
  "error": "insufficient_balance",
  "message": "Not enough funds. Required: 15 cents, available: 3 cents",
  "requestId": "req_..."
}

Rate Limits

When rate limited, the API returns 429 Too Many Requests. Implement exponential backoff in your client.