# Kairos Signal — Verifiable DePIN Data API

> Verifiable DePIN and physical-world data, with cryptographic receipts.
> A machine-readable DePIN (Decentralized Physical Infrastructure Networks) + physical-world data product for AI agents and MCP clients.
> A 731-entry catalog (every catalog row, superseded and subnet rows included).
> 317 networks carry live data — 289 of the networks first-party, read straight
> from the network's own endpoint or chain. That is 18,790 live series, refreshed
> continuously, with daily snapshot history on 315+ live networks plus 129 Bittensor subnets (1703 distinct SN series; browsable per-subnet pages at /subnet/SN8.html, full index /sitemap-subnets.xml).
> Catalog entries without live data yet are labelled `catalog_only` in /v1/networks so you can
> filter them out in one line.
> Every value carries {symbol, metric, value, unit, source, verify_url, as_of}. The verify_url points to the UPSTREAM
> source it was read from — the network's own API, CoinGecko, or DefiLlama — so you can check any number without trusting us.
> Each daily batch is Merkle-rooted and timestamped to Bitcoin via OpenTimestamps. This is a DATA product: no trading
> signals, no performance/return/accuracy claims. Coverage figures are restamped from the
> live warehouse; each value carries its own as_of.

## What this is (and is not)
- IS: measured DePIN infrastructure facts — supply, price/market cap, protocol fees/revenue, TVL, and per-network operational telemetry — each with provenance and an upstream verify_url.
- IS NOT: a trading signal or a prediction product. No win-rate, edge, return, or accuracy figures are published anywhere.
- LAYERS: (1) Ground truth: measured DePIN and physical-world telemetry, each value with source, as_of and an upstream verify_url; a value that has stopped updating is returned flagged is_stale, and a metric with no verified value is omitted, never zero-filled. (2) Structural math: descriptive analytics computed from those values (Marchenko-Pastur correlation spectra, Hodge lead-lag decomposition, Shapley attribution, measured supply change, slashing capacity), each returning its inputs; none is a forecast. The 63-layer manifold encoder at dag.kairossignal.com runs untrained initialization weights (a fixed random projection, plus fresh layer-51 noise on the default path); its JSON answers carry model_state. (3) Delivery with receipts: REST API, MCP server, A2A adapter; data-API responses are ed25519-signed (below) and daily batches are Merkle-rooted and anchored to Bitcoin.

## Access
- REST API + MCP endpoint are LIVE and self-serve. Register at POST https://kairossignal.com/v1/credits/register — instant, no approval, $5 free credits (first 3 keys per IP per 30 days), no card.
- New agents receive $5 in free credits (first 3 keys per IP per 30 days) on registration (no card). 1 credit = 1 USD.
- Per-value verification is live: GET https://kairossignal.com/v1/attest?symbol=AKT&metric=price_usd&date=20260901 returns that row's Merkle inclusion proof and the batch's Bitcoin anchor (OpenTimestamps), for batches whose row-level data is retained (2026-08-29 onward; earlier batches are anchor-only and answer attested:false). Every value is also checkable at its verify_url upstream.

