# Paxie.Matrix Data API

> Launch data for Robinhood Chain and Solana, updated every 20 s (≤30 s lag). Robinhood Chain: every ETH-quoted Uniswap v4 and v3 pool created in the last 24 h. Solana: pump.fun tokens 5 min to 4 h old that show curve progress. Buyer bursts, a rug check on who holds each pool's liquidity (per burst, and per token before you buy), new pools, per-minute flow, repeat-buyer crews and copy-leader replays. Robinhood signals are scored 30 minutes later, Solana ones at graduation or 20 minutes, rugs counted. Data, not trading advice. Pay per call in USDC with x402 (Base or Solana). No API keys, no signup.

Last 24h on Robinhood Chain: 95% of 730 checked buyer bursts fired on pools whose creator still held the liquidity; 83% of those (scored) had it pulled within 30 minutes. Of 34 scored bursts on pools with burned, locked or launchpad-held liquidity, 2 were pulled. (as of 2026-10-10 02:28 UTC, rolling 24 h; rows: GET /v1/rh/bursts/history)


## Endpoints (paid per call, x402; /v1 is canonical)

- GET https://api.paxie.fun/v1/rh/bursts/live ($0.01 per call): Robinhood Chain buyer bursts from the last 1-240 minutes, on every ETH-quoted Uniswap v4 and v3 pool created on the chain in the last 24 h. Each burst carries net ETH inflow, buy and sell swaps, scripted vs spread buying, pool age and a rug check (who held the pool's liquidity at the signal); outcomes are scored 30 minutes after the signal. Data rewritten every 20 s (<= 30 s behind the chain); data older than 120 s is refused with a 503 and not charged.
- GET https://api.paxie.fun/v1/rh/bursts/history ($0.02 per call): Scored Robinhood Chain buyer bursts from the last 1-24 hours. Each row has its rug check and 30-minute outcome: return at 30 min, peak, the return under each exit rule (2% round-trip costs included) and whether the liquidity was pulled. Outcome fields are labels, not features (see /v1/fields). Data rewritten every 20 s (<= 30 s behind the chain); data older than 120 s is refused with a 503 and not charged.
- GET https://api.paxie.fun/v1/rh/pools/new ($0.005 per call): ETH-quoted Uniswap v4 and v3 pools opened on Robinhood Chain in the last 1-24 hours, youngest first, with token, age, last price, ETH liquidity, last swap time, 60-minute net flow and the burst tiers that fired. Data rewritten every 20 s (<= 30 s behind the chain); data older than 120 s is refused with a 503 and not charged.
- GET https://api.paxie.fun/v1/sol/bursts/live ($0.01 per call): Solana pump.fun bonding-curve buyer bursts from the last 1-240 minutes, on pump.fun tokens 5 min to 4 h old that show curve progress. Each burst has SOL inflow, curve position, token age and, on sampled bursts, its anatomy (same-slot bundles, scripted sizes, top-3 share, top holders). Outcomes are scored at graduation or 20 minutes. Data rewritten every 20 s; data older than 120 s is refused with a 503 and not charged.
- GET https://api.paxie.fun/v1/sol/bursts/history ($0.02 per call): Scored Solana pump.fun bonding-curve bursts from the last 1-24 hours: which graduated and how fast, the peak return, and the return under each exit rule with 2.5% round-trip costs. Data rewritten every 20 s; data older than 120 s is refused with a 503 and not charged.
- GET https://api.paxie.fun/v1/snapshot ($0.03 per call): Everything in one call, Robinhood Chain and Solana: live buyer bursts on both chains (last 1-240 minutes, all tiers), Robinhood pools opened in the last hour, and 24-hour tallies (bursts, scored, median 30-minute return, rug check, pump.fun graduations). Data rewritten every 20 s; data older than 120 s is refused with a 503 and not charged.
- GET https://api.paxie.fun/v1/rh/pools/:id/flow ($0.005 per call): One Robinhood Chain pool by Uniswap v4 pool id or v3 pool address (path parameter id, from /v1/rh/pools/new). Returns 1-minute buckets for the last 60 minutes (net ETH, buy ETH, sell ETH, buy and sell swap counts) and the pool's burst history. Untracked pools answer 404 and are not charged. Data rewritten every 20 s (<= 30 s behind the chain); data older than 120 s is refused with a 503 and not charged.
- GET https://api.paxie.fun/v1/rh/token/:addr/rugcheck ($0.02 per call): Rug check for a Robinhood Chain token before you buy (path parameter addr = token contract). Returns the LP ownership profile of each tracked Uniswap v4 pool for the token: the share of liquidity the creator or LP adder can pull (insiderShare), and the shares burned, held by launchpad or locker contracts, or held by other wallets, plus LP age and a class (held, safe, unknown, empty). Pools under 6 hours old are re-profiled on a rolling basis (about every 10 minutes; checkedAt per row). Tokens still on the Pons launchpad bonding curve answer class pons-curve with the curve, creator, fill progress, ETH in the curve, age and fees: a curve has no LP to pull until it graduates. Untracked tokens answer 404 and are not charged.
- GET https://api.paxie.fun/v1/sol/wallets/leaders ($0.05 per call): Top Solana copy-trade leaders ranked by shrunk replay EV. Each wallet's last 60 big pump.fun buys are replayed through one fixed copy exit (stop, take-profit, trail and time stop, fees in, capped at +100%), then shrunk toward the pooled mean so short records do not top the board. Includes sample size, win share and the leader's own sell pattern. On-chain addresses only, no names. Rebuilt hourly; refused (503, not charged) if older than 3 h.
- GET https://api.paxie.fun/v1/rh/crews ($0.02 per call): Repeat-buyer clusters on Robinhood Chain: wallets that bought inside 3 or more of the buyer bursts the scout has captured, with burst count and last-seen time. Use it to spot sniper crews before they dump on you. Data rewritten every 20 s (<= 30 s behind the chain); data older than 120 s is refused with a 503 and not charged.
- GET https://api.paxie.fun/v1/sol/callers/leaderboard ($0.05 per call): Telegram call-channel callers (Solana and Robinhood Chain calls) ranked by what happened after their own posts, traded or not: per caller n, hit15 (reached +15% within 60 min), win35 (+35% before -20%), x2, rug rate (-80% within 60 min) and median 1/5/15/60-minute returns and max moves, each shrunk toward the pooled value so a few lucky calls do not top the board. Callers are sha1 hashes; chats are named only when they are public channels/groups. Windows 24h, 7d, 30d. Rebuilt hourly; refused (503, not charged) if older than 3 h.
- GET https://api.paxie.fun/v1/sol/calls/outcomes ($0.05 per call): Every human call from the followed Telegram chats (Solana and Robinhood Chain tokens) that is 1-48 hours old, with its return 1, 4, 12, 24 and 48 hours after the first post, the 48-hour high and when it came, the dip before the high, and whether the token died. Sampled every 10 minutes from our own series; no third-party prices passed through. Callers hashed, public chats only by name. Rebuilt hourly; refused (503, not charged) if older than 3 h.
- GET https://api.paxie.fun/v1/sol/calls/live ($0.02 per call): Contract addresses (Solana and Robinhood Chain) posted in the followed Telegram call chats in the last 1-120 minutes: first seen, how many chats posted it, our own price and market cap at the first call (pump.fun curve or on-chain pool reads only), the move since and the max since, and its stage (curve band or pool age). Public channels are named with their @username; private chats appear only as counts. Data rewritten every 20 s; refused (503, not charged) if older than 120 s.
- GET https://api.paxie.fun/v1/sol/grads/live ($0.01 per call): Solana pump.fun graduations from the last 1-240 minutes: time on the curve (gradMin), the curve path into graduation from our own curve reads, the buyer burst that preceded it when there was one, and returns 1, 5 and 15 minutes after graduation from our own sampled series. Data rewritten every 20 s; refused (503, not charged) if older than 120 s.
- GET https://api.paxie.fun/v1/sol/grads/history ($0.02 per call): Solana pump.fun graduations from the last 1-48 hours with aggregates: median time on the curve, how many followed a buyer burst, and median post-graduation returns at 1, 5 and 15 minutes (with the share still up at 15). Data rewritten every 20 s; refused (503, not charged) if older than 120 s.
- GET https://api.paxie.fun/v1/desk/trades ($0.01 per call): The Paxie.Matrix desk's closed trades on Solana and Robinhood Chain since a time, for auditing its track record: book (main or explore), mode (paper = simulated fills on live prices, no real money), desk and lane, token, open and close times, return on cost with fees, peak gain and exit reason. Random-twin baseline desks are excluded. Aggregates are free at /v1/desk/stats. Data rewritten every 60 s; refused (503, not charged) if older than 10 min.
- GET https://api.paxie.fun/v1/sol/wallets/:addr/copy-stats ($0.01 per call): Every buy by one Solana copy-leader wallet that the desk observed in the last 14 days (newest 100): leader size, curve position, token age, other leaders on it, our quote drift and paper fill slip vs the leader, what the leader did next, the token's 60-minute path after the buy and the replayed copy return, plus a summary. On-chain addresses only. Rebuilt hourly; untracked wallets answer 404 and are not charged.
- GET https://api.paxie.fun/v1/stream/pass ($0.50 per pass): A stream pass ($0.50 per pass, not per call): up to 60 minutes of Server-Sent Events at /v1/sol/bursts/stream?token=…, pushing Solana pump.fun and Robinhood Chain buyer bursts, pump.fun graduations and new Telegram calls (public chats named, callers hashed) as they fire. The worker appends events every few seconds; heartbeat every 15 s, up to 2 connections per pass. Answers 503 stream_disabled (not charged) when the server has streaming switched off.
- GET https://api.paxie.fun/v1/rh/token/:addr/precall ($0.02 per call): What a Robinhood Chain token did in the hour before a Telegram call on it was posted, for every call our desk saw in the last 48 h: buy swaps and ETH in the 10 minutes before the post, the run over the hour before (run60), the token's age at the call, the most buy txs in one block, and the pre-post buyers' wallets (on-chain addresses; distinct wallets and the most in one block). flags = the bot's own veto rules that match: run (>= 3x in the hour before), young (< 30 min old at the call), cluster (>= 5 wallets in one block). No chat names, callers or message text. Tokens with no call answer 404 and are not charged. Data rewritten every 30 s; refused (503, not charged) if older than 180 s. Research data from our own paper-trading desk, not trading advice.
- GET https://api.paxie.fun/v1/rh/token/:addr/verdict ($0.03 per call): One call before you buy a Robinhood Chain token: avoid, caution or ok, with every reason. Combines the rug check (who holds the Uniswap v4 liquidity, or the Pons bonding-curve fill), liquidity pulls after buyer bursts, the pre-call flags if the token was called (ran >= 3x before the post, same-block wallet cluster, < 30 min old), the token's age, and our desk's own last trade and shadow outcome on it. The rules are listed in every response. Untracked tokens answer 404 and are not charged. Rug check and pool data rewritten every 20 s, pre-call and desk data every 30 s; stale inputs are refused (503, not charged). Research data from our own paper-trading desk, not trading advice.
- GET https://api.paxie.fun/v1/sol/token/:mint/verdict ($0.02 per call): Everything our desk recorded on a Solana mint in the last 48 h: the safety gate result (with rugcheck.xyz numbers, attributed), scout scores (numbers), our grade from scanner-card fields, the trader's action and conviction, the shadow outcomes (return at 1/5/15/60 min, max favourable / adverse excursion) and our last closed paper trade. No trader thesis, no bot card text, no chat content. Mints the desk never saw answer 404 and are not charged. Data rewritten every 30 s; refused (503, not charged) if older than 180 s. Research data from our own paper-trading desk, not trading advice.
- GET https://api.paxie.fun/v1/scanner/:mint ($0.01 per call): Our grade (A-F) for a Solana or Robinhood Chain token from the holder structure on scanner-bot cards: holders, top-10 share, largest holder, snipers, bundles, dev holding, fresh wallets, curve progress, as numbers, with the penalties that set the grade. Derived fields only; the bots' cards are not reproduced. Covers tokens our desk scanned in the last 48 h; others answer 404 and are not charged. Data rewritten every 30 s; refused (503, not charged) if older than 180 s. Research data from our own paper-trading desk, not trading advice.

