$PEAR API

Overview

Lists every endpoint. No key, no sign-up, no wallet. Every answer is { ok: true, data } or { ok: false, error }.

Start here. This one call tells you every address the API answers on, so you never have to hard-code a list that might change.

Every endpoint answers the same two shapes: when things worked you get { ok: true, data }, and when they didn't you get { ok: false, error } with a plain sentence in error. Check ok first and you can treat every route the same way.

It's open to any website — the answers carry permissive sharing headers, so browser code can call it directly with no key and no proxy. Answers are cached for a few seconds, so hammering it won't get you fresher numbers.

What comes back

• ok — true when the call worked
• data.endpoints — every address you can call, with a one-line description

curl "https://pearit.now/api/public/v1"

const res = await fetch("https://pearit.now/api/public/v1");
const body = await res.json();

if (!body.ok) {
  console.error(body.error); // a plain sentence, safe to show people
} else {
  console.log(body.data.endpoints);
}

All coins

Every coin launched here with its live price, market cap, 24h change and volume.

This is the same list the home grid is built from: every coin launched through $PEAR, with live market numbers attached at the moment you ask.

Use sort to order it — newest for a feed, volume for what's busy today, marketcap for the biggest. Use search to look one up by name, ticker, or by pasting a full address. Use limit to keep the answer small; anything over 200 is trimmed to 200.

Numbers come from live market data, so a brand-new coin that hasn't traded yet comes back with its name and address but no price. Always treat usdPrice, mcap and volume24h as possibly missing.

If market data is briefly unavailable you get { ok: false, error } with a 503. Retry after a few seconds rather than immediately.

What you can pass

• sort — newest (default), volume or marketcap
• search — name, ticker or full address
• limit — 1–200, default 50

What comes back

• id — the coin's address on Solana
• name / symbol — its name and ticker
• icon — picture address, when it has one
• usdPrice — price in dollars right now
• mcap — market cap in dollars
• volume24h — buys plus sells over the last 24 hours, in dollars
• priceChange24h — percent move over 24 hours
• holderCount — how many wallets hold it
• createdAt — when it first traded
• graduatedAt — when it filled its pump.fun curve, if it has

curl "https://pearit.now/api/public/v1/coins?sort=volume&limit=5"

const res = await fetch("https://pearit.now/api/public/v1/coins?sort=marketcap&limit=10");
const { ok, data, error } = await res.json();
if (!ok) throw new Error(error);

for (const coin of data) {
  const price = coin.usdPrice ? `$${coin.usdPrice.toPrecision(3)}` : "not trading yet";
  console.log(coin.symbol, price, coin.mcap);
}

function Coins() {
  const [coins, setCoins] = useState([]);

  useEffect(() => {
    let alive = true;
    const load = () =>
      fetch("https://pearit.now/api/public/v1/coins?sort=volume&limit=20")
        .then((r) => r.json())
        .then((b) => { if (alive && b.ok) setCoins(b.data); });
    load();
    const timer = setInterval(load, 30000); // fresh every 30s is plenty
    return () => { alive = false; clearInterval(timer); };
  }, []);

  return coins.map((c) => <div key={c.id}>{c.symbol} — {c.mcap}</div>);
}

curl "https://pearit.now/api/public/v1/coins?search=pear"

One coin

A single coin by address, plus the question it is paired with: the side it backs, the live chance, when it closes and whether it won or lost.

Swap {mint} for the coin's address — the id field from the list above, or the long string in its pump.fun link.

This is the only endpoint that returns the paired outcome, so use it for a coin page rather than filtering the whole list.

market is null when the coin was launched without a question. When it is there, odds is a fraction: 0.62 means a 62% chance. It refreshes in the background, so a page that re-asks every minute stays current.

Once the question is answered, result fills in and outcome tells you straight away whether this coin's side won. Before that both are empty strings, not null.

An address that isn't a real coin here comes back 404 with { ok: false, error }.

What comes back

• token — the same fields as the list above, for this one coin
• market.question — the yes/no question it backs, when it has one
• market.side — yes or no — the side this coin picked
• market.odds — the chance of that side, 0 to 1, refreshed on its own
• market.closeTime — when the question stops taking answers
• market.result — yes, no, or empty while it is still open
• market.outcome — won, lost, or empty — the side compared with the result
• market.url — the question on Polymarket or Kalshi

