Overview

Factor Weave is a quantitative-finance data API exposing factor scores, similarity search across ~12,000 tickers, forward-return labels, and a regime-aware market context. Two access surfaces are available:

• REST API at https://factorweave.com/api — JSON over HTTPS, suitable for any HTTP client.
• MCP Server at https://factorweave.com/api/mcp — stateless JSON-RPC 2.0, plug directly into Claude Desktop, Cursor, or any MCP-aware agent.

All bulk computation happens off-line nightly; request-time work is just a typed file or DB read, so latency is consistently sub-50 ms even on shared hosting.

What's in the box

Where to next

• → Getting Started — register, mint a key, your first request
• → REST API Reference — every endpoint with examples
• → MCP Guide — connect Claude / Cursor / agents
• → Vector Methods — cosine vs label_aware vs supervised vs DTW
• → Tiers & Limits — what each plan unlocks

Stuck? Email support@factorweave.com.

Getting Started

Three steps: create an account, get a credential, make your first call.

1 — Sign up

Registration is currently invite-gated. Use the Sign Up form with the invite code you were sent. Once you have an account, sign in via Login. You're already signed in — skip ahead.

2 — Get a credential

Two equivalent options:

curl -X POST https://factorweave.com/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"you@example.com","password":"…"}'

# → {"access_token":"eyJ…","subscription_tier":"PRO",…}

# All endpoints accept either header form:
Authorization: Bearer fw_live_…
X-API-Key:     fw_live_…

3 — First request

curl -H "X-API-Key: fw_live_…" \
  https://factorweave.com/api/features/AAPL

# Python with requests
import requests
r = requests.get(
    "https://factorweave.com/api/features/AAPL",
    headers={"X-API-Key": "fw_live_…"},
)
print(r.json())

Cookbook

Copy-paste workflows for the things people actually do with Factor Weave. A framing note worth stating plainly: this is a research substrate — clean, point-in-time, leak-free factor data and similarity tooling. It is not a return-prediction service, and none of these recipes claim to be. They assemble data; the thesis is yours.

1 · Pull a ticker's current factor state

The latest-day row — ~28 factor columns: returns, realized vol, RSI, momentum, beta, composite score, cross-sectional ranks.

curl -H "X-API-Key: fw_live_…" \
  https://factorweave.com/api/features/AAPL

# Python
import requests
H = {"X-API-Key": "fw_live_…"}
row = requests.get("https://factorweave.com/api/features/AAPL", headers=H).json()[0]
print(row["rsi"], row["mom"], row["comp_score"], row["q_comp_score"])

2 · Screen the universe by a factor

Top-N tickers ranked by any factor on the latest day — a starting watchlist, not a buy list.

# strongest momentum names today
curl -H "X-API-Key: fw_live_…" \
  "https://factorweave.com/api/top?factor=mom&n=25"

# Python — momentum names that aren't already overbought
import requests
H = {"X-API-Key": "fw_live_…"}
rows = requests.get("https://factorweave.com/api/top",
                    params={"factor": "mom", "n": 100}, headers=H).json()["rows"]
candidates = [r for r in rows if r["rsi"] < 70]
print(len(candidates), "momentum names with RSI < 70")

3 · Find factor-similar tickers

"What else looks like this?" — useful for building peer sets, diversifying a thesis, or finding substitutes. min_lookback_days=30 keeps it to genuine historical analogues rather than today's co-moving ETFs.

curl -H "X-API-Key: fw_live_…" \
  "https://factorweave.com/api/vector-search/similar/AAPL?method=cosine&limit=10&min_lookback_days=30"

# each neighbour carries its factor row + forward-return labels, pre-joined
import requests
H = {"X-API-Key": "fw_live_…"}
r = requests.get("https://factorweave.com/api/vector-search/similar/AAPL",
                 params={"method": "cosine", "limit": 10, "min_lookback_days": 30},
                 headers=H).json()
for n in r["neighbors"]:
    print(n["ticker"], n["date"], "rsi", n["features"]["rsi"])

Note: similarity finds setups that look alike on factor profile. Our own leak-free testing shows it does not forecast forward returns — treat it as a screening lens, not a signal. See the research note.

4 · Assemble a leak-free backtest dataset

Join point-in-time features to forward-return labels. The labels are constructed leak-free (price[t+h]/price[t]−1); the model is yours to build.