## Free

- GET https://api.paxie.fun/v1/sample: 15-minute-delayed preview, 3 bursts per chain
- GET https://api.paxie.fun/v1/openapi.json: OpenAPI 3.1 description with response schemas (also /openapi.json)
- GET https://api.paxie.fun/v1/fields: data dictionary with per-field availability, errors, freshness, limits
- GET https://api.paxie.fun/v1/stats: settled calls by route and day (no payer addresses)
- GET https://api.paxie.fun/v1/health: service health
- GET https://api.paxie.fun/v1/desk/stats: the desk's paper track record (main and explore books, equity index)
- GET https://api.paxie.fun/v1/sol/bursts/stream?token=…: Server-Sent Events (bursts, graduations, calls); needs a token from the paid /v1/stream/pass ($0.50 per pass, up to 60 min)

## MCP

Remote MCP server (Streamable HTTP, id paxie-matrix-data): https://api.paxie.fun/mcp. Tools: rh_token_rugcheck, rh_bursts_live, rh_bursts_history, rh_pools_new, rh_pool_flow, rh_crews, sol_bursts_live, sol_bursts_history, sol_wallet_leaders, launch_snapshot, rh_token_precall, rh_token_verdict, sol_token_verdict, scanner_grade, sol_callers_leaderboard, sol_calls_outcomes, sol_calls_live, sol_grads_live, sol_grads_history, desk_trades, sol_wallet_copy_stats, stream_pass (paid, x402 over MCP, same prices), plus free sample and status.

