API and MCP

Reading the chain…

Your agent can trade, launch and collect here — and Cinder never touches your key. No account, no API key.

Give your AI a wallet here

One command. 20 seconds.

Works with Claude, Cursor and Windsurf. Then just ask it what is trending.

MCP, for an agent

14 tools. One command to install. No key means read-only.

REST, for anything else

Plain JSON, no key, CORS open. The same endpoints this site uses.

The chain, for the paranoid

The contracts are the real API. Addresses below. Nothing here is privileged.

Settings

Add a key to let it trade. Without one it only reads.

shell

# let it trade, capped per call
npx @cinder/mcp install --key 0x… --max-spend 0.05

or by hand: mcp.json

{
  "mcpServers": {
    "cinder": {
      "command": "npx",
      "args": [
        "-y",
        "@cinder/mcp"
      ],
      "env": {
        "CINDER_API": "https://api.cinderpad.xyz",
        "CINDER_CHAIN_ID": "46630",
        "CINDER_PRIVATE_KEY": "0x…  # omit to run read-only",
        "CINDER_MAX_SPEND": "0.05"
      }
    }
  }
}

CINDER_PRIVATE_KEY: The agent's own key. Leave it out for read-only.
CINDER_MAX_SPEND: Most ether one call may spend. Default 0.05.
CINDER_API: Which indexer to read.
CINDER_CHAIN_ID: 46630 testnet, 4663 mainnet.

What the agent gets

Writes are marked. Each of them also takes dry_run, which returns the transaction instead of sending it.

`status`		What the server is connected to, which wallet it signs with, and its spend limit.
`list_tokens`		Tokens by volume, market cap, curve progress or recency.
`get_token`		One token in full: price, liquidity, fee terms, links, curve state.
`get_trades`		The trade feed, for one token or across the launchpad.
`get_candles`		OHLC history at 1m, 5m, 1h or 1d.
`get_holders`		Holders largest first, with contracts flagged.
`get_wallet`		A wallet's balance and what it is owed as creator and as holder.
`quote`		What a trade would return, from the contract that will execute it.
`buy`	signs	Spend ether on a token, on whichever venue it trades.
`sell`	signs	Sell by amount or by percentage of the holding, approval included.
`launch_token`	signs	Create a token on a curve, with its fee terms and first buy.
`claim_fees`	signs	Withdraw creator fees, holder fees, or split a pool's uncollected ones.
`share_fees_with_holders`	signs	Give away fees you have earned, split across holders.
`graduate`	signs	Open the pool of a token whose curve filled but never migrated.

Try the API

Real requests against the live indexer. Nothing on this page is a canned response.

Market

Trading

Protocol

Every token, sortable by volume, market cap, curve progress or recency.

GET/v1/tokens?sort=volume&limit=3

Press run. The request goes to the live API — this page has no canned responses in it, so what you see is what you will get.

Trading without the MCP server

Quote, ask for the transaction, sign it yourself.

Every write endpoint answers with a list of steps, each a to, data and value you can hand to any wallet library. They are ordered and must be sent in order — a sell is preceded by its ERC-20 approval when the wallet has not granted one. Nothing is signed for you and nothing is held on your behalf.

shell

# what a 0.001 buy would return
curl "https://api.cinderpad.xyz/v1/quote?token=$TOKEN&side=buy&amount=1000000000000000"

# the transaction to do it, with a 1% floor on what you receive
curl -X POST https://api.cinderpad.xyz/v1/tx/buy \
  -H 'content-type: application/json' \
  -d '{"token":"'$TOKEN'","amountIn":"1000000000000000","slippageBps":100}'

trade.ts

import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";

const res = await fetch("https://api.cinderpad.xyz/v1/tx/buy", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ token, amountIn: "1000000000000000", slippageBps: 100 }),
});
const { steps, quote } = await res.json();

// Decide with the quote in hand, before anything is signed.
if (Number(quote.feeBps) > 500) throw new Error("too expensive");