## Verifiable receipts — DePIN data-API responses are signed
Every response from the DePIN data API (/v1/networks, /v1/network/<SYM>, /v1/supply,
/v1/market, /v1/history, /v1/attest, /v1/network-signals, /v1/export, /v1/watchtower
and its other routes; JSON, CSV, NDJSON and markdown alike) carries an ed25519
signature, so you can prove later what was served and when, without us. No
X-Kairos-Signature on: the account and credits routes (/v1/credits/*, /v1/derivation,
/v1/data-dictionary, /v1/revision-ledger), the engine routes (/v1/node-quality,
/v1/dilution-risk, /v1/gpu-supply-demand, /v1/geo-concentration, /v1/sector-health,
/v1/dev-velocity, /v1/competitive-landscape), the analytics routes
(/v1/regime, /v1/pairs, /v1/shape, /v1/fragility), and MCP or A2A replies.
Check a signed one:

  curl -sD- -o body.json https://kairossignal.com/v1/networks | grep -i x-kairos
  # x-kairos-timestamp: <RFC3339 UTC>
  # x-kairos-signature: ed25519:<base64>
  # x-kairos-signing-key: https://kairossignal.com/.well-known/kairos-signing-key.json

Signed payload: `kairos-signal-v1|sha256(body)|timestamp|path`. Public key and a
verification snippet are at the signing-key URL. A stored response can be checked
offline months later. Tampering with the body, replaying the signature onto a
different path, or altering the timestamp all fail verification.
This key signs statements only — it is separate from any payment address and
cannot move funds.

## USDC top-ups on Base: two modes
Check GET https://kairossignal.com/v1/credits/crypto for current availability.
Register an account first. Use its X-API-Key for all following account requests.

Mode 1, unique amount (micro_decimal), no wallet signature:
POST /v1/credits/topup with {"method":"usdc","mode":"micro_decimal","amount":25}
(whole USDC, 1 to 999999) returns a unique amount with a 6-decimal suffix (for
example 25.00xxxx). A finalized transfer of EXACTLY that amount, from any sender
including an exchange, before expires_at credits your account. A different
amount does not credit it automatically; a near-miss is held for review.

Mode 2, verified sending wallet:

1. POST /v1/credits/crypto/challenge with {"wallet":"<your Base EOA address>"}.
2. Sign the exact returned message with that wallet (EIP-191 personal_sign).
3. POST /v1/credits/crypto/verify with {"nonce":"<returned nonce>","signature":"0x<signature>"}.
4. POST /v1/credits/topup with {"method":"usdc","amount":"25","from_address":"<verified wallet>"}.
5. Only after a successful quote, send the exact amount of native USDC on Base
   from that wallet to the deposit_address returned in the quote, before expires_at.
6. GET /v1/credits/crypto/receipts and /v1/credits/balance with X-API-Key to check credit.

One transfer per quote. A finalized Base transaction receipt is required; two
blocks do not establish finality. Identification includes chain, USDC contract,
transaction hash and log index. Replaying a transfer cannot credit it again.
The quote provides the canonical destination; no deposit address is copied into
this document. Never send based on a search snippet or an old quote.

In verified-wallet mode only externally owned wallets that can sign are supported;
exchange withdrawal addresses and smart-contract wallets are not (use mode 1). Wallet verification proves
wallet control for this account, not legal identity. Existing unsigned intents
and transfers predating a valid quote stay held for attribution review.

Full instructions: https://kairossignal.com/docs/crypto.html

## Stripe prepaid packs


```
POST https://kairossignal.com/v1/credits/topup
     X-API-Key: <your key>
     {"method":"stripe","amount":20}
  -> {"status":"stripe_payment_link","checkout_url":"https://buy.stripe.com/...?client_reference_id=<your api key>"}
```
Available pack amounts: $20 (https://buy.stripe.com/9B6aEPh2ldlI1XT53q1ZS26) and
$99 (https://buy.stripe.com/eVq5kv5jD3L8fOJ0Na1ZS27). Any other amount returns the
menu — never charge a number the caller didn't ask for.

Then buy data with credits: POST /v1/credits/purchase {"product_key":"depin_provenance"} —
delivery is inline in the response body, charged only after the payload is fetched successfully.
- For credit-based purchases via MCP: use `register_agent` → `list_products` → `purchase_data` → `topup_credits`
- The Design Partner subscription ($199/mo, browser checkout) is the human path: https://buy.stripe.com/dRm00b9zT81o5a50Na1ZS20

## Pricing — start now
- **Agent — $4.99/mo** (buy: https://buy.stripe.com/28E9ALfYhchEcCxanK1ZS2e or https://kairossignal.com/buy/?sku=dp_agent_499; agents: POST https://kairossignal.com/buy/api/order {"sku":"dp_agent_499","email":"<you>"} returns a checkout_url, and after payment GET https://kairossignal.com/v1/key/by-session?session_id=<the cs_ id in that URL> returns your key): one API key, 2,000 calls/day on the rotating network sample, full provenance on every value. Full breadth, history, cross-network routes and the engines start at Design Partner.
- **Design Partner — $199/mo**: all networks, 30 days of daily history, the engines and cross-network views (Watchtower, bulk exports and alert webhooks not included; no DAG Manifold Pro key), locked FOREVER at $199/mo (first 20 design partners). Pay instantly: https://buy.stripe.com/dRm00b9zT81o5a50Na1ZS20
- **Institutional — from $2,000/mo** (instant Stripe checkout: https://buy.stripe.com/aFa14ffYh81odGBdzW1ZS2a | annual $20,000/yr, two months free: https://buy.stripe.com/aFadR17rLdlI7id0Na1ZS2b): fund-grade engine suite for research desks — FDV/dilution map (every in-scope network with a live CoinGecko market cap, EXTREME-MINIMAL; out-of-scope, stale and duplicate-coin rows listed as excluded), supply-demand divergence detector, machine-detected revision ledger (45 upstream restatements preserved as evidence), byte-pinned provenance rail, node quality, GPU supply/demand. Details: https://kairossignal.com/institutional.
- **DePIN Revenue Snapshot — $2.99**: DefiLlama fee and revenue figures (REV_24H/REV_30D are DefiLlama fees totals total24h/total30d; an aggregator's numbers, labelled, not fees we read from each chain) for every network /v1/revenue serves. The free GET /v1/revenue serves the same networks and values; the purchase adds a receipt, not more data.
- **DePIN Networks Catalog — $0.99**: every catalog entry with its coverage tier label, including entries ruled out of scope, defunct or superseded and Bittensor subnet rows; its length is not a count of DePIN networks.
- **DePIN Supply Snapshot (`depin_provenance`) — $0.49**: the full /v1/supply payload, first-party supply telemetry across 146 networks (in-scope networks only; free tier shows a rotating sample) — node counts, GPU capacity and utilisation where a network publishes them (most networks carry only token-contract reads such as total supply and holders), every value with source + verify URL; withheld or stale series are listed under withheld_not_live, never served. The cheapest way to see what the free sample hides.
- **Derivation Ledger full payloads — $2.99**: the newest 100 recorded derivation-ledger fetches (or 100 for one symbol you name), each with raw_body, derived values, source, raw_fidelity, the replay request (JSON-RPC request bodies were not recorded) and a per-row proof of what that row shows. raw_sha256 shows the recorded body is what we received; whether a published value came from that body is stated per row. Only the collector sources listed in the index; code_sha256 names the build, whose source is not served publicly. Index is FREE: GET /v1/derivation
- **DAG Manifold API — $99 for 30 days (1,000 requests/day), product dag_manifold_30d; free tier 10 requests/day per client IP, no key**: 32-dim vectors from an untrained 63-layer encoder (a fixed random-feature map of each tick's symbol-name, sector and price-magnitude hashes, log price and hour/day features). Distances are not correlations; the two batch statistics (batch log top singular value, batch half-norm ratio) are not a Lyapunov exponent or a Wilson-loop curvature. Send the key as X-API-Key. Not included in Design Partner.
- **MCP tools — the read-only tools are free within a daily per-IP quota**: structured DePIN data via Model Context Protocol (no per-query charge). 5 paid analytics tools charge credits per answered call, as each tool's description states (listed under "MCP Endpoint" below); data products are bought with credits via purchase_data.
- **Node Quality Score — $4.99**: raw vs active node counts per network with a live first-party count; an A-F grade only where an active count is measured in the same cycle, else UNGRADED; stale and non-node figures withheld with the reason (e.g. TFT and STORJ, where most registered nodes are offline, disqualified or exited). Each row carries the engine's own caveat — STORJ's ratio counts every node its satellites have ever seen, so it reflects lifetime churn, not current reliability — plus a verify_url.
- **Dilution Risk Map — $4.99**: FDV/MC ratio per DePIN network with a live market-cap measurement (CoinGecko quote within 48 h), banded EXTREME to MINIMAL; symbols ruled not DePIN, defunct or superseded, stale market caps and duplicate CoinGecko coins are excluded and listed under excluded. The delivery's networks_analyzed states how many.
- **GPU Supply/Demand — $9.99**: io.net GPUs by model (latest inventory capture); Akash GPU/CPU/storage totals; Golem only when live (withheld since 2026-10-02 under a quality incident); each input with source, verify_url and as_of. Read the response for current coverage, timestamps and field definitions.
- **DePIN Intel Bundle — $29.99**: node quality, dilution risk, GPU supply/demand, sector health, geo concentration, dev velocity and competitive landscape plus rule-generated summary entries (fixed text templates, no language model; conviction/sector-health/sustainability rung scores only where every input is live; moat withdrawn). Current bundle contents and coverage: /v1/credits/pricing.
- **Sector Health Index — $4.99**: a coverage-and-market index per DePIN category (A-F bands; most of its points measure our own data coverage of the category, so it is not a health measure).
- **Geographic Concentration — $4.99**: reported geographic distribution and concentration measures where the upstream supplies them. Coverage and denominators are stated in the response.
- **Dev Velocity — $4.99**: GitHub repository readings per DePIN network with a tracked repository: stars, forks, issues, days-since-push, active vs dormant; each row dated, activity as of the reading, stale readings withheld.
- **Competitive Landscape — $9.99**: CoinGecko market-cap share within a hand-coded list of networks per category; HHI only with at least 3 members holding a live cap. Read the response for the measured population and current values.
- **Card one-shot, no account**: $4.99 — https://buy.stripe.com/14A28j6nH3L85a5gM81ZS28 (credits post instantly, key auto-provisioned)
- **Free onboarding spec**: GET /v1/data-dictionary — freshness, history depth, coverage per feed, machine-legible.
- Prepaid credits (no subscription): $20 → https://buy.stripe.com/9B6aEPh2ldlI1XT53q1ZS26 | $99 → https://buy.stripe.com/eVq5kv5jD3L8fOJ0Na1ZS27
- **USDC on Base, two modes** — unique amount (micro_decimal, no wallet signature, any sender) or verified wallet; both need a current quote (steps above). Check /v1/credits/crypto for current availability.
- **Per-request x402, no account at all** — GET https://kairossignal.com/x402 for the live product/price descriptor; GET a product URL (e.g. https://kairossignal.com/x402/v1/data/depin_networks) unpaid for a 402 + PAYMENT-REQUIRED payment options header; pay with any standard x402 client (USDC on Base, the first entry of the offer, settled through a public facilitator) or with Circle Gateway batched settlement; retry the same signed authorization on the same URL to receive the data inline with a PAYMENT-RESPONSE settlement receipt. Catalog and prices live at https://kairossignal.com/x402/openapi.json — fetch them rather than trusting a cached copy.

## Proof you can check before trusting us
https://kairossignal.com/node-count-gap — the four DePIN networks that publish BOTH a
cumulative headline count and a live count, side by side with the ratio between them.
Every row links the network's OWN API, so you can re-derive each figure in one curl with
no key and no account. The page carries an as_of and is regenerated; the underlying
counts move, which is the entire point. Figures are deliberately NOT restated here — a
number copied into a second file is a number that will drift away from the first.
This is the clearest single demonstration of what the data is for.

## Endpoints (self-serve — no approval)
_Keyless browsing surfaces need no account at all. Tier-gated views are unlocked by a
subscription, NOT by credits: credit purchases ship data inline and debit your balance
but do not change your tier (verified 2026-09-13)._
- GET /v1/networks            — coverage list: symbol, name, category, whether stamped on-chain, plus the not-covered map. No credit debit; endpoint tier and request limits apply.
- GET /v1/network/<SYM>       — every metric held for one network, each row provenance-stamped. No credit debit; endpoint tier and request limits apply.
- GET /v1/supply             — in-scope first-party supply telemetry across 146 networks (the count the endpoint itself reports as n_networks_available), each value with age + freshness. No credit debit; endpoint tier and request limits apply.
- GET /v1/market             — price_usd, market_cap_usd, fully_diluted_valuation_usd. No credit debit; endpoint tier and request limits apply.
- GET /v1/revenue            — DefiLlama fees and revenue: REV_24H / REV_30D (DefiLlama fees total24h / total30d) and DL_FEES_24H/7D/30D/ALLTIME_USD, DL_REV_24H/7D/30D_USD where DefiLlama has them (aggregator figures, labelled). Free callers get every network it serves. TVL is in /v1/market. No credit debit; endpoint tier and request limits apply.
- GET /v1/brief              — the daily Partner Brief (generated 08:00 UTC, public to all), machine-readable: capacity-vs-demand
                               divergence per network, frozen upstream feeds (dashboards that answer but
                               stopped updating), on-chain supply verifiability, exchange-flow extremes,
                               holder concentration, 7d supply movers. `?date=YYYY-MM-DD` for an older
                               edition. FREE on every tier — it is the clearest proof of what the data buys.
                               Human-readable: https://kairossignal.com/briefs/
- GET /v1/provenance         — {metric, source, verify_url, as_of} for every value we publish. No credit debit; endpoint tier and request limits apply.
- GET /v1/node-quality       — raw vs active node counts; an A-F grade only where an active count is measured, else UNGRADED with the reason. No credit debit; endpoint tier and request limits apply.
- GET /v1/dilution-risk      — FDV/MC ratio analysis per in-scope network with a live market-cap measurement (exclusions listed). Classifies EXTREME/HIGH/ELEVATED/LOW/MINIMAL. No credit debit; endpoint tier and request limits apply.
- GET /v1/gpu-supply-demand  — GPU model counts and reported capacity/utilization; response carries current coverage and source details. No credit debit; endpoint tier and request limits apply.
- GET /v1/intel              — rule-generated summary entries (fixed templates, no language model) with heuristic rung scores; moat withdrawn; coverage is reported by the live product catalog. No credit debit; endpoint tier and request limits apply.
- GET /v1/sector-health      — coverage-and-market index per DePIN category (not a health measure). No credit debit; endpoint tier and request limits apply.
- GET /v1/geo-concentration  — geographic distribution + concentration risk (TFT node-level). No credit debit; endpoint tier and request limits apply.
- GET /v1/dev-velocity       — GitHub activity: stars, forks, issues, days-since-push per network with a tracked repository. No credit debit; endpoint tier and request limits apply.
- GET /v1/competitive-landscape — CoinGecko market-cap share within a hand-coded list per category; HHI only with at least 3 members holding a live cap. No credit debit; endpoint tier and request limits apply.
- GET /health                — liveness probe. Free.
- GET /try                   — free, no signup, no key. 3 showcase DePIN networks with full supply telemetry + verify_url. Try before you buy.
- POST /mcp                  — Model Context Protocol (JSON-RPC 2.0); every tool is listed under "MCP Endpoint" below.

## Row shape (provenance on every field)
```json
{
  "symbol": "AKT",
  "metric": "circulating_supply",
  "value": 383502056.718427,
  "unit": "tokens",
  "source": "CoinGecko /coins/markets",
  "verify_url": "https://www.coingecko.com/en/coins/akash-network",
  "as_of": "2026-08-09T17:15:20Z"
}
```
The as_of is the snapshot instant; open verify_url to compare against the current upstream figure.

## MCP quickstart
1. Register for a key; starter-credit limits apply. Read the actual returned balance and keep the key even if no free credit is granted:
```json
POST https://kairossignal.com/mcp
{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"register_agent","arguments":{"agent_name":"my-agent","email":"agent@example.com"}}}
```
2. Browse products:
```json
POST https://kairossignal.com/mcp
{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"list_products","arguments":{}}}
```
3. Buy a data product after checking its current price and your actual balance (delivery is inline):
```json
POST https://kairossignal.com/mcp
{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"purchase_data","arguments":{"product_key":"depin_provenance","api_key":"YOUR_KEY"}}}
```
4. Top up credits — agents use crypto (Stripe needs a browser and a card):
```json
POST https://kairossignal.com/mcp
{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"topup_credits","arguments":{"method":"crypto","amount":25,"from_address":"0xYourWallet","api_key":"YOUR_KEY"}}}
```
First verify the sending EOA using the challenge flow above. A successful quote returns
the receiving address, amount and expiry. Credit requires a finalized Base transfer.

## Browsing, credit products, and subscription access
- Public GET browsing does not debit credits; response breadth and request limits depend on the served tier.
- Credit-funded products require an explicit POST /v1/credits/purchase (or MCP purchase_data). Current product keys, prices and availability are returned by GET /v1/credits/pricing.
- A successful product purchase delivers data inline and deducts its price from the account balance. Check that balance first; a capped registration can receive no free credit.
- Credits do not unlock subscription-only endpoints. Subscription access is described at https://kairossignal.com/pricing.
- /health is a free liveness probe.

## Coverage & depth (regenerated from live truth; see /v1/networks to re-measure any figure yourself)
- 317 networks carry live data (289 of the networks first-party, read from the network's own
  endpoint or chain); 18,790 distinct live series, 7,313 of them first-party series; a 731-entry
  catalog in total — entries without live data are labelled `catalog_only` in /v1/networks
  (filter them in one line).
- Daily snapshot history: 315+ networks plus 129 Bittensor subnets, 1703 distinct SN series. Per-subnet pages: https://kairossignal.com/subnet/SN8.html (index: /sitemap-subnets.xml)
  Market data (price, market cap, FDV) on 238 networks.
- Capacity utilisation, measured honestly (this is the scarce one): we compute a ratio only
  where we independently hold BOTH halves. That is AKT (cores, memory, storage, GPUs),
  TFT (cores, memory, storage), IO (devices) and SC (storage). FLUX was added 2026-08-24 as
  an ALLOCATION ratio (reserved capacity, not measured consumption — Flux publishes no
  per-app usage) covering cores, memory and storage. STORJ publishes NO capacity denominator at all
  (measured 2026-08-24): its public figures are all numerator — bytes stored by customers and
  the node-side footprint after erasure coding — and its per-satellite node counts are
  memberships, so one node on three satellites counts three times. We therefore publish no
  Storj utilisation ratio; the numerator is collected and labelled as consumption. Most networks publish a numerator and no denominator at
  all; we say so rather than inventing one.

## World intelligence (measured physical-world telemetry, as of 2026-08-24)
Beyond token networks, the same provenance-first pipeline measures the physical world:
- Maritime AIS: 4,148 vessels tracked in the latest snapshot from 2 national feeds (Norway 3,491, Finland 657).
- Satellites: 26 constellations tracked (physical-satellite telemetry).
- GPS interference: 29 days of jamming-map coverage (2026-07-25 to 2026-08-22; upstream lags ~2 days).
- BitTorrent DHT: 6,416 servers measured directly; implied network size ~2.16M nodes.
- Nym mixnet: 1,096 bonded nodes.
- Airspace: 437 military aircraft airborne and 122 active TFRs in the latest snapshot.
- Estate-wide: 108 sectors, 21.2M rows ingested in the last 24h.
Every world-intelligence value carries the same {source, verify_url, as_of} provenance as the DePIN rows.
- Depth (distinct live metrics per network, last 7 days, queried 2026-08-24): Akash 249, io.net 119, Storj 78, ThreeFold 63, WeatherXM 51, Filecoin 50, Aethir 49, Althea 47, The Graph 45, Lava 45, Nym 44, Fetch.ai 44, Grass 42, Flux 40, Geodnet 39, Livepeer 39.

## Provenance (real source mix — not all first-party; as of 2026-08-25)
- first-party: first-party series read from the network's own API / chain (289 networks with first-party telemetry)
- CoinGecko: price, market cap, FDV on 288 networks
- DefiLlama: protocol TVL, fees & revenue
- GitHub: developer-activity telemetry
Every row names its source; /v1/provenance lists the full map.

## Two trust guarantees
1. verify_url — every value points at the upstream source it was read from. Open it and confirm; if it doesn't match, we're wrong.
2. Bitcoin anchor — each daily batch is hashed into one Merkle root (e.g. the 2026-08-09 batch: 1,369 values -> 9cd92fde04...987318b7), submitted to OpenTimestamps across 4 independent calendars and confirming on the Bitcoin blockchain. We cannot backdate or alter a batch after the fact.

## Honesty policy
- Where a network publishes no free feed, it is flagged in the coverage map. We never fabricate a value to fill a gap.
- No trading-performance figures are published. No personal data is sold. We hold an email address per API key (a placeholder if none is given) and request logs with IP address and user-agent; the full list is at https://kairossignal.com/compliance

# Featured analysis
- https://kairossignal.com/divergence.html — "Two compute networks, the same eleven days, opposite directions": io.net grew registered devices +23.9% while delivering +0.0% more compute-hours; Akash GPU utilisation rose 31.6%->61.2% on a shrinking fleet. Only measurable with both halves of the utilisation ratio, timestamped — which is the product.

## Agent Quickstart (register → pricing → credit-funded data)

```bash
# 1. Register (free, $5 credits (first 3 keys per IP per 30 days), no card)
curl -X POST https://kairossignal.com/v1/credits/register \
  -H "Content-Type: application/json" \
  -d '{"email":"your-agent@example.com","agent_name":"your-agent"}'
# The response includes api_key and the actual credits_balance.
# A capped signup can receive no free credit; keep its key rather than registering again.
# Use the returned key below and check the balance against the current product price.

# 2. Browse products
curl https://kairossignal.com/v1/credits/pricing

# 3. Purchase the starter supply snapshot (requires enough credits; delivers data inline)
curl -X POST https://kairossignal.com/v1/credits/purchase \
  -H "Content-Type: application/json" \
  -H "X-API-Key: abc123..." \
  -d '{"product_key":"depin_provenance"}'
# On success, data contains the first-party supply snapshot (every in-scope network /v1/supply serves; withheld or stale series are listed under withheld_not_live, never served), not the intel bundle.
# If the actual balance is insufficient, top up the same account before purchasing.

# Top up when free credits run out — autonomous, USDC on Base:
curl -X POST https://kairossignal.com/v1/credits/topup \
  -H "X-API-Key: abc123..." \
  -H "Content-Type: application/json" \
  -d '{"method":"crypto","amount":25,"from_address":"0xYourWallet"}'
# First complete the wallet challenge and signature verification described above.
# The successful quote supplies the current receiving address, exact amount and expiry.
# Send only after that quote; credit requires a finalized Base transfer.
```

## MCP Endpoint
Connect at `https://kairossignal.com/mcp` (MCP 2025-11-25 (also negotiates 2025-06-18, 2025-03-26, 2024-11-05); streamable HTTP)
Tools: get_network_signals, find_networks, get_network, get_metric_history, verify_value, register_agent, list_products, purchase_data, topup_credits, check_balance, list_datasets, get_stats, get_data_dictionary, get_derivation_ledger, fetch_dataset, verify_footprint, get_hodge_regime_sieve, get_rmt_regime_state, get_depin_slashing_audit, get_shap_node_attribution, get_listing_dilution_score — 21 tools, 5 of them paid analytics tools charged in credits per answered call.
Paid per answered call: get_hodge_regime_sieve (1 credit), get_rmt_regime_state (1 credit), get_depin_slashing_audit (2 credits), get_shap_node_attribution (1.5 credits), get_listing_dilution_score (1 credit).
Read-only edition (no account, purchase or payment tools): `https://kairossignal.com/mcp/public` — it serves 11 tools.

## MCP Server
MCP endpoint (streamable HTTP): https://kairossignal.com/mcp
Available tools: get_network_signals, find_networks, get_network, get_metric_history, verify_value, register_agent, list_products, purchase_data, topup_credits, check_balance, list_datasets, get_stats, get_data_dictionary, get_derivation_ledger, fetch_dataset, verify_footprint, get_hodge_regime_sieve, get_rmt_regime_state, get_depin_slashing_audit, get_shap_node_attribution, get_listing_dilution_score
Ask questions with find_networks -> get_network -> get_metric_history -> verify_value (read-only, no key).
Auth: X-API-Key header (register free at /v1/credits/register for $5 credits (first 3 keys per IP per 30 days))
.well-known/mcp.json: https://kairossignal.com/.well-known/mcp.json

## HTML surfaces for humans (and agents that read HTML)

- https://kairossignal.com/ — the product front page: what the API is, the provenance model, pricing.
- https://kairossignal.com/depin-data-api — the REST endpoints and the live coverage counts (stamped from live truth on the page itself); row shape and auth.
- https://kairossignal.com/depin-supply-data — first-party supply telemetry; what "supply" means and how revisions are kept.
- https://kairossignal.com/depin-intelligence — the working method: definitions before calculations, calculations before interpretation.
- https://kairossignal.com/diligence — evidence-based DePIN diligence: what we measure, what we can't, and why that matters.
- https://kairossignal.com/pricing — tiers: free key ($5 credits (first 3 keys per IP per 30 days), first 3 keys per IP per 30 days), Design Partner $199/mo, Pro, Enterprise.
- https://kairossignal.com/network/ — per-network pages with live metrics and sources.
- https://kairossignal.com/blog/ — the research brief archive; every claim sourced.

## Not investment advice
Kairos Signal is not a broker-dealer, investment advisor, or financial services provider.
Nothing published here is a recommendation to buy or sell any asset. All outputs are
measurements and research, for informational purposes only, without warranty.
Terms: https://kairossignal.com/terms
Disclaimer: https://kairossignal.com/disclaimer