## How to pay

Request any paid endpoint. The server answers 402 with a PAYMENT-REQUIRED header (price, USDC asset, network, payTo). An x402 client signs the payment and retries with a PAYMENT-SIGNATURE header; the response comes back with the data and a PAYMENT-RESPONSE receipt. Settled through Coinbase's x402 facilitator; listed in the x402 Bazaar. Browsers on other origins can call it (CORS allows PAYMENT-SIGNATURE and exposes PAYMENT-REQUIRED / PAYMENT-RESPONSE).

## When each field exists (read before backtesting)

- signal: Known when the burst fires. Safe to use as a feature.
- signal+seconds: Filled 5-60 s after the signal, computed from chain state as of the signal block. Safe as a feature once present; null until then.
- signal+30m: Outcome. Exists only after the scoring window closes (Robinhood 30 min; Solana graduation or 20 min). Never use as a feature: a backtest that does uses the future.
- now: Current state as of the response's generatedAt (or the row's checkedAt). Not tied to a signal.
- Rows are appended at signal time; their outcome is filled in place later. A row fetched from history already carries its future: use only signal and signal+seconds fields as inputs.
- All timestamps are epoch milliseconds.

## Fields

### rhBurst
Robinhood Chain buyer burst: net ETH buying into one ETH-quoted Uniswap v4 or v3 pool within 60 s while buying is still building.
- id (string, signal): Stable row id: sha1 of chain + pool + tier + signal time (16 hex). Unique per row — dedupe on this, not pool + at (main and lite can fire on one pool in the same second).
- at (integer, signal): Signal time, epoch ms (when our scout saw the threshold crossed).
- token (string, signal): Token contract address.
- pool (string, signal): Pool id: v4 PoolId (bytes32) or v3 pool address.
- tier (string, signal): main: >= 1 ETH net in and >= 12 buy swaps in 60 s, still buying over the last 15 s, pool 5 min-6 h old. lite: >= 0.5 ETH and >= 8 buys (fires earlier, noisier). refire: main thresholds again on the same pool >= 30 min after its last burst. old: first main-threshold burst on a 6-24 h pool.
- dex (string, signal): Uniswap version of the pool.
- shape (string, signal): scripted: >= 5 buy swaps of an identical size inside the window (one crew splitting a bag). spread: the 3 largest buys are < 50% of the buying. other: neither. v3: a v3-pool burst (tracked as its own lane, shape not classified).
- inflowEth (number, signal): Net ETH into the pool over the window (buys minus sells).
- buys (integer, signal): Buy swaps in the window.
- sells (integer, signal): Sell swaps in the window.
- windowSec (integer, signal): Window length in seconds (60).
- poolAgeMin (number, signal): Minutes since the pool was created.
- sameSizeMax (integer, signal): Largest count of buy swaps with an identical ETH size in the window.
- top3Share (number, signal): Share of the window's buy ETH from its 3 largest buy swaps (0-1).
- sizeCV (number, signal): Coefficient of variation of buy sizes (stdev / mean). Low = uniform, scripted-looking.
- buyers (integer, signal+seconds): Distinct buyer wallets (tx senders) in the window. Main tier only; null otherwise.
- repeatBuyers (integer, signal+seconds): Of those, wallets seen in earlier bursts. Main tier only.
- lp (object, signal+seconds): Rug check: who held the pool's liquidity at the signal block. v4 main and lite bursts; null otherwise. See lp fields.
- outcome (object, signal+30m): Scored 30 minutes after the signal. { scored: false } until then. See rhOutcome fields.

