mcp server

Plug an agent into aio.

A hosted MCP server with the same keys, limits and checks as the REST API: your agent prepares, your machine signs.

Connect

Endpoint (Streamable HTTP, stateless):

https://aio.fun/api/mcp

Send your key as a Bearer token. Most clients take a config like this; keep the key in an environment variable, not in the file:

{
  "mcpServers": {
    "aio": {
      "type": "http",
      "url": "https://aio.fun/api/mcp",
      "headers": {
        "Authorization": "Bearer ${AIO_API_KEY}"
      }
    }
  }
}

A request without a valid key gets 401 with a WWW-Authenticate header that points at /.well-known/oauth-protected-resource. Sign-in with OAuth comes later; API keys work today.

Tools

Each tool needs a scope on the key. A missing scope comes back as a tool error, so the agent can tell you which scope to add. Every tool call counts once toward the key's limits.

MCP tools
tool	what it does	scope	effect
wallet_challenge	One-time message to sign with your wallet	read	changes state
link_wallet	Send that signature to link the wallet to this key	read	changes state
launch_coin	Prepare a launch; returns the unsigned fee transaction	launch	changes state
submit_launch	Submit the signed fee transaction; safe to repeat	launch	irreversible
get_launch	Launch status, and the mint once live	read	read-only
get_coin	One live coin	read	read-only
list_coins	Live coins, newest first	read	read-only
quote	Price on the coin's own pool	read	read-only
buy	Unsigned buy transaction plus a simulation	trade	read-only
sell	Unsigned sell transaction plus a simulation	trade	read-only
submit_transaction	Relay a swap you signed	trade	irreversible
claim_fees	Claim fees to your Privy embedded wallet	claim	changes state
get_fees_for_handle	Coins and unclaimed fees for an X or GitHub handle	read	read-only
portfolio	Positions, fees and rewards of a wallet	read	read-only
get_coin_strategy	A coin's burn or drop strategy	read	read-only
set_coin_strategy	Change it, as the coin's verified fee owner	strategy	irreversible

Tools carry readOnlyHint and destructiveHint, and return structuredContent alongside text.

A launch, start to finish

wallet_challenge, sign the message locally, then link_wallet. Once per wallet and key.
launch_coin with the coin fields and your linked launcherWallet. Keep the returned launchId. Stock-paired coins default to feeMode: "holders", paid in the quote token; send "dev" to opt out (see fee modes and defaults). The result says what the coin got: read feeMode and feeModeReason before signing. A stock coin is set with quote (a stock token id such as "nvda-bp", mainnet only). linkedTicker is deprecated and ignored.
Sign the fee transaction on your machine and pass it to submit_launch.
Call get_launch until the status is live. If a call times out, repeat submit_launch with the same launchId; never prepare a second launch.

Trading is the same shape: buy or sell returns an unsigned transaction and a simulation. Check it, sign locally, then submit_transaction.

What aio will not do

Take a private key or seed phrase. Tool arguments that look like one are refused before anything reads them.
Sign for you. Every transaction is signed by your wallet, on your machine.
Pay fees anywhere else. Claims go to the Privy embedded wallet of the key's account.
Pass coin text off as instructions. Names and descriptions arrive as {"untrusted":true,"text":"…"}.

60 tool calls per minute per key, 30 of them for trading. Launch limits are the same as the REST API.