Verified official statistics, one API.

Two calls

# 1. The latest US unemployment rate, with provenance on every value (no key needed):
curl "https://starwell.dev/api/starwell/v1/sources/fred/series/UNRATE/observations?latest=3"

# 2. A computed, cited answer (free key, create one at /account):
curl -X POST "https://starwell.dev/api/starwell/v1/answer" \
  -H "Authorization: Bearer dlk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"question": "What was the average US unemployment rate in 2024?"}'

Base URL: https://starwell.dev/api/starwell/v1. All responses use { success, data, meta } envelopes. Dates are ISO YYYY-MM-DD. Machine-readable spec: OpenAPI 3.1.

Press a button, see the live API

These run against the live store from your browser, no key needed. The equivalent curl appears with each response. The sample analysis runs the real answers engine, so allow 10 to 40 seconds on the day's first run.

Open data reads, free keys for answers

Data reads need no key: 120 requests per minute per IP across sources, catalog, series, observations, stats, and CSV. Answers and monitors need an API key. Keys are free, no card: sign in at /account, create a key (shown once, stored hashed), and track your usage there. A keyless sample answer lives at GET /v1/answer/demo.

Send the key as Authorization: Bearer dlk_live_... or X-API-Key. Keys raise your limits to the daily quotas below.

Read the store

Terms: a source is an agency, a dataset is one of its published tables, a series is one indicator over time, and an observation is one value. Public pages call observations "data points".

GET/v1/sources

The sources served, with counts, cadence notes, and terms links.

GET/v1/catalog

The whole catalog flat, in one call: every served series with its indicator, unit, frequency, geography, coverage, verification status, license, and dataset context. Parameters: q (ranked search across series ids, indicators, geographies, and dataset titles, e.g. ?q=unemployment+canada), source (restrict to one slug), limit (1..1000; defaults to 50 with q, else all), offset. meta carries count, total, offset, and hasMore. A human-browsable view lives at /catalog.

GET/v1/sources/:source/datasets