### lp
Rug check at the signal block. Liquidity-weighted shares of who held the pool's LP position NFTs. insider = the wallet that created the pool or sent an LP add; they can pull it whenever they like.
- class (string, signal+seconds): held: the creator / LP adder held >= 50% of the liquidity (the rug tell). safe: burned, launchpad or locker contracts, or other wallets held >= 50%. unknown: the LP owner could not be read; never treat as safe.
- insiderShare (number, signal+seconds): Share of liquidity whose LP NFT the pool creator / LP adder still held (0-1). On Robinhood Chain >= 0.5 is the rug tell: most such pools are pulled within ~10 minutes of liquidity going in.
- burnedShare (number, signal+seconds): Share whose LP NFT was sent to the zero or dead address (cannot be pulled).
- contractShare (number, signal+seconds): Share added by a contract other than Uniswap's position manager (a launchpad or locker).
- otherShare (number, signal+seconds): Share held by any other wallet.
- unknownShare (number, signal+seconds): Share whose LP NFT owner could not be read.
- lpAgeMin (number, signal+seconds): Minutes from the first liquidity add to the signal.
- estimated (boolean, signal+seconds): true on bursts before Oct 8 2026 21:10 PT, profiled afterwards with the signal block estimated from block time (minute-level precision).

### rhOutcome
What happened in the 30 minutes after a Robinhood burst, priced from the pool's own swaps. 2% round-trip costs included in every return.
- scored (boolean, signal+30m): false until the 30-minute window closes.
- scoredAt (integer, signal+30m): When the outcome was written (epoch ms): the earliest moment it was knowable. null on rows scored before Oct 9 17:30 PT.
- ret30m (number, signal+30m): Return holding from the signal price to 30 minutes (-1 = worthless).
- peakRet (number, signal+30m): Best price in the window vs the signal price. Not reachable in practice: you do not know the top.
- ruleRet (number, signal+30m): Return under our live exit rule (fade 0.5 ETH from the high-water inflow, or 60 s without a new price high; -15% stop).
- byRule (object, signal+30m): Return, exit reason and exit second under each exit rule we test, keyed by a stable opaque rule id (rule definitions are private). Every rule shares the same -15% stop-loss, so a token that hits the stop before any rule's own exit shows the same stop-loss result under several rules. hold = the baseline with no exit signal: only that stop, graduation (Solana) or the end of the scoring window.
- rug (object, signal+30m): { atSec, lpRemoved }: >= 80% of the pool's liquidity was removed atSec after the signal. Every exit rule that had not fired by then scores -100% (minus costs). null = no rug in the window.