const wallet = createWalletClient({ account, chain, transport: http(rpc) });
for (const step of steps) {
  const hash = await wallet.sendTransaction({
    to: step.to,
    data: step.data,
    value: BigInt(step.value),
  });
  await client.waitForTransactionReceipt({ hash });
}

GET	/v1/quote	token, side, amount, slippageBps → amountOut, minAmountOut, feeBps, venue, executionPrice. Read from the chain, not from the last trade.
POST	/v1/tx/buy	token, amountIn, slippageBps → one step. The spend is the transaction's value.
POST	/v1/tx/sell	token, amountIn, slippageBps, sender → an approval step when the wallet is short one, then the sell. Send them in order.
POST	/v1/tx/launch	name, symbol, metadata or metadataURI, creatorTaxBps, devBuy, devLockSeconds, shareFeesWithHolders → one step, plus the launch fee broken out.
POST	/v1/tx/claim	kind of creator \| holder \| pool, token → the steps that collect it.
POST	/v1/tx/share	token, amount → gives that much of your earned fees to current holders, once.
POST	/v1/tx/graduate	token → opens a stranded token's pool. Anyone may; it costs only gas.
GET	/v1/wallets/:address/payouts	Everything one wallet is owed, in one call, instead of four contract reads.

Things that will catch you out

Each of these has, at least once.

A token trades in one of two places

On a curve until it has raised its target, then in a Uniswap v4 pool. Every quote says which, and the endpoints route for you — but the venues price differently, and a number you cached from one will not hold on the other.

There is a third state, briefly

A curve can fill without its pool opening, which leaves the token tradeable nowhere. Quotes return 409 and say so. Anybody can finish the migration with /v1/tx/graduate, for the price of the gas.

Fees are per token, and a creator sets part of them

feeBps is the platform's standing fee plus that creator's surcharge, which can be as much as 10%. Read it before trading something you did not launch.

Amounts are strings, always

Every integer in this API is a decimal string, because a JSON number is a double and would round a wei amount without telling you. Parse to BigInt, not to Number.

A quote is not a promise

It is what the contract says right now. The transaction carries a minimum derived from your slippageBps, and it will revert rather than fill badly. Zero slippage on a public mempool is an invitation.

Fees accrue; they are never pushed

Nothing is sent to you automatically — a contract that pays out on every trade can be broken by one recipient that reverts. Check /v1/wallets/:address/payouts and collect.

The contracts

Read them instead of trusting this page. Addresses come from the live deployment.

Reading…

{ "mcpServers": { "cinder": { "command": "npx", "args": [ "-y", "@cinder/mcp" ], "env": { "CINDER_API": "https://api.cinderpad.xyz", "CINDER_CHAIN_ID": "46630", "CINDER_PRIVATE_KEY": "0x… # omit to run read-only", "CINDER_MAX_SPEND": "0.05" } } } }

# what a 0.001 buy would return curl "https://api.cinderpad.xyz/v1/quote?token=$TOKEN&side=buy&amount=1000000000000000" # the transaction to do it, with a 1% floor on what you receive curl -X POST https://api.cinderpad.xyz/v1/tx/buy \ -H 'content-type: application/json' \ -d '{"token":"'$TOKEN'","amountIn":"1000000000000000","slippageBps":100}'

import { createWalletClient, http } from "viem"; import { privateKeyToAccount } from "viem/accounts"; const res = await fetch("https://api.cinderpad.xyz/v1/tx/buy", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ token, amountIn: "1000000000000000", slippageBps: 100 }), }); const { steps, quote } = await res.json(); // Decide with the quote in hand, before anything is signed. if (Number(quote.feeBps) > 500) throw new Error("too expensive"); const wallet = createWalletClient({ account, chain, transport: http(rpc) }); for (const step of steps) { const hash = await wallet.sendTransaction({ to: step.to, data: step.data, value: BigInt(step.value), }); await client.waitForTransactionReceipt({ hash }); }