The trading API that just works. Even for your AI.

Tell Claude Code, Cursor or Codex what bot you want. It reads our docs, calls one API for trades, launches, bundles and live data, and ships. No RPC to run, no protocol code to write, keys never leave your machine.

Build with AI Quickstart

https://api.trenchytools.lol

Why it just works

Your AI already knows how to use it

Most APIs make an assistant guess. Ours hands it everything it needs to be right the first time, and tells it exactly what to fix when it is not.

Docs your AI can read

AGENTS.md, openapi.json and llms-full.txt: the rules, every endpoint and field, the whole docs as text. Generated from one source and checked against the code.

Errors that fix themselves

Every error carries a stable code, a hint that says what to change, and a link to the exact docs row. The assistant reads it and corrects its own request.

One request shape, every venue

Pass a token address; the API finds the curve or the pool, prices from live state, applies your slippage. pump.fun, PumpSwap, pons today; more launchpads on the way.

Nothing to run

No RPC, no Jito account, no IPFS. Builds, simulation, sends, bundles, lookup tables and a live feed from our own node, behind one key you get with one request.

Your keys stay yours

Transactions come back unsigned. Sign in your own process and submit through us or any node. We never see a private key.

Capabilities you can query

GET /api/chains tells an agent which chains, launchpads and operations are live right now, so it never builds against something that does not exist.

Paste this into your assistant

One prompt, one API key, a working bot. Five ready prompts on the Build with AI page.

See the prompts →

prompt.txt

Build a Solana sniper bot on the TrenchyTools API.

Before writing code, read https://trenchytools-docs-production.up.railway.app/AGENTS.md, https://trenchytools-docs-production.up.railway.app/openapi.json and https://trenchytools-docs-production.up.railway.app/llms-full.txt.
Use only endpoints from openapi.json. Keys stay local. Create my API key with GET https://api.trenchytools.lol/api/create-api-key.
Simulate before sending, start with 0.005 SOL, handle every error by its "code" and show me its "hint".
Deliver a TypeScript project with README, .env.example, npm start and a DRY_RUN mode.

How a trade works

Build → sign → send. Keys never leave your process.

trade-local returns an unsigned transaction priced from the current reserves with your slippage and priority fee applied. Sign with web3.js or viem, then send it, bundle it, or push it through any node.

Trade

trade-local → sign → send. Curve or AMM resolved per token, slippage and priority fee applied from live state.

Launch

Metadata upload, create and dev buy in one transaction. Mint keypair co-signs; the API never sees a key.

Bundle

Create plus up to 16 buyers in one Jito bundle, packed through launch lookup tables. Atomic, same slot.

Stream

Creates, migrations, per-token and per-wallet trades over one websocket, from our own gRPC node.

buy.mjs

import { Keypair, VersionedTransaction } from '@solana/web3.js'

const BASE = 'https://api.trenchytools.lol'
const wallet = Keypair.fromSecretKey(SECRET)

// 1. Build: the API reads the curve / pool and returns an unsigned v0 tx
const res = await fetch(`${BASE}/api/sol/trade-local?api-key=${API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    publicKey: wallet.publicKey.toBase58(),
    action: 'buy', mint: MINT, amount: 0.5,
    denominatedInSol: 'true', slippage: 15, priorityFee: 0.0005, pool: 'auto',
  }),
})
const tx = VersionedTransaction.deserialize(new Uint8Array(await res.arrayBuffer()))

// 2. Sign locally. 3. Send through our RPC + Jito lanes
tx.sign([wallet])
const { signature } = await fetch(`${BASE}/api/sol/send?api-key=${API_KEY}`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ transaction: Buffer.from(tx.serialize()).toString('base64') }),
}).then((r) => r.json())