### solBurst
Solana pump.fun bonding-curve buyer burst: >= 10 SOL net in within 60 s, token >= 5 min old, curve 25-55% full, still buying. Tokens 5 min to 4 h old that show curve progress are watched.
- id (string, signal): Stable row id: sha1 of chain + mint + signal time (16 hex). Dedupe on this.
- at (integer, signal): Signal time, epoch ms.
- mint (string, signal): Token mint.
- inflowSol (number, signal): Net SOL into the curve over the window.
- windowSec (integer, signal): Window length in seconds.
- curveFrom (number, signal): Curve fill at the start of the window (0-1).
- curveAt (number, signal): Curve fill at the signal (0-1).
- tokenAgeMin (number, signal): Minutes since the token launched.
- anatomy (object, signal+seconds): Sampled bursts only. See solAnatomy fields. null when not sampled.
- outcome (object, signal+30m): Scored at graduation or 20 minutes. { scored: false } until then. See solOutcome fields.

### solAnatomy
Who bought inside a Solana burst window (sampled bursts).
- buys (integer, signal+seconds): Buy trades in the window.
- buyers (integer, signal+seconds): Distinct buyer wallets.
- sameSlotMax (integer, signal+seconds): Most buys landed in one slot (bundling).
- bundledShare (number, signal+seconds): Share of buy SOL that landed in multi-buy slots (0-1).
- sameSizeMax (integer, signal+seconds): Largest count of buys with an identical size.
- top3Share (number, signal+seconds): Share of buy SOL from the 3 largest buys (0-1).
- holdersTop10 (number, signal+seconds): Share of supply held by the top 10 holders (0-1).
- holderTop1 (number, signal+seconds): Share of supply held by the largest holder (0-1).
- repeatBuyers (integer, signal+seconds): Buyers seen in earlier Solana bursts.

### solOutcome
What happened after a Solana burst: the curve path to graduation or 20 minutes (price = curve SOL squared). 2.5% round-trip costs included.
- scored (boolean, signal+30m): false until graduation or 20 minutes.
- scoredAt (integer, signal+30m): When the outcome was written (epoch ms): the earliest moment it was knowable. null on rows scored before Oct 9 17:30 PT.
- graduated (boolean, signal+30m): The curve completed inside the window.
- gradMin (number, signal+30m): Minutes from the signal to graduation; null if it did not graduate.
- peakRet (number, signal+30m): Best curve price in the window vs the signal.
- gradRet (number, signal+30m): Return at graduation; null if it did not graduate.
- ret20m (number, signal+30m): Return at the 20-minute close; null if it graduated first.
- ruleRet (number, signal+30m): Return under our live abandon-ship exit rule.
- nonStandardCurve (boolean, signal+30m): true when the curve reserves were outside the standard pump.fun range (prices less reliable).
- byRule (object, signal+30m): Return, exit reason and exit second under each exit rule we test, keyed by a stable opaque rule id (rule definitions are private). Every rule shares the same -15% stop-loss, so a token that hits the stop before any rule's own exit shows the same stop-loss result under several rules. hold = the baseline with no exit signal: only that stop, graduation (Solana) or the end of the scoring window.