curl "https://pearit.now/api/public/v1/coins/9iKAPEqEDNqfZ2wD3g25RMRpYFW78AnXJgm6yNq5zpad"

const mint = "9iKAPEqEDNqfZ2wD3g25RMRpYFW78AnXJgm6yNq5zpad";
const res = await fetch(`https://pearit.now/api/public/v1/coins/${mint}`);
const { ok, data, error } = await res.json();
if (!ok) throw new Error(error); // 404 when the address isn't one of ours

console.log(data.token.symbol, data.token.usdPrice);

if (data.market) {
  const chance = Math.round(data.market.odds * 100);
  console.log(`backs ${data.market.side} on "${data.market.question}" — ${chance}%`);
  if (data.market.outcome) console.log("this coin", data.market.outcome);
}

Open questions

Live yes/no questions from Polymarket and Kalshi — the same list the launch form searches.

These are real questions from two prediction markets, merged into one list and filtered down to plain yes/no ones. Only open questions come back.

sort=volume gives you the ones people care about most; sort=closing gives you the ones answering soonest — handy for a 'settling today' section.

yesPrice is the chance of yes as a fraction, so the chance of no is 1 minus it. Multiply by 100 for a percentage.

Both sources are polled and cached for about a minute, so calling this in a tight loop returns the same answer. One of the two sources is fetched through our server because it doesn't allow browser calls — you don't have to do anything, it's already handled.

The id you get here is what a coin stores when it pairs with a question, so you can match a coin to its question across both endpoints.

What you can pass

• search — words to look for
• sort — volume (default) or closing
• limit — 1–100, default 30

What comes back

• source — polymarket or kalshi
• id — the question's own id at that source — pass this back when launching
• question — the yes/no question, in words
• yesPrice — the chance of yes, 0 to 1
• volume — how much has been traded on it, in dollars
• closeTime — when it stops taking answers
• url — the question on its own site
• status — open, closed or settled

curl "https://pearit.now/api/public/v1/markets?search=election&sort=closing"

const res = await fetch("https://pearit.now/api/public/v1/markets?sort=closing&limit=10");
const { ok, data, error } = await res.json();
if (!ok) throw new Error(error);

for (const q of data) {
  const chance = Math.round(q.yesPrice * 100);
  const closes = new Date(q.closeTime).toLocaleString();
  console.log(`[${q.source}] ${q.question} — yes ${chance}% — closes ${closes}`);
}

Buybacks and burns

Every $PEAR buy-and-burn with the SOL spent, the $PEAR burned and both transaction signatures.

When a coin launches with buyback picked, its creator fees are collected, spent on $PEAR, and that $PEAR is destroyed. This endpoint is the public receipt book for all of it.

totals is the running score — the same number shown in the site header. events is the individual burns, newest first.

Both signatures are real Solana transactions. Stick either on the end of https://solscan.io/tx/ and anyone can check it themselves.

burnSignature can be empty for a burn that was bought but not yet destroyed; show it as pending rather than as zero.

What you can pass

• limit — 1–200, default 50

What comes back

• totals.solSpent — all the SOL ever spent buying $PEAR back
• totals.padBurned — all the $PEAR ever burned
• totals.burns — how many burns have happened
• events[].createdAt — when that burn happened
• events[].solSpent — SOL spent on that one
• events[].padBurned — $PEAR destroyed on that one
• events[].swapSignature — the buy, checkable on Solscan
• events[].burnSignature — the burn, checkable on Solscan

curl "https://pearit.now/api/public/v1/buybacks?limit=5"

const res = await fetch("https://pearit.now/api/public/v1/buybacks?limit=20");
const { ok, data, error } = await res.json();
if (!ok) throw new Error(error);

console.log(`${data.totals.padBurned} $PEAR burned across ${data.totals.burns} burns`);

for (const burn of data.events) {
  const link = burn.burnSignature
    ? `https://solscan.io/tx/${burn.burnSignature}`
    : "burn pending";
  console.log(new Date(burn.createdAt).toDateString(), burn.padBurned, link);
}