import requests, pandas as pd
H = {"X-API-Key": "fw_live_…"}
B = "https://factorweave.com/api"

# point-in-time features for a ticker over a date range
feats  = requests.get(f"{B}/features/AAPL",
                      params={"start_date": "2024-01-01", "end_date": "2024-12-31"},
                      headers=H).json()["rows"]
# matching forward-return labels (PRO tier+)
labels = requests.get(f"{B}/labels/AAPL",
                      params={"start_date": "2024-01-01", "end_date": "2024-12-31"},
                      headers=H).json()["labels"]

X = pd.DataFrame(feats).set_index("date")
y = pd.DataFrame(labels).set_index("date")["fwd_ret_20d"]
df = X.join(y).dropna()
# df is now a clean, leak-free (features → realised forward return) frame.
# Train / cross-validate your own model on it.

5 · Condition research on the market regime

Factor behaviour differs by volatility regime. Pull the current SPY-vol regime and split any study by it.

curl -H "X-API-Key: fw_live_…" \
  "https://factorweave.com/api/top?factor=comp_score&n=10"

# via MCP, conversationally (Claude / Cursor):
#   "What volatility regime is the market in, and show me the
#    top momentum names — then tell me how crowded that factor looks."

6 · Read the derived analytics

Whole-universe and per-ticker derivations — a market-state read, a per-ticker digest, the risk cluster, the raw embedding. Tier-gated (see Tiers).

# market state — factor dispersion, breadth, regime odds  (FREE = today)
curl -H "X-API-Key: fw_live_…" https://factorweave.com/api/market-context?latest=1

# per-ticker digest — ranks, risk cluster, regime, unusualness  (HOBBY+)
curl -H "X-API-Key: fw_live_…" https://factorweave.com/api/report-card/AAPL

# risk cluster — calm / normal / stressed  (PRO+)
curl -H "X-API-Key: fw_live_…" https://factorweave.com/api/risk-cluster/AAPL

# raw 32-D factor-state embedding — build your own models  (QUANT)
curl -H "X-API-Key: fw_live_…" https://factorweave.com/api/embedding/AAPL

All four are also MCP tools — get_market_context, get_report_card, get_risk_cluster, get_embedding.

7 · Use the Python SDK instead of raw HTTP

Typed, autocompleting client — handles auth, retries on 429, paginates the universe endpoint. Same endpoints as the REST docs, just cleaner.

pip install factorweave

from factorweave import FactorWeave
fw = FactorWeave(api_key="fw_live_…")   # or env: FACTORWEAVE_API_KEY

# point-in-time factors
row = fw.features("AAPL").latest()
print(row.rsi, row.mom, row.comp_score)

# similarity search
hits = fw.similar("AAPL", method="cosine", limit=10, min_lookback_days=30)
for h in hits:
    print(h.ticker, h.date, h.distance)

# market-context + report card
print(fw.market_context().regime)
print(fw.report_card("AAPL").risk_cluster)

Source: factorweave-tools/python · PyPI: pypi.org/project/factorweave.

7b · The fw CLI shipped with the Python package

The same pip install factorweave installs an fw command — friendly tables by default, --json for pipes. Useful for shell pipelines, cron jobs, or just kicking the tires from a terminal.

export FACTORWEAVE_API_KEY=fw_live_…

fw features AAPL
fw top mom -n 25
fw similar AAPL --method cosine --limit 10
fw market-context
fw report-card NVDA
fw embedding TSLA --json | jq '.vector | length'

fw --help

7c · TypeScript / Node from a Next.js or Vercel function

Same shape as the Python SDK. Native fetch, ESM + CJS, full types, retry on 429 + 5xx. Server-side only — don't ship your fw_live_… key to the browser.

npm install @blazing-customs/factorweave

import { FactorWeave } from '@blazing-customs/factorweave';

const fw = new FactorWeave({ apiKey: process.env.FACTORWEAVE_API_KEY });

const row  = await fw.latestFeatures('AAPL');
const top  = await fw.top({ factor: 'mom', n: 25 });
const hits = await fw.similar('AAPL', { method: 'cosine', limit: 10 });
const card = await fw.reportCard('AAPL');     // HOBBY+

Source: factorweave-tools/typescript · npm: @blazing-customs/factorweave.

7d · R from RStudio