### pool
An ETH-quoted Uniswap v4 or v3 pool on Robinhood Chain created in the last 24 h.
- id (string, now): v4 PoolId or v3 pool address.
- dex (string, now): v4 or v3.
- token (string, now): Token address.
- createdBlock (integer, now): Block the pool was created in.
- ageMin (number, now): Minutes since creation.
- lastPx (number, now): Last swap price, ETH per raw token unit (scale by the token's decimals).
- liqEth (number, now): ETH-side liquidity estimate at the last swap.
- lastSwapAt (integer, now): Time of the last swap, epoch ms.
- net60m (number, now): Net ETH in over the last 60 minutes.
- buys60m (integer, now): Buy swaps, last 60 minutes.
- sells60m (integer, now): Sell swaps, last 60 minutes.
- fired (array, now): Burst tiers that have fired on this pool (main, lite, refire, old).

### rugProfile
Rug check for one pool right now (GET /v1/rh/token/{addr}/rugcheck). Same reading as the per-burst lp object, taken at the latest block the scout had when it profiled the pool.
- pool (string, now): v4 PoolId.
- token (string, now): Token address.
- dex (string, now): Always v4 (v3 LP ownership is not profiled).
- poolAgeMin (number, now): Pool age at the check, minutes.
- checkedAt (integer, now): When this profile was taken, epoch ms. Active pools are re-profiled about every 10 minutes.
- block (integer, now): Block the ownership was read at.
- class (string, now): held / safe / unknown as on bursts, plus empty: no liquidity in the pool (never added, or already pulled).
- insiderShare (number, now): Share of liquidity the creator / LP adder can pull (0-1).
- burnedShare (number, now): Share burned (cannot be pulled).
- contractShare (number, now): Share added by a launchpad or locker contract.
- otherShare (number, now): Share held by other wallets.
- unknownShare (number, now): Share whose LP NFT owner could not be read.
- lpAgeMin (number, now): Minutes since the first liquidity add.
- lpAdds (integer, now): Liquidity adds seen.
- creator (string, now): Address that created the pool (Initialize tx sender).

### walletLeader
A Solana wallet whose pump.fun buys we replay as copy trades (GET /v1/sol/wallets/leaders). Replays use one fixed exit plan over a 60-minute price path; fees in; each capped at +100%.
- rank (integer, now): Rank by evShrunk.
- wallet (string, now): Wallet address (on-chain).
- n (integer, now): Replayed big buys (up to the last 60).
- evShrunk (number, now): Mean replay return per copy, shrunk toward the pooled mean with k pseudo-buys (see method.shrink).
- evRaw (number, now): Unshrunk mean replay return per copy.
- winShare (number, now): Share of replays that ended positive.
- shadowed (integer, now): Buys shadowed for 60 min (all sizes).
- shadowHit (number, now): Share of shadowed buys that hit +35% before -20%.
- lastBuyAt (integer, now): Last buy we saw, epoch ms.
- sells (object, now): The leader's own exits on the buys we followed: observed, sold, soldShare, medSoldSec, medSellGain (leader's gain at its first sell), soldWithin60sShare. null when none observed.

### crew
A repeat buyer in Robinhood Chain bursts (GET /v1/rh/crews): a tx sender of buy swaps inside 3 or more burst windows.
- wallet (string, now): Wallet address (on-chain).
- bursts (integer, now): Bursts it bought into.
- lastSeenAt (integer, now): Last burst it bought into, epoch ms (minute precision).
- lastSeenMinAgo (integer, now): Minutes since then, at snapshot time.

### ponsCurve
Rug check for a Pons launchpad bonding-curve token (class pons-curve on GET /v1/rh/token/{addr}/rugcheck): read from the curve contract by our worker. Pons launchpad bonding-curve token: it has no Uniswap pool and no LP to pull until the curve fills (4.2 ETH) and graduates. The risk on a curve is the creator or early insiders selling into it, not liquidity removal.
- curve (string, now): The token's bonding-curve contract.
- creator (string, now): Launch creator (TokenLaunched event).
- launchBlock (integer, now): Block the token launched in.
- ageMin (number, now): Minutes since launch at checkedAt.
- progress (number, now): Curve fill: ETH in the curve / the graduation threshold (0-1).
- ethInCurve (number, now): Real ETH held by the curve.
- thresholdEth (number, now): ETH the curve must raise to graduate (4.2).
- graduated (boolean, now): The curve completed; the token now trades on a Uniswap v4 pool (the v4 rug check applies).
- mcapUsd (number, now): Curve spot price x supply, in USD.
- feeBps (integer, now): Median fee the curve charged on its last 30 buys (basis points; early anti-snipe windows charge more).
- checkedAt (integer, now): When the curve was read, epoch ms.

