Developer API

A public API for building on MEME STREET: read live market data, get exact quotes, and launch or trade coins from your own code. Write endpoints return unsigned transactions that you sign with your own wallet, so the API never touches your keys.

How the API works

The API is plain HTTPS plus JSON (a simple text format for structured data). There is nothing to install and no account to create.

Base URL: https://app.memestreet.fun/api/v1
Network: Robinhood Chain testnet (chainId 46630) during the preview. At launch the same endpoints will point at mainnet.
Rate limit: 120 requests per minute per IP.
Auth: none. You sign your own transactions.

The API is non-custodial, which means it never holds funds or private keys. Read endpoints just return data. Write endpoints validate your input, simulate the call against the blockchain, and return an unsigned transaction: an object with to (the contract address), data (the encoded call) and value. You sign that transaction with your own wallet or library and broadcast it yourself. If you have used pump.fun's local transaction mode, this works the same way.

All token amounts are strings in wei unless noted. Wei is the smallest unit of a token: since every token here has 18 decimals, 1 token equals 1000000000000000000 wei. Amounts travel as strings because they are too large for standard JSON numbers.

Note Everything on this page runs against the testnet preview today. Mainnet addresses and the mainnet chainId (4663) will be published at launch; the endpoint paths will not change.

Warning No MEME STREET endpoint will ever ask for your private key or seed phrase. Anything that does is not this API.

Read endpoints

GET /chain

Protocol constants and contract addresses. Useful as a sanity check before you build transactions.

{
  "chainId": 46630,
  "rpc": "https://rpc.testnet.chain.robinhood.com",
  "factory": "0xFC879be387047f8ab26e35A58baA6e2Cb6D0840F",
  "network": "robinhood-testnet",
  "curveSupply": "800000000000000000000000000",
  "totalSupply": "1000000000000000000000000000",
  "virtualToken0": "1200000000000000000000000000"
}

GET /stocks

The tokenized stocks you can back a coin with, together with their contract addresses. Always take stock addresses from here rather than from a DEX listing, because fake copies of these tickers with spoofed liquidity exist elsewhere.

{ "stocks": [ { "address": "0xc9f9...bd4e", "symbol": "TSLA", "refPriceUsd": 248 } ] }

GET /coins

Lists launched coins with live market data. Supports query parameters: sort (one of created, mcap, progress, volume), stock (filter by backing stock symbol, for example TSLA), graduated (true or false), limit and offset for paging.

Field	Meaning
`token`, `curve`, `creator`	Contract addresses of the coin, its bonding curve (the contract that prices trades before graduation), and the wallet that launched it
`stock`, `stockSymbol`	The tokenized stock backing this coin
`priceX18`	Price in stock per token, multiplied by 1e18 so it fits in an integer
`tokensSold`	Net tokens distributed by the curve so far
`progress`	Percent of the curve sold (100 means graduated)
`mcapUsd`	Market cap in USD (reference stock prices on testnet)
`graduated`	`true` once liquidity has moved to Uniswap V4, the decentralized exchange where graduated coins trade

GET /coins/:token

A single coin plus its last 50 trades (buys, sells and the graduation event), each with a transaction hash and timestamp. The response also includes the coin's claimable creator fees as fees.creator (and fees.creatorUsd).

GET /quote

An exact quote for a trade, computed with the same integer math the contract uses, so the numbers match the chain to the wei. Parameters: token (coin address), side (buy or sell) and amount in wei. A buy quote looks like this:

{
  "tokensOut": "394630872483221476510067115",
  "stockUsed": "500000000000000000",
  "refund": "0",
  "fee": "10000000000000000",
  "priceBeforeX18": "833333333",
  "priceAfterX18": "1850083333",
  "graduates": false
}

graduates: true means this buy would complete the curve. In that case any overpaid surplus is refunded automatically and the coin's liquidity moves to Uniswap V4, all in the same transaction.

Write endpoints

Write endpoints are transaction builders. They validate inputs, simulate the call on the current chain state, and return unsigned transactions. You sign and broadcast them in order with any EVM wallet or library.

POST /metadata

Uploads the coin's photo, banner and description before launching. Images go in as base64 data URLs, which is just the image file encoded as text inside the JSON (png, jpg, webp or gif). The photo can be up to 600KB and the optional banner up to 1.2MB; the description is capped at 500 characters.

{
  "name": "Wolf of Meme Street",
  "description": "max 500 chars",
  "image": "data:image/png;base64,...",
  "banner": "data:image/jpeg;base64,... (optional)"
}

Response:

{ "metadataURI": "https://app.memestreet.fun/meta/<id>.json", "image": "...", "banner": "..." }