Returns idiomatic data.frames. httr2-based with automatic retry on 429/5xx, tier-aware errors.

install.packages("factorweave",
                 repos = c("https://blazing-customs.r-universe.dev",
                           "https://cloud.r-project.org"))

library(factorweave)
client <- fw_client(api_key = "fw_live_…")

row  <- fw_latest_features(client, "AAPL")
hist <- fw_features(client, "AAPL", start = "2024-01-01", end = "2024-12-31")
top  <- fw_top(client, "mom", n = 25)
hits <- fw_similar(client, "AAPL", method = "cosine", limit = 10)

Source: factorweave-tools/r.

7e · Other languages: auto-generated clients

Go, Rust, Ruby, PHP, and Dart clients are committed under generated/ on the umbrella repo. Java / C# / Kotlin / Swift live one shell command away.

# vendor a client into your project
git clone --depth 1 https://github.com/Blazing-Customs/factorweave-tools.git
cp -r factorweave-tools/generated/go    ./internal/factorweave    # Go
cp -r factorweave-tools/generated/rust  ./crates/factorweave      # Rust

# generate Java / C# / Kotlin / Swift on demand:
bash scripts/regenerate_clients.sh java csharp kotlin swift

8 · Pull factors straight into Google Sheets

A Google Apps Script add-on exposes Factor Weave as spreadsheet custom functions — type a formula, get a live factor. Paste your API key once in Script Properties.

# one factor, one cell
=FACTORWEAVE("AAPL", "rsi")

# many factors at once → spills across columns
=FACTORWEAVE("AAPL", "rsi,mom,vol_real,comp_score")

# top-N screen → spills down a column
=FACTORWEAVE_TOP("mom", 25)

# market regime in one cell
=FACTORWEAVE_REGIME()

Setup guide + Code.gs: sdk/sheets.

9 · Get factor alerts in Slack / Discord / Zapier

Create an alert rule on the Alerts page with a delivery URL. The nightly evaluator posts JSON to that URL whenever the rule fires — Slack/Discord incoming-webhooks accept it directly, Zapier and n8n consume the same payload.

# sample delivery payload
{
  "rule_id": 17,
  "name": "AAPL momentum strong",
  "ticker": "AAPL",
  "factor": "mom",
  "value": 1.83,
  "threshold": 1.5,
  "operator": ">",
  "fired_at": "2026-05-22T22:05:14Z"
}

# create rule via API
curl -X POST https://factorweave.com/api/alert-rules \
  -H "X-API-Key: fw_live_…" \
  -H "Content-Type: application/json" \
  -d '{"ticker":"AAPL","factor":"mom","op":">","threshold":1.5,
       "delivery_url":"https://hooks.slack.com/services/T.../B.../..."}'

Browser-push delivery (no webhook URL needed) is also wired up — see Integrations → PWA + push.

More

• → MCP Server — wire this into Claude/Cursor for conversational research
• → REST API Reference — every endpoint + parameters
• → Research note — what the data does and does not do, measured

Integrations

• → OpenAPI 3.0 spec · Swagger UI — for LangChain / OpenAI tool-use / ChatGPT Actions / autogen SDKs
• → Python SDK — pip install factorweave
• → Google Sheets add-on — =FACTORWEAVE("AAPL","rsi")
• → Alert webhooks — Slack/Discord/Zapier/n8n delivery

REST API Reference

Base URL: https://factorweave.com/api. All authed endpoints accept either Authorization: Bearer <jwt-or-api-key> or X-API-Key: fw_live_….

A machine-readable summary is also available at /api/docs.

Example responses

GET /api/features/AAPL

[{
  "ticker":"AAPL","instrument_type":"stock","date":"2026-05-01",
  "open":278.86,"close":280.14,"volume":79915442,
  "ret_1d":0.0324,"ret_5d":0.0335,"ret_20d":0.0946,
  "rsi":69.31,"mom":0.0946,"meanrev":0.0067,
  "z_52w":1.31,"beta_spy":0.97,"comp_score":-0.18,
  "rank_mom":7844,"q_mom":71,"rank_comp_score":1232,"q_comp_score":11
}]

GET /api/features/AAPL?date=2025-09-15 (historical row at a specific date — for analogue-backtests, eliminates look-ahead bias)