### precall
Pre-call context (GET /v1/rh/token/{addr}/precall): the pool's activity before a Robinhood call was posted, captured when our desk first saw the call.
- postedAt (integer, signal): When the call was first posted, epoch ms.
- tracked (boolean, signal): Our scout had the token's pool; false = the pre-post numbers are missing (run falls back to the DexScreener h1 change).
- buys (integer, signal): Buy swaps in the 10 minutes before the post.
- buyEth (number, signal): ETH spent on those buys.
- sameBlockMaxTx (integer, signal): Most buy txs in one block in that window.
- run60 (number, signal): Price at the post / price at the start of the hour before it (3 = up 3x).
- ageAtCallMin (number, signal): Token (pool) age when the call was posted, minutes.
- chg1h0 (number, signal): DexScreener 1-hour % change when we saw the call (fallback only).
- wallets (integer, signal+seconds): Distinct pre-post buyer wallets (tx senders) resolved; null until resolved.
- sameBlockWallets (integer, signal+seconds): Most distinct wallets buying in one block before the post.
- walletList (array, signal+seconds): The resolved buyer wallets (up to 40, on-chain addresses).
- flags (array, signal+seconds): Matching veto rules: run, young, cluster (see rules in the response).

### verdict
GET /v1/rh/token/{addr}/verdict: avoid / caution / ok from the rug check, liquidity pulls, pre-call flags and token age; the worst matching rule decides. Research, not advice.
- verdict (string, now): avoid, caution or ok.
- reasons (array, now): Every rule that matched, with its level.
- rug (object, now): uniswap-v4-lp (class, insiderShare, pools, checkedAt) or pons-curve (progress, ethInCurve, creator); null when not profiled.
- precall (object, signal+seconds): flags and the main pre-call numbers if the token was called; null otherwise.
- desk (object, now): Our desk's last closed trade and first finished shadow on the token (paper unless mode says live).
- tokenAgeMin (number, now): Minutes since the token's oldest tracked pool (or its Pons launch) was created.

### solVerdict
GET /v1/sol/token/{mint}/verdict: what our desk recorded on a Solana mint in the last 48 h. Research, not advice.
- safety (object, now): Our safety gate (pass, fails) and the rugcheck.xyz numbers it read (attributed).
- scouts (object, now): Scout scores (0-1) and their composite.
- scanner (object, now): Our grade from scanner-card fields (see GET /v1/scanner/{mint}).
- trader (object, now): The head trader's action (enter / pass) and conviction; no thesis.
- shadows (array, signal+30m): Shadow outcomes: ret1/ret5/ret15/ret60 from the shadow's start price, mfe / mae (max favourable / adverse excursion). Labels, not features.
- lastTrade (object, signal+30m): Our last closed trade on the mint: book (main / explore), mode, retPct, exit.

### scannerGrade
GET /v1/scanner/{mint}: our grade from scanner-bot holder data. Shares are 0-1; the most cautious reading across bots.
- grade (string, now): A-F (see gradeRules).
- score (number, now): 100 minus penalties.
- fields.top10Pct (number, now): Share of supply held by the top 10 holders.
- fields.topHolder1Pct (number, now): Share held by the largest holder.
- fields.snipers / sniperPct (number, now): Sniper wallets and their share.
- fields.bundlers / bundlePct (number, now): Bundled-buy wallets and their share.
- fields.devLeftPct (number, now): Share the dev still holds.
- fields.fresh1d / fresh7d (number, now): Share held by wallets created in the last 1 / 7 days.
- fields.holders (integer, now): Holder count.

## Quickstart (free sample → verdict → paid feed)

1. Free: GET https://api.paxie.fun/v1/sample (15-min delayed rows, no wallet).
2. Pick a token, check it: GET https://api.paxie.fun/v1/rh/token/{addr}/verdict ($0.03) or /v1/sol/token/{mint}/verdict ($0.02). Unknown tokens answer 404 before payment.
3. Optional live feed: poll GET https://api.paxie.fun/v1/rh/bursts/live ($0.01) or buy a stream pass ($0.50, up to 60 min of SSE).

Node (x402 v2, USDC on Base):

