KAIROS Signal API

The only comprehensive DePIN data API. 350+ projects, 254+ variables per project, 800,000+ global sensors. All cleaned, normalized, and cross-validated against physical infrastructure reality.

Technical Brief

KAIROS Signal is a vertically-integrated data intelligence platform purpose-built for decentralized physical infrastructure networks (DePIN). Rather than repackaging existing exchange feeds, we built a multi-layer ingestion and analysis pipeline that connects five distinct data domains:

1. DePIN Project Layer

Direct ingestion from 350+ DePIN project APIs, on-chain contracts, and validator endpoints. We collect node count, uptime, throughput, capacity, earnings, churn rate, geographic distribution, and 240+ additional variables per project. Each collector runs on a concurrent pipeline with configurable refresh cadence.

2. Solana On-Chain Layer

Dedicated RPC connections to Solana mainnet for real-time token analytics — supply, price, holder distribution, and DeFi activity across all Solana-native DePIN tokens. Separate market data collectors cross-reference pricing from multiple independent oracles.

3. Physical Sensor Network

800,000+ sensors from NOAA Space Weather, US Energy Grids (EIA), Maritime AIS, and 15+ government agencies. These physical-world signals are correlated with on-chain network performance to identify divergences invisible to pure financial analysis.

4. Exchange & Market Data

High-throughput WebSocket ingestion from major exchanges — order books, trades, funding rates, open interest, and liquidation events. Data is passed through an artifact rejection sieve before storage to eliminate anomalous ticks and bad data.

5. Analytical Engine (17 Layers)

All raw data passes through 17 proprietary analytical layers grounded in econophysics, information theory, and nonlinear dynamics:

Data Pipeline Architecture

ARCHITECTURE
┌─────────────────────────────────────────────────────────────────────┐
│  INGESTION LAYER                                                     │
│  ┌──────────────┐ ┌───────────┐ ┌──────────┐ ┌──────────────────┐  │
│  │  DePIN APIs   │ │  Solana   │ │ Exchange │ │  Physical Sensor │  │
│  │  350+ direct  │ │  RPC +    │ │  WebSocket│ │  NOAA / EIA /   │  │
│  │  collectors   │ │  Oracles  │ │  Streams │ │  AIS / Gov      │  │
│  └──────┬───────┘ └─────┬─────┘ └─────┬────┘ └────────┬────────┘  │
│         └───────────────┴─────────────┴────────────────┘            │
│                                │                                     │
│                    L1 Sieve (artifact rejection)                     │
│                                ▼                                     │
│                   ┌────────────────────────┐                        │
│                   │   ClickHouse Cluster    │                        │
│                   │   48 tables · ~100M/day │                        │
│                   └───────────┬────────────┘                        │
│                               ▼                                     │
│                   ┌────────────────────────┐                        │
│                   │  17 Analytical Layers   │                        │
│                   │  Econophysics Engine    │                        │
│                   └───────────┬────────────┘                        │
│                               ▼                                     │
│    ┌───────────┐   ┌────────────┐   ┌──────────────┐               │
│    │ REST API  │   │ WebSocket  │   │  Snowflake   │               │
│    └───────────┘   └────────────┘   └──────────────┘               │
└─────────────────────────────────────────────────────────────────────┘

Authentication

All API requests require an API key passed in the X-API-Key header. You receive your API key immediately after subscribing.

CURLcurl -H "X-API-Key: ks_your_api_key_here" \
  https://kairossignal.com/api/v1/projects

PYTHONimport requests

API_KEY = "ks_your_api_key_here"
BASE = "https://kairossignal.com/api/v1"

headers = {"X-API-Key": API_KEY}
projects = requests.get(f"{BASE}/projects", headers=headers).json()

JAVASCRIPTconst API_KEY = "ks_your_api_key_here";
const BASE = "https://kairossignal.com/api/v1";

const res = await fetch(`${BASE}/projects`, {
  headers: { "X-API-Key": API_KEY }
});
const projects = await res.json();

Quick Start

Get up and running in 60 seconds:

BASH# 1. Subscribe at https://kairossignal.com/#pricing
# 2. Copy your API key from the success page
# 3. Test it:

export KAIROS_KEY="ks_your_key_here"

# List all 350+ DePIN projects
curl -s -H "X-API-Key: $KAIROS_KEY" \
  https://kairossignal.com/api/v1/projects | python3 -m json.tool

# Get Reality Gap scores
curl -s -H "X-API-Key: $KAIROS_KEY" \
  https://kairossignal.com/api/v1/reality-gap | python3 -m json.tool

# Check your account & usage
curl -s -H "X-API-Key: $KAIROS_KEY" \
  https://kairossignal.com/api/v1/account | python3 -m json.tool

Rate Limits & Tiers

Response Fields

EXAMPLE RESPONSE{
  "projects": [
    {
      "slug": "helium",
      "name": "Helium",
      "category": "wireless",
      "price_usd": 8.42,
      "market_cap": 1420000000,
      "active_nodes": 375420,
      "total_nodes": 982000,
      "health_score": 82.4,
      "reality_gap": 0.12,
      "uptime_pct": 94.7,
      "earnings_per_node": 0.18
    },
    ...
  ],
  "count": 352,
  "updated_at": "2026-02-15T10:20:00Z"
}

Returns everything from the list endpoint plus deep network stats, enrichment data, AI intelligence, and grade assessments.

Query Parameters

A score of 0.0 = perfect alignment. Scores above 0.3 indicate significant divergence — the network's on-chain metrics don't match physical sensor verification.

EXAMPLE RESPONSE{
  "reality_gap": [
    {
      "project": "helium",
      "gap_score": 0.12,
      "on_chain_nodes": 982000,
      "verified_active": 375420,
      "confidence": 0.94,
      "last_verified": "2026-02-15T10:00:00Z"
    },
    ...
  ]
}

Regimes: trending_bull, trending_bear, mean_reverting, high_volatility, low_volatility, chaotic

Data Schema

KAIROS runs on ClickHouse with 48 tables. Below are the tables available to API subscribers. Analyst+ tiers get direct Snowflake access to query these schemas directly.

Delivery Options

Snowflake Marketplace

Analyst and Enterprise tier subscribers receive access to a private Snowflake listing. You can query all KAIROS tables directly with standard SQL — no API rate limits, no pagination.

SNOWFLAKE SQL-- All DePIN projects ranked by Reality Gap divergence
SELECT
    project_name,
    category,
    health_score,
    reality_gap,
    active_nodes,
    earnings_per_node
FROM kairos.depin_health_profiles
WHERE timestamp > DATEADD(hour, -1, CURRENT_TIMESTAMP())
ORDER BY reality_gap DESC
LIMIT 20;

-- Cross-correlations between crypto and physical sensors
SELECT
    crypto_symbol,
    sensor_category,
    correlation_24h,
    p_value,
    signal_strength
FROM kairos.cross_correlations
WHERE ABS(correlation_24h) > 0.5
  AND p_value < 0.05
ORDER BY ABS(correlation_24h) DESC;

Webhooks (Coming Soon)

Configure webhook endpoints to receive push notifications for Reality Gap™ alerts, regime changes, and whale movements. Available Q2 2026.