{
  "ticker":"AAPL","count":1,"first_date":"2025-04-02","last_date":"2026-05-01",
  "filters":{"date":"2025-09-15","start_date":"2025-09-15","end_date":"2025-09-15"},
  "rows":[{"date":"2025-09-15","close":231.45,"rsi":56.2,"mom":0.034,…}]
}

GET /api/vector-search/similar/AAPL?method=supervised&limit=2 (each neighbor carries pre-joined features + forward-return labels)

{
  "query_ticker":"AAPL","query_date":"2026-05-01","method":"supervised",
  "neighbors":[
    {
      "ticker":"ACGL","date":"2017-01-10","rank":1,"score":1.0000,
      "features":{"close":28.77,"rsi":44.23,"mom":0.0014,"comp_score":0.136,"beta_spy":0.46,…},
      "labels":  {"fwd_ret_1d":0.0006,"fwd_ret_5d":0.0204,"fwd_ret_20d":0.0660,"target_5d_up3":0,"target_20d_up10":0}
    },
    {
      "ticker":"WNTR","date":"2025-09-05","rank":2,"score":0.9754,
      "features":{…},"labels":{…}
    }
  ]
}

POST /api/me/keys → fw_live_… (shown ONCE)

{
  "key":"fw_live_AbCd…",
  "prefix":"fw_live_AbCd",
  "expires_at":"2027-05-03T07:00:00+00:00",
  "warning":"This is the only time the full key will be shown. Save it securely."
}

Error shape

HTTP 401  { "detail": "Token invalid or expired" }
HTTP 403  { "detail": "method 'supervised' requires a higher tier" }
HTTP 404  { "detail": "no neighbors for FAKE" }
HTTP 429  { "detail": "Daily quota exceeded", "tier": "FREE", "used": 250, "limit": 250 }

MCP Server

The Model Context Protocol (MCP) endpoint lets agents like Claude Desktop, Cursor, or any MCP-aware client use Factor Weave directly as a set of tools. The transport is stateless streamable HTTP — every POST is one self-contained JSON-RPC 2.0 request, no session, no SSE.

Endpoint

POST https://factorweave.com/api/mcp
Content-Type: application/json
Authorization: Bearer fw_live_…       (or X-API-Key)
Accept: application/json
Protocol version: 2025-03-26

initialize, tools/list, ping, and the public get_manifest tool work without auth. Every other tool requires a credential.

Tool catalog

Wire format

Discover tools:

curl -X POST https://factorweave.com/api/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Call find_similar:

curl -X POST https://factorweave.com/api/mcp \
  -H "Authorization: Bearer fw_live_…" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc":"2.0","id":1,"method":"tools/call",
    "params":{
      "name":"find_similar",
      "arguments":{"ticker":"AAPL","method":"supervised","limit":5,"min_lookback_days":30}
    }
  }'

Claude Desktop / Cursor config

Drop into ~/Library/Application Support/Claude/claude_desktop_config.json (or the equivalent on your platform):

{
  "mcpServers": {
    "factorweave": {
      "url": "https://factorweave.com/api/mcp",
      "transport": "streamable-http",
      "headers": {
        "Authorization": "Bearer fw_live_…"
      }
    }
  }
}

Some clients only support a stdio bridge; in that case use @modelcontextprotocol/inspector or any HTTP→stdio shim, pointing it at the URL above.

Python SDK

from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async with streamablehttp_client(
    "https://factorweave.com/api/mcp",
    headers={"Authorization": "Bearer fw_live_…"},
) as (read, write, _):
    async with ClientSession(read, write) as s:
        await s.initialize()
        tools = await s.list_tools()
        result = await s.call_tool(
            "find_similar",
            {"ticker": "AAPL", "method": "dtw", "limit": 5},
        )

Vector Similarity Methods

Each ticker × date is embedded as a 32-dimensional regime-aware vector. The four similarity methods differ in which subset of the backbook is searched and what distance is used to rank it.

cosine — all tiers

Cosine similarity over the full 32-D embedding against every (ticker, date) in the backbook.

• Score range: -1 to 1 (higher = more similar)
• Use when: you want maximum recall and don't care about regime / time-shape
• Caveat: top hits will often be same-day correlated tickers (ETFs of the underlying). Use min_lookback_days=30 to filter.

label_aware — PRO+

Cosine similarity, but the backbook is restricted to dates that share the query's SPY-volatility regime (low / mid / high).

