# NetNet Intel

> Independent, on-chain intelligence for NetNet ($NET) on Robinhood Chain (chain ID 4663): the treasury, NAV (core and incl. the RWA sleeve), supply, holders and whale moves, bonds and credit, read straight from the chain, with every on-chain figure's exact contract call published and a live verifier; plus a model and live race for NetNet's weekly Treasury prediction market, and Shift Run, a points-only arcade. Fan-made: not affiliated with NetNet Capital. Read-only analysis, not financial advice.

The site is a single-page app: its pages need JavaScript. For data, use the JSON read API or the MCP server below. All figures come from public chain reads unless a field says otherwise; each response carries the chain `block` and `asOf` time it was read at. Official figures: NetNet Capital's own app at https://app.netnet.capital.

## Start here (agents)

- Connect the MCP server `https://netnetintel.com/mcp` (no auth; its `instructions` carry this guide) or `GET https://netnetintel.com/api/v1/<area>`. No key.
- Most questions take one call with the tool's filters; stop as soon as the question is answered (rarely more than three calls). Common chains: daily report → `get_desk`; whale check → `get_holders` { kind: "sell", days: 7, minUsd } → `get_whale`; liquidation watch → `get_loop` { status: "at-risk,wind-down" } → `get_loop_liquidations`; why the number moved → `get_growth` → `get_history`; the weekly print → `get_predict` → `get_predict_intel`; a figure that drives a decision → its call → `verify_figures`. Full table: **Common chains** below.
- Quote each figure with its `block`/`asOf`. `stale`, `lastGood`, `complete: false` mean not fully live: say so. Errors (`bad_request`, `not_found`, `rate_limited`, `unavailable`) and what to do: **Errors and partial answers** below. Never fill a gap from memory.
- Every list has a cap; narrow with filters (limits per tool: **Answer sizes** below). Client code: [Python](https://netnetintel.com/examples/netnet_client.py), [TypeScript](https://netnetintel.com/examples/netnet-client.ts). Agent skill: https://netnetintel.com/skills/netnet-intel/SKILL.md

## Verify, don't trust

Every figure that is a direct chain read can be checked independently:

- [Sources](https://netnetintel.com/api/v1/sources): the contract registry and, for every verifiable figure, the exact `eth_call` (address, function, 4-byte selector, decimals), its formula and a ready `curl` against the chain's public RPC (https://rpc.mainnet.chain.robinhood.com, no key).
- [Verify](https://netnetintel.com/api/v1/verify?figures=nav_core,rfv,supply): NetNet Intel re-reads the named figures (or all of them) from the public RPC, independent of the provider the site reads with, at the block they were served from, and reports `exact`, `match` (within a stated tolerance) or `mismatch`, with the raw results. The public node keeps about the last thousand blocks of state; older blocks are re-checked at the chain head.
- [Verify in your browser](https://netnetintel.com/verify): the same check run by a person's own browser straight against the public RPC; `/api/v1/verify?local=1` returns only the served values and calls, for verifiers that run elsewhere. The public node rate-limits shared server addresses: when it refuses NetNet Intel's edge server, the same calls go to the same public node from NetNet Intel's backend; if that is refused too, they are re-read at the same block from the site's archive provider and the report says `independent: false`. `checkedBy` always says which path answered. For a fully independent check, use /verify or run the calls yourself.
- [Second opinion](https://netnetintel.com/api/v1/peer): the core figures beside Netstack's (https://netnet.exe.xyz, an independent NetNet reader with its own code and chain reads), each row with both blocks and exact / match / differs; MCP `get_peer_check`.
- Figure ids: `nav_core`, `nav_core_check`, `rfv`, `rfv_liquid_usdg`, `rfv_morpho_counted`, `rfv_pol`, `supply`, `price_twap`, `premium_core`, `staked`, `staked_share`, `dividend_index`, `sleeve_wallet`.
- To check by hand: run each call at the response's `block` (or `latest`), take the first 32-byte word as an unsigned integer ÷ 10^decimals, apply the formula.
- Calculated figures (NAV incl. the RWA sleeve, the model's odds) are labelled as such, with their inputs listed part by part. Whale moves carry their transaction hash: check them in the receipt's Transfer logs on https://robin.etherscan.io.
- [Methodology in full](https://netnetintel.com/llms-full.txt)

## Build it yourself (open recipes)

Every figure NetNet Intel shows can be rebuilt from Robinhood Chain alone, without this API or any NetNet Intel server: 73 recipes across the treasury, growth, buybacks, liquidity, bonds, NET Advance, Loop, holders, Predict, the arcade games and Turbo. MIT licensed.

- [Recipes catalog](https://netnetintel.com/api/v1/recipes): each recipe's contract calls (address, calldata, decimals), event filters (address, topic0, fromBlock), formula, steps, caveats and what it `needs` (`eth_call`, `eth_getLogs`, `archive`, or an off-chain input such as address labels). `/api/v1/recipes/{id}` adds the figure NetNet Intel serves for it; `?run=1` adds a worked example pinned to a block with every raw request and result (contract-read recipes).
- [The code](https://netnetintel.com/kit/netnet-recipes.mjs): one dependency-free ES module (browser, Node 18+, Workers): `import { RECIPES, makeCtx, run } from "https://netnetintel.com/kit/netnet-recipes.mjs"; await run(RECIPES.find((r) => r.id === "nav_core"), makeCtx())`. Point `makeCtx({ rpc })` at any node; `ctx.trail` lists every request as proof. Sources per area: https://netnetintel.com/kit/src/
- [Recipes page](https://netnetintel.com/recipes): run any recipe in your own browser and compare with the served figure.
- [Desk in one call](https://netnetintel.com/api/v1/desk): every tile of the community desk with each figure's value, block, asOf, source endpoint and field, and recipe; MCP `get_desk`. Start here for broad questions.
- [Community desk](https://netnetintel.com/kit/): the whole ecosystem on one screen, read by the visitor's browser straight from the chain; [one-file version](https://netnetintel.com/kit/netnet-desk.html) to host anywhere. The site's version with side-by-side checks: https://netnetintel.com/desk
- Limits of the public RPC: contract state is kept for about 10 minutes (a pinned-block read re-checks there for a few minutes, on an archive node forever); event history (eth_getLogs, up to 10M blocks a request) always re-checks; it rate-limits busy addresses, so heavy recipes (full holder or loan books) take minutes. Recipes marked `archive` need an archive node.

## Read API (JSON, GET, no key, any origin)

120 requests a minute per address (20 for `/api/v1/verify`); a 429 carries `Retry-After`. Formats, limits and examples: "Usage, limits and formats" below.

- [API index](https://netnetintel.com/api/v1) · [OpenAPI spec](https://netnetintel.com/openapi.json)
- [Live $NET figures](https://netnetintel.com/api/v1/net): price (pair-oracle TWAP), NAV per token, premium, reserves, supply, staked, DEX market; `liquidity`: TVL, 24h volume and ±2% depth summed over every NET pool against USDG, WETH or ETH. About 15 s fresh (liquidity about 2 min).
- [NAV](https://netnetintel.com/api/v1/nav): NAV per NET two ways, core (Treasury.backingPerToken(), on-chain) and incl. the RWA sleeve ((Treasury.rfv() + the sleeve) ÷ NET in issue, calculated), the RFV parts, the sleeve's breakdown, both premiums and the recipes.
- [Treasury](https://netnetintel.com/api/v1/treasury): RFV and its parts, holdings, LP positions and pools, the sleeve's directly held assets.
- [Supply & staking](https://netnetintel.com/api/v1/supply): NET in issue, staked, circulating and its exclusions, burned, NET held per protocol contract, index, epoch, rate.
- [Holders](https://netnetintel.com/api/v1/holders?moves=50): the top 50 holders' own wallets (contracts that hold for others, such as pools and Pendle's SY, and the protocol's Safes are listed apart, in `held`; balance, stance, 7- and 30-day flows), their latest decoded moves with tx hashes, `flowTotals` (the whale flow over 24 hours, 7 and 30 days, as the Holders page shows it: holders' own wallets, linked-wallet reshuffles and the protocol's Safes left out), and wallet clusters (wallets linked by two-way transfers: likely one owner, with the evidence). Each whale carries its `history` (`avgEntry`, `pnl` at the board's price). Filters: `address` (one wallet's moves), `kind` (comma list: buy, sell, bond, stake, unstake, lp-add, lp-remove, deposit, withdraw, transfer-in, transfer-out), `days`, `minUsd`, and `stance` for whales; `movesByKind` totals the matched moves. `priceSource` / `priceAsOf` say which price the board used (it rebuilds about hourly). Example: `?moves=50&kind=sell&days=7&minUsd=10000`.
- [One whale](https://netnetintel.com/api/v1/whale/0x72f273312b253d301b593ca1bbcb740aa500a242): balances, history (entry, P&L, rebase earned), loan, moves and its linked wallets with live balances.
- [Bonds](https://netnetintel.com/api/v1/bonds?epochs=21&trend=24h): the bond desk by 8-hour epoch (NET sold against the cap, `fill`, `soldAfter1h` / `2h` / `4h`, sell-out time, buyers, `paidVsMarket` and `afterVest`), the `live` epoch, and `demandByTrend`: sell-outs grouped by NET's price trend going in (`trend=8h|24h|3d`, last 30 days).
- [Credit](https://netnetintel.com/api/v1/credit): the USDG vault, the Loopback wsNET market and how it marks collateral, the stock markets, liquidations.
- [Buybacks](https://netnetintel.com/api/v1/buybacks?days=7): the team's NET buybacks from the RWA sleeve's Safes: 24-hour, 7-day, 30-day and all-time totals and their `shareOfSupply`, a `window` of `days` (1-90) against the window before it, buys per UTC day (average, low and high price), `bySafe`, venues, the latest buys with tx hashes, the `otcDesk`, the loan that funds them, and the Treasury's inverse bond (NAV × 0.985, burned).
- [Predict market](https://netnetintel.com/api/v1/predict): the open weekly series, the live number it grades, NetNet Intel's model odds, every past series.
- [Loop loans](https://netnetintel.com/api/v1/loop?status=at-risk,wind-down&sort=risk): every Loopback loan (wsNET/USDG on Morpho Blue) with its status (AT RISK, WIND DOWN, WATCH, SAFE: the closer of health < 1.05 / 1.10 / 1.20 and a 5 / 15 / 30% TWAP fall), the TWAP fall to liquidation, the USDG to repay (or wsNET to add) to get back to health 1.20 or survive a 15% or 30% fall, and for a liquidatable loan the full-liquidation repay, seize and profit; filter by `status`, `account`, `minDebt`; sort by `risk` (lowest health first), `debt`, `health`, `collateral`. No transaction data.
- [Predict intel](https://netnetintel.com/api/v1/predict/intel?above=29000000): ask the model: its odds that the print lands above any numbers (`above`, comma list, up to 20), its 68% and 90% ranges, the gap to the line per day, the drivers (incl. the NET TWAP the line implies), each side's value against its break-even, and its graded record.
- [Number history](https://netnetintel.com/api/v1/history?days=7): 1 to 90 days, every 30 minutes up to 7 days, every 4 hours up to 30 and daily beyond (`detail=full` or `interval=30m|1h|4h|1d` to choose): Core RFV, the sleeve mark, `memoHoldings` and `trueRfv`, backing, TWAP, supply, staked (`NET.balanceOf(staking)`), and `trueRfvByClass` at each day's close.
- [What grows NET](https://netnetintel.com/api/v1/grows?days=30): the treasury's change over `days` (1-90, or `all`): money in by source (bonds, the trading fee, premium sales, desks…), money out, value changes, the sleeve by asset class, and the per-NET effect (reserves vs new NET).
- [Liquidator release](https://netnetintel.com/api/v1/liquidator): the self-run Loop liquidator's latest version, whether it is urgent, what's new, and the command that updates it.
- [LP](https://netnetintel.com/api/v1/lp): the NET/USDG v2 pool: reserves, TVL, the week's volume, swaps and fees by day, and who holds the LP (protocol, wallets, contracts, locked) with each holder's fees; `allPools`: every NET pool against USDG, WETH or ETH with TVL, 24h volume, turnover flags and ±2% depth.
- [Sleeve memo holdings](https://netnetintel.com/api/v1/sleeve): the RWA sleeve's holdings beyond its Safe, line by line (NET held, the Loopback position, NET Advance receivables, THE BOOK's pot, the asset desk, v4 LP).
- [Sleeve loan](https://netnetintel.com/api/v1/sleeve/loan): the sleeve's Loopback loan: wsNET posted, USDG owed, LTV, the NET mark at which it could be liquidated, and what the borrowed USDG bought.
- [Pendle](https://netnetintel.com/api/v1/pendle): Pendle's sNET market: the implied APY against what sNET's rebase pays now, by day.
- [NET Advance](https://netnetintel.com/api/v1/advance): lock NET for 30 days and take 40% of its value in USDG now (the lock's rebase pays it back): `howItWorks` in plain words, a worked `example` on today's rate, `capacity` (USDG open for new locks now, every refill and how fast holders used it up), the terms, the book (outstanding, coverage, shortfall, break-even mark), maturities, the positions most at risk.
- [House Vault](https://netnetintel.com/api/v1/vault): the vault behind Predict: share price, capital, queued exits, settles, depositors.
- [THE BOOK](https://netnetintel.com/api/v1/book): the sportsbook: house pot, open markets, results, weekly totals.
- [Presser card](https://netnetintel.com/api/v1/presser/1): one Button Presser card, No. 1 to 4,999, with its OpenSea ask (`market`) and `opensea` link.
- [Presser search](https://netnetintel.com/api/v1/pressers?plate=brass&character=none&sort=price): Brass and Steel cards by `plate`, `faction` (none, bluechips, frontier, chosen), `character` (none, created), `race`, `listed`, `minPrice` / `maxPrice`, `combine` (and, or), `sort` (price, -price, id, -id), `limit`; cheapest first with OpenSea links, plus each plate's census.
- [Presser census & market](https://netnetintel.com/api/v1/presser): sides, races and plates, the Brass and Steel floors (NetNet Intel tracks those two plates; `market.collectionFloor` is OpenSea's floor for the whole collection, which holds other items too, so it is not a card's price; full collection: https://opensea.io/collection/button-presser), how many are listed, the cheapest asks.
- [Gear search](https://netnetintel.com/api/v1/gear?tier=artifact&sort=price): NetNet Gear by `item`, `tier`, `slot`, `table`, `wearable`, `plate`, `earnedBy`, `listed`, `minPrice` / `maxPrice`, `sort` (price, -price, id, scarcity), `limit`; plus per item its supply, minted, listed and floor ask.
- [Games](https://netnetintel.com/api/v1/games): NetNet's arcade (play.netnet.capital) from NetNet Intel's own index of the games' events: per game (DIAL-UP.EXE, COINflip, SpaceX Invaders, MSFT Flight Simulator; WinNET, the prize draw, on its own row) and window (24h, 7d, 30d, all) plays, players, `wagered`, `paidOut`, `houseResult` and `houseEdge`, `fees` (and the share swept to the manager and to the RWA sleeve), bankroll funding, `netBought` through DIAL-UP's zaps, and `daily`; `?game=dialup` for one. Token amounts exact, USD at today's marks. The games send nothing to the Core Treasury.
- [Where the money goes](https://netnetintel.com/api/v1/value?days=7): the Core Treasury's USDG in by source (`coreTreasury.moneyIn.bySource`: bonds, fees, premium, pteam, desks, …) and out, stated zeros for what the arcade, Turbo and THE BOOK send it, and the RWA sleeve by source (`sleeve.bySource`: games, turbo, book, stocks, netBuybacks). `days`: 1, 7 or 30. MCP: `get_value_capture`.
- [Loop liquidations](https://netnetintel.com/api/v1/loop/liquidations): every Loop (Loopback) liquidation from NetNet Intel's own index, the newest merged from the live feed: `windows` for 30m, 12h, 24h, 7d and 30d (`n`, `repaid`, `seized`, `valueOracle`, `valueMarket`, `profitOracle`, `profitMarket`, `badDebt`), a time `series` (`?window=24h`), who liquidates (`leaders`, `&leaders=7d`) and the latest 20. MCP: `get_loop_liquidations`.
- [Turbo](https://netnetintel.com/api/v1/turbo): Turbo, NetNet Capital's knock-out card desk on tokenized stocks (NVDA, AAPL, SPCX), from NetNet Intel's own index of the desk's events: per window (24h, 7d, 30d, all) cards bought, buyers, `paidUsdg`, opening and performance fees, `payoutUsd`, `deskResultUsd`, `sweptToSleeve`; the series board (`series[]`: strike, leverage, expiry, sold, outstanding, state) and the house's stock pots. `?series=17`, `&days=7`. MCP: `get_turbo`.
- [Official docs](https://netnetintel.com/api/v1/docs?q=knock-out%20card): NetNet Capital's own documentation (docs.netnet.capital), searched: `results[]` with `page`, `heading`, `excerpt` and the `url` to cite. Without `q`, the list of pages; `/api/v1/docs/{page}` for one page (e.g. `/api/v1/docs/turbo`). MCP: `search_docs`, `get_doc`. For what a term means and how a desk works; live figures come from the data endpoints.
- [Shift Run](https://netnetintel.com/api/v1/shiftrun?scope=all): the leaderboard (points only); `scope=all|today`.

Numbers are plain JSON numbers in their natural unit (USD, NET or USDG; not wei). Times are ISO 8601 UTC. OpenSea asks are read by NetNet Intel every 2 minutes for Button Presser cards (every 10 for NetNet Gear) and are not sale prices; give their age and check the link before acting.

### Ask it anything

| Question | Call |
|---|---|
| Cheapest Brass presser with no character, with OpenSea links? | `/api/v1/pressers?plate=brass&character=none&sort=price` (`search_pressers`) |
| Brass pressers with no side or no character, cheapest first? | `/api/v1/pressers?plate=brass&faction=none&character=none&combine=or` |
| Cheapest ARTIFACT gear, and how scarce is each item? | `/api/v1/gear?tier=artifact&sort=price` (`search_gear`; `items[]` has supply, minted, floor) |
| Which Loop loans need to wind down, and how much should they repay? | `/api/v1/loop?status=at-risk,wind-down` (`get_loop`) |
| Is there USDG to take on NET Advance, and how fast do refills go? | `/api/v1/advance` (`get_advance`): `capacity` |
| What are the odds the print is above 29M? | `/api/v1/predict/intel?above=29000000` (`get_predict_intel`) |
| How much did the team buy back this week vs last? | `/api/v1/buybacks?days=7` (`get_buybacks`): `window` and `window.previous` |
| What grew the treasury this month? | `/api/v1/grows?days=30` (`get_growth`): `answer`, `moneyIn.bySource` |
| Do bonds sell slower when NET falls? | `/api/v1/bonds?trend=24h` (`get_bonds`): `demandByTrend` |
| Which whales are selling this week? | `/api/v1/holders?kind=sell&days=7` (`get_holders`): `moves`, `movesByKind` |
| Who holds the LP? | `/api/v1/lp` (`get_lp`): `byClass`, `holders` |
| Total liquidity and volume? | `/api/v1/net` (`get_net`): `liquidity`; per pool in `/api/v1/lp` `allPools` |
| Are the arcade games making money? How many players? | `/api/v1/games` (`get_games`): `totals.d7`, `games[].windows.d7.houseResult` |
| Where does the money go? What feeds the sleeve? Do the games pay the treasury? | `/api/v1/value?days=7` (`get_value_capture`): `coreTreasury.moneyIn.bySource`, `coreTreasury.fromGames`, `sleeve.bySource` |
| How many Loop liquidations in the last 24 hours, and who took them? | `/api/v1/loop/liquidations` (`get_loop_liquidations`): `windows.h24.n`, `windows.h24.repaid`, `leaders.rows` |
| How is Turbo doing? What does the sleeve get from it? | `/api/v1/turbo` (`get_turbo`): `windows.d7.paidUsdg`, `windows.d7.deskResultUsd`, `windows.all.sweptToSleeve` |
| What is X? How does a desk work? What are its rules or fees? | `/api/v1/docs?q=...` (`search_docs`), then `/api/v1/docs/{page}` (`get_doc`): quote and cite `url` |
| What does the sleeve hold beyond its Safe? | `/api/v1/sleeve` (`get_sleeve_memo`) |

## Usage, limits and formats

**Connect.** MCP: `https://netnetintel.com/mcp` (Streamable HTTP; plain JSON replies, no sessions, no auth; protocol versions 2024-11-05 to 2025-11-25). REST: `GET https://netnetintel.com/api/v1/<area>` from any HTTP client and any origin. No key, no account.

**Limits, per minute**

| Surface | Limit | Counted per |
| --- | --- | --- |
| MCP tool calls | 240 | client (address + User-Agent) |
| MCP messages, `initialize`, `ping` and `tools/list` included | 1,500 | address |
| Read API | 120 | address |
| `/api/v1/verify` | 20 | address |
| A2A | 60 | address |

Over a limit: HTTP 429 with `Retry-After` (seconds). The read API answers `{ "error": "rate_limited", "retryAfter": N }`; MCP answers a JSON-RPC error with the request's id, `{ "code": -32029, "message": "Rate limited: retry in N s", "data": { "retryAfter": N } }` (one per message in a batch). Wait N seconds, then retry once.

**Calling it well**

- One call per question: the narrowest tool or endpoint, with its filters (`days`, `kind`, `minUsd`, `status`, `sort`, `limit`). `get_desk` (`/api/v1/desk`) for a broad overview in one call.
- How often the data moves: prices about every 15 s; OpenSea asks every 2 minutes; the indexes (games, Turbo, Loop liquidations) every 5 minutes; holders and bonds every 1-2 minutes. Polling faster returns the same answer.
- Dashboards and scheduled jobs: read `/api/v1/desk` once per run, or the few areas the dashboard shows, every few minutes at most; a daily sync needs one call per area a day.
- Send a `User-Agent` that names your app (no key needed; it shows us what is used).
- Bodies are compact JSON; `?pretty=1` indents them. `?summary=1` gives the compact shape of `/api/v1/holders`, `/advance` and `/buybacks`; over MCP those are compact unless `detail: true`.

**Common chains** (stop as soon as the question is answered: most take one call, few need more than three)

| Question | Calls, in order |
| --- | --- |
| Daily report, dashboard | `get_desk` (`/api/v1/desk`) once; `get_alerts` only for "anything I should know?" |
| Whale check | `get_holders` { kind: "sell", days: 7, minUsd: 10000 } → `get_whale` { address } for the 1-3 that matter; outside the top 50, `get_wallet` |
| Liquidation watch | `get_loop` { status: "at-risk,wind-down" } → `get_loop_liquidations` { window: "24h" } |
| Why did the number move | `get_growth` { days: 7 } → `get_history` { days: 7 } if the path matters; `get_value_capture` for where the money went |
| The weekly print | `get_predict` → `get_predict_intel` { above: [the line] } |
| A figure that drives a decision | its area call → `verify_figures` (core figures) or `get_recipes` { id } to rebuild it |
| A term or rule | `search_docs` { query } → `get_doc` { page } only if the snippet isn't enough |

Don't repeat a call within its refresh time, and don't walk every wallet or loan: use the filters.

**Answer sizes.** Most answers are 1-30 KB. Every list has a cap, so there is no paging: narrow with the filters. On the API, `/api/v1/holders`, `/advance` and `/buybacks` are full unless `?summary=1`; `/api/v1/history` follows the same spacing as `get_history` (`&detail=full` for every 30-minute row).

<!-- sizes:start -->
| Tool | Size controls (MCP arguments; most are query parameters of the same name on the API) | Notes |
| --- | --- | --- |
| `get_history` | `days` 1-90 (default 7); `interval` 30m / 1h / 4h / 1d; `detail` (default false) | 30-minute rows up to 7 days, then 4-hourly (to 30) and daily; `detail: true` is every row (90 days about 1.2 MB) |
| `get_holders` | `moves` 0-500 (default 50); `days`; `detail` (default false) | compact: the decision fields and a detail URL; filter moves with `kind`, `days`, `minUsd`, `address` |
| `get_bonds` | `epochs` 1-90 (default 21) |  |
| `get_buybacks` | `days` 1-90 (default 7); `detail` (default false) | compact unless `detail: true` |
| `get_desk` | none | one call for every area (about 25 KB): the dashboard read |
| `get_games` | `days` 1-30; `detail` (default false) | totals; `detail: true` adds the day-by-day series |
| `get_value_capture` | `days` 1 / 7 / 30 (default 7) |  |
| `search_docs` | `limit` 1-10 (default 5) | the best sections, not whole pages; `get_doc` for one page |
| `get_loop_liquidations` | `window` 30m / 12h / 24h / 7d / 30d (default 24h) |  |
| `get_turbo` | `days` 1-30; `detail` (default false) | totals and the board; `detail: true` adds the series |
| `get_recipes` | none | the catalog without `id`; one full recipe with it |
| `search_pressers` | `limit` 1-200 (default 25) | cheapest first; narrow with `plate`, `faction`, `character`, `maxPrice` |
| `search_gear` | `limit` 1-200 (default 25) | cheapest first; narrow with `tier`, `slot`, `item`, `maxPrice` |
| `get_growth` | `days` | `days` 1-90 or "all" (default 30) |
| `get_loop` | `limit` 1-200 (default 25) | riskiest first; filter with `status`, `minDebt`, `account` |
| `get_advance` | `detail` (default false) | compact unless `detail: true` |
| `get_shiftrun` | `scope` all / today (default all) |  |
<!-- sizes:end -->

**What comes back**

- JSON with the figures in plain units (USD, NET, USDG; never wei) and UTC times. Every body with an `asOf` carries `freshness` { asOf, block, ageSec, maxAgeSec, stale }: quote the block or time with each figure.
- Uptime and what is failing now: https://netnetintel.com/status (`/status.json`, MCP `get_status`).

**Errors and partial answers**

| You get | Meaning | Do |
| --- | --- | --- |
| 400 `{ "error": "bad_request", "message", "allowed"? }` | the arguments are wrong: a bad id or address, or a filter value that doesn't exist (an unknown `kind`, `stance`, `status`, `sort`, `trend`…; never silently ignored) | fix them from `message` / `allowed`; don't retry as is |
| 404 `{ "error": "not_found" }` | no such card, wallet, page or recipe | say so |
| 429 `{ "error": "rate_limited", "retryAfter": N }`; MCP: JSON-RPC error `{ "code": -32029, "message", "data": { "retryAfter": N } }` with the request's id (one per message in a batch) | over a limit | wait N seconds (`Retry-After`), retry once, never in a loop |
| 503 `{ "error": "unavailable", "message", "retryAfter": 30, "fallback": "<recipe URL>" }`; MCP: the same body with `isError: true` | the source is down and nothing is saved | retry once after `retryAfter`; then follow `fallback` (it rebuilds the figure from the chain) or say it is unavailable |
| 200 with `lastGood` { savedAt, reason }, `stale: true`; REST header `x-fallback: last_good` | the source was slow (over 8 s) or down; this is the last good answer | use it, quote its `asOf`, say it may be behind |
| `complete: false`, `unread`, a `note` | part of the answer is missing | say which part |

Never fill a gap from memory. OpenSea asks, the verifier and the status are always live (no last good answers).

**Client code.** Ready-made, dependency-free clients for the read API and MCP that send a User-Agent, wait once on 429/503 and flag answers that aren't live: [Python](https://netnetintel.com/examples/netnet_client.py) (standard library) and [TypeScript](https://netnetintel.com/examples/netnet-client.ts) (fetch: Node 18+, Deno, Bun, browsers, Workers). MIT.

MCP over HTTP:

```sh
curl -s https://netnetintel.com/mcp -H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_net","arguments":{}}}'
```

Python:

```python
from netnet_client import NetNet          # https://netnetintel.com/examples/netnet_client.py
nn = NetNet("my-dashboard/1.0")
desk = nn.get("/api/v1/desk")             # everything once
loans = nn.tool("get_loop", status="at-risk,wind-down")
print(nn.warnings(loans) or "live")       # e.g. ["stale: 640 s old (fresh within 600 s)"]
```

TypeScript:

```ts
import { NetNet } from "./netnet-client.ts";   // https://netnetintel.com/examples/netnet-client.ts
const nn = new NetNet("my-bot/1.0");
const sells = await nn.get("/api/v1/holders", { kind: "sell", days: 7, minUsd: 10000 });
const net = await nn.tool("get_net");
console.log(net.price, net.freshness?.block, NetNet.warnings(net));
```

**MCP clients.** Claude (web and desktop): Customize → Connectors → Add custom connector, paste `https://netnetintel.com/mcp`. Claude Desktop from its config file (`claude_desktop_config.json`): `{ "mcpServers": { "netnet-intel": { "command": "npx", "args": ["-y", "mcp-remote", "https://netnetintel.com/mcp"] } } }`. Claude Code: `claude mcp add --transport http netnet-intel https://netnetintel.com/mcp`. Cursor (`.cursor/mcp.json`): `{ "mcpServers": { "netnet-intel": { "url": "https://netnetintel.com/mcp" } } }`. VS Code (`.vscode/mcp.json`): `{ "servers": { "netnet-intel": { "type": "http", "url": "https://netnetintel.com/mcp" } } }`. ChatGPT: Settings → Apps & Connectors → Developer mode → Create, no authentication, paste the URL.

## For agents

- [MCP server](https://netnetintel.com/mcp): remote MCP (Streamable HTTP, no auth); add it by URL in Claude, Cursor or any MCP client. Tools: `get_net`, `get_nav`, `get_treasury`, `get_supply`, `get_holders` (`moves`, `address`, `kind`, `days`, `minUsd`, `stance`), `get_whale`, `get_bonds` (`epochs`, `trend`), `get_credit`, `get_buybacks` (`days`), `get_predict`, `get_predict_intel` (`above`), `get_loop` (`status`, `account`, `minDebt`, `sort`, `limit`), `get_history`, `get_growth` (`days`), `get_lp`, `get_sleeve_memo`, `get_sleeve_loan`, `get_pendle`, `get_advance`, `get_house_vault`, `get_book`, `get_presser`, `search_pressers`, `get_presser_market`, `search_gear`, `get_shiftrun`, `get_sources`, `verify_figures`, `get_recipes` (`id`, `run`), `get_desk`, `get_peer_check`, `get_alerts` (`minUsd`), `get_wallet` (`address`), `get_games` (`game`, `days`, `detail`), `get_turbo` (`series`, `days`, `detail`), `get_loop_liquidations` (`window`, `leaders`), `get_value_capture` (`days`), `search_docs` (`query`), `get_doc` (`page`), `report_gap` (`question`: when nothing here answers it), `get_status` (uptime: checked about every 5 minutes, every tool in turn about every 35 minutes). Same shapes as the read API, with three differences for agents: `get_holders`, `get_advance` and `get_buybacks` answer compactly unless `detail: true`; every result carries `freshness` { asOf, block, ageSec, maxAgeSec, stale }; when a source is slow (over 8 s) or down, the answer is its last good one, with a `lastGood` note (`savedAt`, `reason`), its own asOf and `freshness.stale: true`; a failure with nothing saved is `{ error, retryAfter, fallback }` (fallback: the recipe that rebuilds the figure from the chain). Uptime: https://netnetintel.com/status. Server card: https://netnetintel.com/.well-known/mcp.json
- [API catalog](https://netnetintel.com/.well-known/api-catalog) (RFC 9727): the read API and the MCP server with their specs, docs and status ([status](https://netnetintel.com/api/v1/status)). Every page also sends `Link` headers to it.
- Markdown pages: request any page (for example https://netnetintel.com/buybacks) with `Accept: text/markdown` for a short live summary of it: what it shows, its current figures with the block, and where to check them.
- [A2A agent](https://netnetintel.com/.well-known/agent-card.json): an Agent2Agent JSON-RPC endpoint at https://netnetintel.com/a2a; `SendMessage` with a question (or a data part `{"skill": "buybacks"}`, or a 0x address) answers with a Markdown summary and the area's JSON.
- [Agent Skills index](https://netnetintel.com/.well-known/agent-skills/index.json): the published skills with their SHA-256 digests. In a browser, the site also registers WebMCP tools (`open_page`, `get_page_summary`, `get_live_data`, `lookup_wallet`).
- [auth.md](https://netnetintel.com/auth.md): no registration, no keys; everything is public, read-only and rate-limited.
- [Agent Skill](https://netnetintel.com/skills/netnet-intel/SKILL.md): which call answers what, how to read the figures, how to verify them.
- When you report a NetNet figure, give the block it was read at; verify it when accuracy matters.
- Not covered yet? Say so rather than estimating, and send the question with the MCP tool `report_gap` (plain words, no personal details). Usage: NetNet Intel counts calls per tool and endpoint to improve the service; it stores no IP addresses, and keeps the questions sent to `report_gap` (and A2A questions it couldn't route) for 90 days.
- [Alerts](https://netnetintel.com/api/v1/alerts?minUsd=10000): what needs attention now (NET Advance open, Loop AT RISK / WIND DOWN, a buyback after a quiet stretch, whale sells over minUsd in 24 h), each with a level (act / watch / info) and its source.
- Every read-API body with an `asOf` carries `freshness` { asOf, block, ageSec, maxAgeSec, stale }; `?summary=1` on /api/v1/holders, /advance and /buybacks gives the compact shape. Bodies are compact JSON (no indentation); add `?pretty=1` to any /api/v1 path or to /openapi.json for an indented copy. If your fetcher caches by URL, add any query (e.g. `?t=<now>`) to get a fresh read.
- [Status](https://netnetintel.com/api/v1/status): the newest successful core read (block, asOf, ageSec) and `stale` when it is older than 10 minutes, plus `mcp`: the heartbeat's view (about every 5 minutes, every MCP tool in turn about every 35 minutes: status, last check, uptime over 24 h, 7 d and 30 d, tools failing now). The page: https://netnetintel.com/status; JSON: /status.json; MCP: `get_status`.
- Last good answers: a read API call (GET) or MCP tool whose source fails, or takes over 8 s, answers with its last good body: HTTP 200, header `x-fallback: last_good`, a `lastGood` field (`savedAt`, `reason`), `stale: true` and its own asOf. Treat it as stale data: quote its time. OpenSea asks, the verifier and the status are always live.
- Errors are small and typed: see **Errors and partial answers** above for each shape and what to do.
- Building on this data: call one endpoint or tool per question (the **Common chains** above for multi-step questions) and quote its `block`/`asOf`; use the filters (`days`, `kind`, `minUsd`, `status`, `sort`, `limit`) rather than fetching everything; treat `stale: true`, `complete: false` or a `note` as part of the answer; on a 429 wait for `retry-after`, and on a 502/503 retry once, then fall back to the recipe (`/api/v1/recipes/{id}`) and read the chain directly. A verify report's `checkedBy` and `independent` say who re-read the chain. The A2A skills (17) route a plain question to the right area; the read API and MCP cover everything with filters.

## Alerts

- [@netnetintel_bot](https://t.me/netnetintel_bot) on Telegram: follow any top-50 wallet and get a message on each of its buys, sells, stakes and transfers of 10 NET or more (the moves NetNet Intel decodes). Connecting a wallet is optional. Deep link to follow one: `https://t.me/netnetintel_bot?start=w_<address without 0x, lowercase>`.

## Key terms

- NAV per NET (core): Treasury.backingPerToken() = Treasury.rfv() ÷ NET.totalSupply(), what the contracts back each NET with.
- RFV: Treasury.rfv(): liquid USDG + the Morpho position after a 2% haircut + protocol-owned liquidity.
- RWA sleeve: tokenized equities, hOHM and positions held by a team-custodied Safe, disclosed and counted by the official Reports, outside RFV and not a guaranteed backstop.
- NAV incl. RWA sleeve: (RFV + the sleeve) ÷ NET in issue, the Reports' "NAV incl. RWAs". True RFV = RFV + the sleeve.
- The number: True RFV in USD. The weekly Predict series asks whether it will be above (HIGHER) or below (LOWER) a fixed line at the print time; a series opens Wednesdays 14:00 UTC.
- HIGHER / LOWER tokens pay 1 USDG if their side is right, so a token's price is the market's implied probability. The model's odds are NetNet Intel's inference, not the desk's price.
- Premium: the TWAP price ÷ NAV per NET (core). The distribution rate follows it: 0.45% per 8-hour epoch at 1.75× and above, zero at 1×.

## Pages

- [Overview](https://netnetintel.com/): price, both NAVs, the treasury at a glance, the live Predict series
- [What grows NET](https://netnetintel.com/grows): how much the treasury grew and from where: money in by source, the sleeve by asset class, the effect per NET
- [NAV](https://netnetintel.com/nav): NAV per NET core and incl. the RWA sleeve, side by side, with each figure's source
- [Treasury](https://netnetintel.com/treasury): every holding read on-chain
- [Holders & whales](https://netnetintel.com/holders): the top 50 wallets, their moves decoded, follow any on Telegram
- [Supply & Staking](https://netnetintel.com/supply): supply decomposition, sNET emissions and known holders
- [Predict](https://netnetintel.com/predict): the model's call on the weekly print, its graded record, the book and past prints
- [Liquidity](https://netnetintel.com/liquidity): NET/USDG LP pools
- [Bonds](https://netnetintel.com/bonds): the BondDepository's bonds and offering board
- [Credit](https://netnetintel.com/credit): NetNet Credit, Loopback and Pendle loans
- [Advance](https://netnetintel.com/advance): NET Advance positions
- [The Book](https://netnetintel.com/book): sports spreads settled in wsNET
- [Buybacks](https://netnetintel.com/buybacks): what the team buys back from the RWA sleeve's Safe, at what price against NAV, through which venues and paid from what; the Treasury's inverse-bond floor bid; the fee schedule; the treasury's inflows by source are charted on NAV
- [Contracts](https://netnetintel.com/contracts): the discovered NetNet contract registry
- [Risks](https://netnetintel.com/risks): smart-contract, admin and economic risk map
- [Claims](https://netnetintel.com/claims): what NetNet claims, checked on-chain
- [Report Reconciliation](https://netnetintel.com/reconciliation): the official terminal's figures against a reconstruction from raw balances
- [Sources](https://netnetintel.com/sources): data hierarchy, methodology and audit trail
- [Verify](https://netnetintel.com/verify): your browser re-reads the on-chain figures from the public RPC at the served block and compares
- [Recipes](https://netnetintel.com/recipes): how every figure is built, with a Run button that rebuilds it in your browser
- [Community desk](https://netnetintel.com/desk): the ecosystem on one screen, each figure checkable from the chain
- [Button Presser](https://netnetintel.com/presser): faction, race and plate census, card and gear lookup, OpenSea asks
- [Shift Run](https://netnetintel.com/shiftrun): the arcade; beat the number to the print line. Points only, nothing to wager.

## Optional

- [Trade](https://netnetintel.com/trade): Predict trades signed by the visitor's own wallet; the site holds no keys or funds
- [Wallet](https://netnetintel.com/wallet): look up any address's NET holdings
- [NAV Lab](https://netnetintel.com/nav-lab): scenario calculator from the live figures
- [Research](https://netnetintel.com/research)