```js
// npm i @x402/fetch @x402/evm viem
import { wrapFetchWithPaymentFromConfig } from '@x402/fetch';
import { ExactEvmScheme } from '@x402/evm';
import { privateKeyToAccount } from 'viem/accounts';
const pay = wrapFetchWithPaymentFromConfig(fetch, { schemes: [{ network: 'eip155:8453', client: new ExactEvmScheme(privateKeyToAccount(process.env.AGENT_KEY)) }] });
const MAX_USD_PER_DAY = 2; let spent = 0; const seen = new Set();
async function get(path, priceUsd) {
  if (spent + priceUsd > MAX_USD_PER_DAY) throw new Error('daily budget reached');
  for (let i = 0; i < 3; i++) {
    const r = await pay(`https://api.paxie.fun${path}`);
    if (r.status === 200) { spent += priceUsd; return r.json(); }
    if (r.status === 503 || r.status === 429) { await new Promise((s) => setTimeout(s, 1000 * (Number(r.headers.get('retry-after')) || 2 ** i))); continue; }
    return r.json(); // 400/404: not charged, don't retry
  }
}
const live = await get('/v1/rh/bursts/live?minutes=5', 0.01);
for (const b of live.bursts) if (!seen.has(b.id)) seen.add(b.id); // dedupe on the stable row id
```

Python (x402 2.25, USDC on Base):

```python
# pip install "x402[evm]" requests
import os
from eth_account import Account
from x402 import x402ClientSync
from x402.http.clients import x402_requests
from x402.mechanisms.evm.exact import register_exact_evm_client
from x402.mechanisms.evm.signers import EthAccountSigner
client = x402ClientSync()
register_exact_evm_client(client, EthAccountSigner(Account.from_key(os.environ["AGENT_KEY"])))
session = x402_requests(client)
r = session.get("https://api.paxie.fun/v1/rh/bursts/live?minutes=5")
if r.status_code == 200:
    seen = {b["id"] for b in r.json()["bursts"]}  # dedupe on the stable row id
```

Paying from Solana instead (Node):

```js
// npm i @x402/fetch @x402/svm @solana/kit
import { wrapFetchWithPaymentFromConfig } from '@x402/fetch';
import { ExactSvmScheme } from '@x402/svm/exact/client';
import { toClientSvmSigner } from '@x402/svm';
import { createKeyPairSignerFromBytes } from '@solana/kit';
const signer = toClientSvmSigner(await createKeyPairSignerFromBytes(Uint8Array.from(JSON.parse(process.env.SOLANA_KEYPAIR_JSON))));
const pay = wrapFetchWithPaymentFromConfig(fetch, { schemes: [{ network: 'solana:*', client: new ExactSvmScheme(signer) }] });
```

MCP client config (Streamable HTTP):

```json
{ "mcpServers": { "paxie-matrix": { "type": "http", "url": "https://api.paxie.fun/mcp" } } }
```

sample and status are free; paid tools need an x402-aware MCP client (@x402/mcp in Node, x402.mcp.client in Python) and settle per call.


Budget: polling a $0.01 route every 20 s costs $43.20/day (4,320 calls). A stream pass covers an hour for $0.50 ($12/day if renewed hourly); on disconnect, reconnect with the same pass while it is valid (up to 2 connections per pass); events missed while disconnected are not replayed — catch up with the history route.

## Errors, freshness, limits

- Errors are { error, code, docs }. 400 bad address; 402 payment required; 404 not tracked; 429 rate limited (free routes); 503 warming up, data stale (> 120 s) or payments not live. 4xx/5xx responses are never charged.
- Live chain data is rewritten every 20 s (≤30 s lag). Every paid response has generatedAt and ageSec; /v1/sample has generatedAt and delayedMin; /v1/health reports dataAgeSec. Paid routes refuse (503, not charged) data older than their freshness limit: 120 s for the burst/pool/rug-check routes, 180 s for precall/verdict/scanner, longer for hourly products (callers, outcomes, copy stats: 3 h) — each route's description states its own.
- Paid endpoints: no rate limit beyond payment. /v1/sample: 30 per minute per IP; other free routes 120; /mcp 60. History windows are per route: bursts/pools 24 h, precall/verdict/scanner 48 h, wallet copy stats 14 days, caller leaderboard up to 30 days.
- Query parameters outside their documented range or enum are rejected with 400 bad_param before any payment (never clamped silently).

## Notes

- Raw bursts are not a buy signal: on Robinhood Chain most fire on pools whose creator still holds the LP and pulls it minutes later. Use lp.insiderShare, or GET /v1/rh/token/{addr}/rugcheck before you buy.
- Data, not trading advice.