• Score range: -1 to 1
• Use when: you want lookalikes from comparable market conditions
• Caveat: if today's regime is the dominant one in history, results will overlap with plain cosine

supervised — QUANT

Embeddings are projected through a PLS regression fit on forward-return labels, then ranked by cosine — a return-weighted view of similarity.

• Score range: -1 to 1 (in PLS-projected space)
• Use when: you want a return-weighted similarity lens rather than plain factor-profile similarity
• Caveat: it is not a return forecast — our leak-free testing shows factor similarity does not predict returns (research note). It's an alternative projection, not an oracle.

dtw — PRO+

Cosine top-200 shortlist, then re-ranked by Dynamic Time Warping distance over the rolling return window with a Sakoe-Chiba band.

• Score range: negative DTW distance (higher / closer to zero = more similar)
• Use when: you care about shape over time, even with phase shifts (e.g. "find tickers tracing the same arc, possibly lagged a week")
• Caveat: the shortlist is only top 50 per query — narrower than cosine — so recall is lower by design

When to use which

Derived Analytics

Four products computed over the whole universe — things you can't reconstruct from the handful of tickers you hold, because they need the entire cross-section. All are pure derivations: no raw market data. Use them interactively in the Analytics tab.

Market Context — FREE (today) · HOBBY+ (252-day history)

GET /api/market-context — a daily, whole-universe read of market state. Three groups of metrics:

• Factor dispersion — the 10th-to-90th percentile spread of momentum / composite score / RSI across every ticker. Wide = the cross-section is spreading out (more relative opportunity, often more stress); narrow = names moving together. disp_momentum_pctile says where today's dispersion sits vs its own trailing year (1.0 = widest in a year). It's a percentile spread, not a standard deviation, so a few penny-stock blow-ups can't distort it.
• Breadth — the fraction of the universe with positive momentum, a positive trailing 20-day return, overbought (RSI>70) or oversold (RSI<30). Breadth below 0.5 means more than half the market is negative.
• Regime — the current SPY-volatility regime (low / mid / high), how many trading days it has held, and regime_next_odds — the empirical P(next trading day's regime | current), counted over full history.

How to read it: rising dispersion + falling breadth is the classic "market getting choppy" signature; the regime odds quantify how sticky the current regime has been.

Factor Report Card — HOBBY+

GET /api/report-card/{ticker} — a per-ticker digest assembled from the rest of the dataset. Five parts:

• Snapshot — the ticker's current factor values (return, momentum, RSI, realized vol, beta, …).
• Percentile ranks — where it sits cross-sectionally today (e.g. q_comp_score = 87 → 87th percentile of the universe on composite score).
• Risk cluster — the analogue-derived volatility regime (see below). PRO+; HOBBY sees it locked.
• Market regime — the current SPY-volatility regime, for context.
• Unusualness — a z-score of today's factor values against the ticker's own 252-day history. score is the largest absolute z across factors; verdict is typical (<1.5), somewhat unusual (1.5–2.5) or very unusual (≥2.5). It answers "is this ticker in a normal state for itself, or an outlier?"

Risk Cluster — PRO+

GET /api/risk-cluster/{ticker} — the volatility regime a ticker's factor analogues historically landed in.

• How it works: take the ticker's cosine analogues, look at each analogue's realized forward 20-day volatility, average it (expected_fwd_vol), and rank cross-sectionally into a tercile — calm / normal / stressed.
• How to read: vol_percentile places it 0–1 across the universe; n_analogues is how many historical analogues backed the tag.
• What it is — and isn't: our leak-free probe found factor similarity clusters forward volatility at a real, significant level (cross-sectional IC +0.062, t +8.3 — see the research note). It's a risk-coherence / screening signal, not a volatility forecast for the stock — a ticker's own trailing vol predicts that far better.

Embedding Vectors — QUANT

GET /api/embedding/{ticker} — the raw 32-dimensional regime-aware factor-state vector for a ticker.

• What it is: the exact representation the similarity search itself runs on — each ticker-day compressed to 32 floats.
• Use when: you want to build your own models, similarity metrics or clustering on the representation rather than consuming our precomputed neighbors.
• Caveat: it's a learned representation, not a signal — distance in this space is factor-profile similarity, which (per the research note) does not forecast returns.

When to use which

SDKs & Integrations

Six ways to use Factor Weave — pick the one that matches your workflow. All hit the same API, share the same daily quota, and read the same nightly-fresh data. See the dedicated marketing page for a shareable overview.

🐍 Python SDK — pip install factorweave

Typed client over every endpoint, with optional pandas / polars adapters and tier-aware error classes. Auth via API key (preferred for scripts) or JWT.

import factorweave as fw

client = fw.Client(api_key="fw_live_…")
row    = client.features("AAPL")[0]
hist   = client.features("AAPL", start="2024-01-01", end="2024-12-31").to_polars()
top    = client.top("mom", n=25).to_pandas()
nbrs   = client.find_similar("NVDA", method="cosine", min_lookback_days=30)
client.report_card("AAPL")     # HOBBY+
client.risk_cluster("TSLA")    # PRO+
client.embedding("AAPL")       # QUANT

Source: github.com/Blazing-Customs/factorweave-tools/python · PyPI

🤖 MCP Server — 12 tools · HOBBY+

Stateless streamable-HTTP MCP. 12 typed tools: factor lookups, similarity search, top-N, market context, report card, risk cluster, embeddings, labels, alerts, usage, regime, manifest.

// claude_desktop_config.json
{
  "mcpServers": {
    "factorweave": {
      "url": "https://factorweave.com/api/mcp",
      "transport": "streamable-http",
      "headers": { "Authorization": "Bearer fw_live_…" }
    }
  }
}

→ Full protocol on the MCP Server docs page · marketing /mcp.html

📜 OpenAPI 3.0 spec

Typed schema for every endpoint. Drop the URL into anything that consumes OpenAPI — LangChain OpenAPIToolkit, LlamaIndex, OpenAI Function Calling, Anthropic tool use, ChatGPT Actions, autogenerated SDKs.

# LangChain
from langchain_community.agent_toolkits.openapi.toolkit import OpenAPIToolkit
from langchain_community.tools.openapi.utils.openapi_utils import OpenAPISpec
spec = OpenAPISpec.from_url("https://factorweave.com/api/openapi.json")

# ChatGPT Actions: paste the URL into the Action's "Import from URL" field.

Raw spec: /api/openapi.json · Clickable explorer: /api/docs/swagger

📊 Google Sheets add-on

Apps Script project — paste once, then use custom functions in any cell. Per-user API key stored via PropertiesService (not shared with the sheet).

=FACTORWEAVE("AAPL", "rsi")        → 83.5
=FW_TOP("mom", 25)                 → 25 rows of top-momentum tickers
=FW_MARKET_CONTEXT()               → today's regime / dispersion / breadth
=FW_REPORT_CARD("AAPL")            → full per-ticker digest  (HOBBY+)

Install: paste sdk/sheets/Code.gs into Extensions → Apps Script. Then Factor Weave → Set API key… from the new menu.

📡 Webhook alert delivery — Slack · Discord · Zapier · Make · n8n

Create an alert rule, attach a delivery_url; once a UTC day after the nightly bundle, Factor Weave POSTs a JSON digest of every matching ticker to that URL.

POST https://hooks.slack.com/services/…
Content-Type: application/json

{
  "source": "factorweave",
  "rule":   { "id": "...", "name": "RSI overbought", "indicator": "rsi",
              "condition": ">", "value": 70 },
  "as_of":  "2026-05-22",
  "count":  374,
  "matches": [{ "ticker": "NVDA", "value": 88.3 }, …]
}

Configure rules in the Alerts tab. One POST per rule per day (capped at 100 matches; truncated: true if more).

🔔 PWA + Web Push — HOBBY+

Install Factor Weave as an app on iOS / Android / desktop (the browser's "Add to home screen" / "Install" affordance); opt in to native browser notifications when an alert rule fires. Push arrives even when the tab is closed.

Toggle both from Alerts → App & browser alerts.

Tiers & Limits

All tiers share the same underlying data; what differs is daily quota and which advanced surfaces — vector methods, labels, MCP, and the derived analytics — are unlocked.

Derived analytics by tier

Whole-universe / per-ticker derivations — things you can't compute without the full cross-section.

Quota behaviour

• Quota counter resets at 00:00 UTC.
• Both REST and MCP calls count against the same daily total.
• Exceeding quota returns HTTP 429 with { "detail": "daily quota exceeded for tier …" }.
• An expired paid subscription soft-downgrades to FREE until renewed — no hard cutoff.