Datasets (official releases and tables) in one source, with coverage and links to the official table pages. Parameters: q (ranked search over this source's ids and titles), limit (1..50000; defaults to 50 with q, else all), offset. Same meta block as the catalog.

GET/v1/sources/:source/datasets/:datasetId

One dataset plus its series, each with its verification status. The envelope carries the citation block. A wide dataset holds thousands of series, so data.series takes limit (1..10000) and offset, and meta.series carries the counts for that list.

GET/v1/sources/:source/series/:seriesId

Full series metadata, current verification status, and the most recent golden and freshness check records.

GET/v1/sources/:source/series/:seriesId/observations

The values. Parameters: start, end, latest (1..5000), limit, offset, format (json or csv; the CSV variant is spreadsheet-ready and carries its attribution as leading # comment lines). Series are addressed by the ids practitioners already use: fred/UNRATE, statcan/v41690973.

{
  "success": true,
  "data": [
    {
      "period": "2026-06-01",
      "value": 4.2,
      "status": "normal",
      "revision": 1,
      "provenance": {
        "sourceUrl": "https://api.stlouisfed.org/fred/series/observations?series_id=UNRATE&...&api_key=REDACTED",
        "retrievedAt": "2026-07-04T13:38:34.644+00:00",
        "connectorVersion": "1.0.0"
      }
    }
  ],
  "meta": {
    "series": { "externalId": "UNRATE", "indicator": "Unemployment Rate", "unit": "Percent" },
    "verification": { "status": "passing", "lastVerifiedAt": "2026-07-04T13:41:05..." },
    "citation": {
      "source": "Federal Reserve Economic Data (FRED)",
      "dataset": "Employment Situation",
      "url": "https://fred.stlouisfed.org/release?rid=50"
    }
  }
}

GET/v1/sources/:source/series/:seriesId/stats

Summary statistics computed over the verified store: latest and previous values, all-time min and max, mean, and the change versus the previous period and versus a year ago. The envelope carries verification, license, and citation like every other endpoint.

Pagination and stability

Every list endpoint pages the same way: limit and offset, with meta.hasMore true exactly when rows exist past the page you were served. Page until it is false and you have walked the set once, no duplicates and nothing dropped — that holds for /v1/catalog, /v1/sources/:source/datasets, the series list inside a dataset, and observations. Observations default to limit 1000 (max 5000), and latest=N is the shortcut for "the newest N" without offset math. A cut window is always marked: CSV exports carry a # NOTE: truncated comment. Catalog and dataset paging is served from a 60-second snapshot, so a page taken while a new series lands may shift by a row; observations page straight off the store. v1 is frozen: changes are additive only (new fields, new endpoints); nothing documented here is removed or repurposed.

Embeddable charts

Every served series is also a self-contained SVG chart at https://starwell.dev/sources/:source/:seriesId/chart.svg (the site root, not the API base). Recent values, verification status, and attribution are drawn into the image. The licensing gate applies as on the API: a restricted series returns 451. Responses cache for about an hour. No key, no JavaScript. Each series page shows its embed ready to copy:

<img src="https://starwell.dev/sources/fred/UNRATE/chart.svg"
     alt="US unemployment rate" width="720" />

Every dataset is addressable

The store indexes every dataset its sources publish in their own catalogs (28,000+ across the twelve, from Statistics Canada's ~8,200 cubes and Eurostat's ~6,700 datasets to every SEC filer). The values inside them are fetched and kept as they are asked for.

Search sees the whole index. GET /v1/catalog?q= and the MCP search_catalog tool return served series as always, plus meta.datasetMatches: datasets from the wider index that match your terms, each flagged with how many of its series are already served. GET /v1/sources/:source/datasets?q=&limit= searches one source's index the same way.

A miss can materialize. Some sources are enabled for on-demand serving: Statistics Canada, ECB, World Bank (WDI), INSEE, ABS, Eurostat (EU/EFTA/candidate geographies), and SEC EDGAR. On those, requesting a series the store has never held by its source-native id (/v1/sources/statcan/series/v<vectorId> for any real StatCan vector) fetches it live from the official source, serves it with per-observation provenance, and keeps it for later callers. First calls take a few seconds; if the fetch outlasts the request you get 503 {"code": "materializing"} with a Retry-After. Materialized series start unverified, with no golden values assigned yet. Series that keep getting called are promoted to the daily refresh schedule and backfilled with full history.

When it cannot serve, the code says why: 404 unknown_series, 422 series_unservable, 503 source_unreachable, 451 license_restricted, or 429 materialize_rate_limited. Each is spelled out under Errors.

POST /v1/answer resolves questions against served series; a series you have just materialized is immediately pinnable via series and joins plain-language resolution within a minute.

POST/v1/answer

Ask a question in plain language. The engine matches it to served series (or pin them with series), pulls the verified observations, writes and runs real Python in a sandbox, and returns the computed result. No number is model-estimated. Requires a free API key (401 key_required without one). The keyless sample is GET /v1/answer/demo.

The same engine drives the chat in your browser: multi-turn questions, charts, and the Python behind every answer.

curl -X POST "https://starwell.dev/api/starwell/v1/answer" \
  -H "Authorization: Bearer dlk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "question": "What was the average US unemployment rate in 2024?",
    "series": [{ "source": "fred", "seriesId": "UNRATE" }],
    "start": "2024-01-01", "end": "2024-12-01"
  }'

{
  "success": true,
  "data": {
    "answer": "The average US unemployment rate in 2024 was 4.03%.",
    "chart": { "...": "Plotly figure JSON" },
    "python": "import pandas as pd\ndf = pd.DataFrame(data)\n...",
    "series": [{
      "source": "fred", "seriesId": "UNRATE",
      "verification": { "status": "passing", "lastVerifiedAt": "..." },
      "citation": { "dataset": "Employment Situation", "url": "https://fred.stlouisfed.org/release?rid=50" }
    }]
  },
  "meta": {
    "observationsUsed": 12, "cached": false, "durationMs": 12085,
    "coverage": [
      { "seriesId": "UNRATE", "from": "2024-01-01",
        "to": "2024-12-01", "points": 12, "truncated": false }
    ]
  }
}

Expect 10 to 40 seconds on a cache miss. Repeats come back from the answers cache in milliseconds, and the cache clears when the underlying official data moves. When no served series can answer the question, the API returns 422.

Further meta fields, each present only when it applies:

Deep analysis: "mode": "deep"

Add "mode": "deep" to the same request and the engine plans 3 to 4 separate analyses for your question (trend, distribution, outliers and turning points, cross-series relationships), runs Python for each in the sandbox, and writes them up as one report. The response adds data.sections[]: each section carries its own computed output (stdout), its python, and its charts. Works with up to 4 pinned series, for comparisons like "US vs Canada inflation since 2020". Expect 60 to 180 seconds on a cache miss; deep reports cache separately from default answers. Free keys include 5 deep reports a day (deep_limit past that; default answers keep their own quota). Also exposed to agents as the deep_analysis MCP tool.

POST/v1/monitors

Watch a series; get a webhook the moment it moves. Body: {"source": "fred", "seriesId": "DGS10", "webhookUrl": "https://..."}. Requires an API key (keys are free). Detection rides the store's own refresh loop: when a refresh lands a new period or a revised value, Starwell POSTs a series.updated event with the new value, the previous period, the verification status, and the citation. Delivery is https-only, one attempt per refresh; the monitor's snapshot only advances on successful delivery, so a missed delivery re-fires on the next refresh. Manage with GET /v1/monitors and DELETE /v1/monitors/:id (scoped to your key). Monitors per key: 5 free, 100 pro.

{
  "event": "series.updated",
  "source": "fred",
  "seriesId": "DGS10",
  "indicator": "Market Yield on U.S. Treasury Securities at 10-Year Constant Maturity",
  "period": "2026-07-10", "value": 4.21, "previousPeriod": "2026-07-09",
  "verification": "passing",
  "citation": { "dataset": "H.15 Selected Interest Rates", "url": "https://fred.stlouisfed.org/release?rid=53" }
}

Verify deliveries

Every delivery is signed. The create response returns a webhookSecret (shown once; re-creating the same monitor rotates it), and each POST carries X-Starwell-Signature: sha256=<hex>, the HMAC-SHA256 of the raw request body. Verify it before trusting the payload:

import crypto from "node:crypto";

const expected = "sha256=" + crypto.createHmac("sha256", process.env.STARWELL_WEBHOOK_SECRET)
  .update(rawBody) // the exact request body bytes, before any JSON parsing
  .digest("hex");
const authentic = crypto.timingSafeEqual(Buffer.from(signatureHeader), Buffer.from(expected));

Verification statuses

The answer sandbox

/v1/answer writes Python and runs it. Every run gets its own microVM (Firecracker, via E2B), so the isolation is at the hypervisor layer.

Ephemeral: a fresh sandbox per request, destroyed when the request ends, so no workspace, temporary file, or interpreter variable is reused between callers. Credential-free: the runner environment holds no database URL, no source API keys, and no model keys, so there is nothing in it to take. Fail closed: if the sandbox is unreachable, the answer fails with an error rather than running anywhere else. The code also has nothing private to compute over: the observations it sees are the same public official statistics this API already serves, fetched beforehand and handed in as data.

A gate runs against the live sandbox before any cutover and attempts each forbidden action, failing if one succeeds: reading credentials from the environment, reaching the cloud metadata endpoint, resolving a hostname, opening an outbound connection, running an infinite loop, allocating unbounded memory, and reading another run's files or variables.

Where we are not finished. Name resolution and the cloud metadata endpoint are blocked, and we verify both. Blanket outbound egress blocking is not switched on yet, so that gate does not pass today and we are not claiming it. It is the next thing we are closing. We would rather say that here than let you assume it.

What we do not claim: no sandbox is unbreakable. What we can say is that an escape would land in a machine with no credentials in it, holding only public data, that exists for the duration of one request.

Errors

Every error is the same shape: { "success": false, "error": "human-readable message", "code": "machine_code" }, where code appears when there is a branchable condition. Agents: branch on the status and code, show error to humans.

Every keyed response carries X-RateLimit-Limit, X-RateLimit-Used, X-RateLimit-Remaining, and X-RateLimit-Reset, all CORS-exposed, so browser agents can read them and pace themselves.

MCP server

The same capabilities as native tools for any MCP client, served over Streamable HTTP with no session state:

https://starwell.dev/api/starwell/mcp

Tools: search_catalog, list_sources, list_datasets, get_series, get_series_stats, get_observations, answer, deep_analysis, and monitor management (create_monitor, list_monitors, delete_monitor). Data reads work keyless; answer, deep_analysis, and the monitor tools need a free key from /account. Remote clients pass it as an Authorization: Bearer header; the stdio bridge reads STARWELL_API_KEY.

Connect your client

Claude Code

claude mcp add --transport http starwell https://starwell.dev/api/starwell/mcp

Claude Desktop / claude.ai: Settings → Connectors → Add custom connector with the URL above. On plans without remote connectors, use the stdio bridge in the desktop config:

{
  "mcpServers": {
    "starwell": { "command": "npx", "args": ["-y", "starwell-mcp"] }
  }
}

Cursor (remote, nothing to install), in .cursor/mcp.json:

{
  "mcpServers": {
    "starwell": { "url": "https://starwell.dev/api/starwell/mcp" }
  }
}

VS Code (Copilot agent mode), in .vscode/mcp.json:

{
  "servers": {
    "starwell": { "type": "http", "url": "https://starwell.dev/api/starwell/mcp" }
  }
}

OpenAI Codex CLI, in ~/.codex/config.toml:

[mcp_servers.starwell]
command = "npx"
args = ["-y", "starwell-mcp"]

Gemini CLI, in ~/.gemini/settings.json:

{
  "mcpServers": {
    "starwell": { "httpUrl": "https://starwell.dev/api/starwell/mcp" }
  }
}

ChatGPT: Settings → Apps → enable developer mode, add a connector with the remote URL. LangChain / agent frameworks: point any MCP adapter (e.g. langchain-mcp-adapters) at the same URL; the tool surface loads dynamically, so new sources and tools appear without code changes.

JSON for every data page

Every public data page carries a rel="alternate" link to its API equivalent, and requesting it with Accept: application/json (or ?format=json) redirects straight to the data: /catalog to /api/starwell/v1/catalog, a source page to its datasets endpoint, a series page to its observations. Series pages also publish schema.org Dataset markup with CSV and JSON distributions.

The full pattern is at /agent-native. Machine entry points: /llms.txt (site map for LLMs), /llms-full.txt (this documentation as one markdown file), /openapi.json, /changelog.xml. Agents use the same rate limits and keys as everyone else, and only public data is served this way.

Copy and paste

Python and pandas

The CSV endpoint reads straight into a DataFrame; the # attribution lines are skipped with comment.

import pandas as pd

df = pd.read_csv(
    "https://starwell.dev/api/starwell/v1/sources/fred/series/UNRATE/observations?format=csv",
    comment="#", parse_dates=["period"],
)
print(df.tail())

JavaScript

const r = await fetch(
  "https://starwell.dev/api/starwell/v1/sources/fred/series/UNRATE/stats"
);
const { data, meta } = await r.json();
console.log(data.latest, meta.citation.text);

Google Sheets

One formula, re-fetched every time the sheet opens:

=IMPORTDATA("https://starwell.dev/api/starwell/v1/sources/fred/series/UNRATE/observations?format=csv&latest=120")

Sources and attribution

Every API response carries the series' license code, license URL, and attribution text; the per-source view is the live catalog. A series whose license does not permit redistribution is excluded from the catalog and from /answer, and direct requests for it return 451 Unavailable For Legal Reasons with the license context instead of data.

Values are served as published by the source (current vintage). Revisions are tracked append-only.

Questions, keys, pilots: create an account or write to hello@starwell.dev.