Pass the returned metadataURI to /tx/create-token. The indexer fetches it on launch and serves the description and images with every coin in the read endpoints.

POST /tx/create-token

Builds the transaction that launches a memecoin backed by a real tokenized stock.

{
  "name": "API Cat",
  "symbol": "APICAT",
  "metadataURI": "ipfs://... (optional)",
  "stock": "0x1fbe1a0e43594b3455993b5de5fd0a7a266298d0",
  "virtualStock0": "1000000000000000000",
  "from": "0xYourAddress (optional, improves simulation)"
}

virtualStock0 sets the starting price and the size of the raise. The curve sells 800M tokens and, when it completes, holds virtualStock0 times 2 of the backing stock as liquidity (fees excluded). A higher virtualStock0 means a higher starting price and a bigger total raise. The minimum is 0.001 stock.

Response:

{
  "chainId": 46630,
  "tx": { "to": "0xFC879be387047f8ab26e35A58baA6e2Cb6D0840F", "data": "0x...", "value": "0" },
  "predicted": { "token": "0xC3C7...6B94", "curve": "0xBd15...91bE" }
}

predicted comes from an eth_call simulation, a read-only dry run against the chain, so the token and curve addresses are exact before you even broadcast. If the launch would fail on chain (for example the stock is not allowlisted, or virtualStock0 is below the minimum), the endpoint answers 400 with the revert reason instead of handing you a broken transaction.

Note To make the creator's first buy (the dev buy), wait for the create transaction to confirm, then call POST /tx/buy with the new token address and your amount, and sign the returned transactions. You are first in the curve. The official app does exactly this under the hood.

POST /tx/buy

{ "token": "0x...", "amount": "500000000000000000", "slippageBps": 100, "from": "0xYou" }

amount is the stock you are paying in, in wei. slippageBps is your slippage tolerance in basis points (100 means 1%): the most the price may move against you before the trade fails instead of filling. The response contains up to two transactions. The first is an approve, the standard ERC-20 permission that lets the curve contract take your stock; it is only included when your current allowance is too low. The second is the buy itself, with a minTokensOut floor derived from the quote and your slippage.

{
  "chainId": 46630,
  "txs": [
    { "to": "<stock>", "data": "0x095ea7b3...", "description": "approve stock to curve" },
    { "to": "<curve>", "data": "0xd6febde8...", "description": "buy on the bonding curve" }
  ],
  "quote": { "tokensOut": "...", "minTokensOut": "...", "refund": "0", "graduates": false }
}

POST /tx/sell

Same shape as buy, in the other direction: amount is tokens in, and the response returns an approve (if needed) plus a sell transaction protected by minStockOut.

POST /tx/claim-fees

Builds the transaction that claims a coin's accrued creator fees. 1% of every buy and sell accrues inside the curve contract, in the backing stock, and is claimable at any time, before or after graduation.

{ "token": "0x..." }

Response:

{ "tx": { "to": "<curve>", "data": "0x...", "value": "0" } }

The claim is permissionless: anyone can send this transaction, but the funds always go to the coin's creator. Fees accrue inside the contract instead of being paid out on each trade, so a blocked or broken wallet can never halt trading. Check the claimable amount in GET /coins/:token under fees.creator.

End to end example

Launching a coin from the command line. The example uses curl (sends web requests), jq (reads JSON) and cast, Foundry's tool for signing and sending Ethereum transactions. Replace $PK with your own private key, which stays on your own machine.

API=https://app.memestreet.fun/api/v1

# 1. pick a stock
curl -s $API/stocks

# 2. build the launch tx
curl -s -X POST $API/tx/create-token -H 'content-type: application/json' -d '{
  "name":"API Cat","symbol":"APICAT",
  "stock":"0x1fbe1a0e43594b3455993b5de5fd0a7a266298d0",
  "virtualStock0":"1000000000000000000"
}' > create.json

# 3. sign and send with YOUR key
cast send $(jq -r .tx.to create.json) $(jq -r .tx.data create.json) \
  --private-key $PK --rpc-url https://rpc.testnet.chain.robinhood.com

# 4. your token is live and indexed
curl -s $API/coins/$(jq -r .predicted.token create.json)

Errors

Code	Meaning
`400`	Invalid parameters, a failed simulation (the revert reason is included), or an attempt to trade a graduated coin on the curve
`404`	Unknown token or route
`429`	Rate limit exceeded (120 requests per minute per IP)
`500`	Internal error

Graduated coins no longer trade on the bonding curve. They trade on Uniswap V4 with a 1% fee tier, still paired against their backing stock, so use any V4-compatible router with the token / stock pool.