API Documentation

Alphanume exposes every dataset through a single, query-parameter–based REST API. This page walks through account setup, authentication, and the request pattern shared by all endpoints.

Create an Account

To access the Alphanume API, create an account at the sign-up page. After registering and setting your password, your API key will be emailed to you automatically.

Base URL

All Alphanume API requests are made against:

https://api.alphanume.com/v1

Example Request

The API follows a simple, query-parameter–based request structure. Below is a sample request to the Historical Market Cap endpoint:

import requests

url = "https://api.alphanume.com/v1/historical-market-cap"
params = {
    "ticker": "AAPL",
    "date": "2026-02-06",
    "api_key": "alp_abc123"
}

response = requests.get(url, params=params)
data = response.json()

print(data)

curl "https://api.alphanume.com/v1/historical-market-cap?ticker=AAPL&date=2026-02-06&api_key=alp_abc123"

Header-Based Auth

You can also pass your API key via the X-API-Key header instead of a query parameter.

curl "https://api.alphanume.com/v1/historical-market-cap?ticker=AAPL&date=2026-02-06" \
  -H "X-API-Key: alp_abc123"

Response Format

Responses are returned in JSON and are designed to be immediately usable in research pipelines.

{
  "count": 1,
  "data": [
    {
      "date": "2026-02-06",
      "ticker": "AAPL",
      "market_cap": 4109599296360.0,
      "shares_outstanding": 14776353000.0
    }
  ]
}

General Pattern

All Alphanume endpoints follow the same structure:

GET /v1/{endpoint}?param1=value&param2=value&api_key=alphanume_api_key

This makes it easy to programmatically construct requests across datasets without learning new schemas.

Rate Limits

• Pro tier: 600 requests per minute
• Exceeding the limit returns HTTP 429

Next Steps

• Explore the available datasets in the sidebar
• Review authentication and API key setup
• Integrate directly into your backtests or production systems

The Next-Day Movers dataset provides a daily, model-ranked collection of equities most likely to experience large price moves in the following trading session.

Each observation contains one of the top names selected from a universe of liquid optionable equities, based on a predictive model designed to identify securities with elevated next-day realized movement potential. Behind the scenes, the model evaluates features such as implied volatility, realized volatility, and related volatility structure information to rank candidates by expected next-day movement.

All observations are stored historically and remain fixed once published, allowing the dataset to be used safely in systematic research and backtesting workflows without lookahead bias.

Why it's useful

• Identify equities most likely to experience outsized next-day moves
• Build directional or non-directional volatility trading strategies
• Screen for high-movement candidates before the next session opens
• Study the relationship between implied volatility, realized volatility, and future movement
• Backtest systematic workflows built around next-day mover selection

Endpoint

GET /v1/next-day-movers

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/next-day-movers"
params = {"api_key": "alp_abc123"}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/next-day-movers?api_key=alp_abc123"

Request Parameters

• api_key (required) — your Alphanume API key.
• date — observations for a single trading date (YYYY-MM-DD).
• date_gte / date_lte / date_gt / date_lt — filter by date range. Any logically valid combination is accepted.

If no date filters are provided, all available historical observations are returned.

Response Format

{
  "count": 2,
  "data": [
    { "date": "2026-03-09", "ticker": "AAOI", "return": 8.92, "absolute_move": 8.92 },
    { "date": "2026-03-09", "ticker": "FIGR", "return": 21.29, "absolute_move": 21.29 }
  ]
}

Forward Return Availability

For the most recent observation date, return and absolute_move will appear as null. These fields represent realized movement during the following trading session — until a full trading day has completed after the selection date, the outcome cannot yet be calculated. Once the next session has closed, the values are populated automatically and remain fixed thereafter.

// Most recent date
{ "date": "2026-03-10", "ticker": "NVDA", "return": null, "absolute_move": null }

// Historical observation
{ "date": "2026-03-09", "ticker": "FIGR", "return": 21.29, "absolute_move": 21.29 }

Response Fields

Notes on Data Behavior

• New selections are generated daily at 3:30 PM (America/New_York Time)
• Historical observations are stored point-in-time
• Once published, observations are not retroactively altered
• Dates are returned as YYYY-MM-DD
• Results are ordered by date DESC

The Quant Galore Momentum Index provides the historical and live constituents of a rules-based, cross-sectional equity momentum strategy.

Each observation represents a stock included in the 10-stock monthly basket on a specific rebalance date, along with its rank within that basket. This dataset is designed for systematic traders, researchers, and allocators who want clean, point-in-time access to a maintained momentum index without reconstructing the full ranking pipeline.

Why it's useful

• Replicate or track the Quant Galore Momentum strategy
• Run independent performance attribution or turnover analysis
• Study cross-sectional momentum concentration effects
• Measure post-rebalance drift and decay
• Build overlays (options, hedging, leverage) on top of a rules-based equity core

Index Overview

• Universe: Deeply liquid U.S. equities with at least six consecutive weeks of listed weekly option expirations
• Construction: Cross-sectional momentum ranking
• Basket Size: Top 10 stocks
• Rebalance Frequency: Monthly
• Ranking: Highest momentum = rank 1

The dataset reflects the actual basket at that specific date, not a reconstructed or retroactively altered list.

Endpoint

GET /v1/quant-galore-momentum-index

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/quant-galore-momentum-index"
params = {"api_key": "alp_abc123"}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/quant-galore-momentum-index?api_key=alp_abc123"

Request Parameters

• api_key (required) — your Alphanume API key.
• date (optional) — return basket constituents for a single rebalance date (YYYY-MM-DD). Cannot be combined with range parameters.
• date_gte / date_lte / date_gt / date_lt (optional) — filter by rebalance date range. Any logically valid combination is accepted.

Validation rules:

• date_lte must be ≥ date_gte
• date_lte must be > date_gt
• date_lt must be > date_gte

If no date filters are provided, all available historical observations are returned (subject to tier-based limits).

Response Format

{
  "count": 970,
  "data": [
    { "date": "2026-02-02", "ticker": "BE", "rank": 10 },
    { "date": "2026-02-02", "ticker": "IREN", "rank": 9 }
  ]
}

Response Fields

Notes on Data Behavior

• Constituents update monthly upon rebalance at 4:05 PM (America/New_York Time)
• Each rebalance date contains exactly 10 stocks
• Rankings are deterministic and stored historically
• Historical baskets remain fixed once published
• Results are ordered by date DESC
• Dates are returned in YYYY-MM-DD format
• Invalid date formats return a 400 response
• Mixing date with range parameters returns a 400

The S&P 500 0-DTE Strike Band dataset provides a daily, model-derived strike range representing the expected intraday price bounds for the S&P 500 index during the current trading session.

Each observation contains a lower and upper strike level that define the range in which the index is expected to remain with high probability through the close of the same-day (0-DTE) options cycle. The band is calculated using forward-looking implied probability distributions and broader market risk factors, and is designed to assist traders in strike selection and risk management for intraday option strategies.

All observations are point-in-time and stored historically. Once published, values are never retroactively altered, allowing the dataset to be used safely in systematic research and backtesting workflows.

Why it's useful

• Identify statistically informed strike levels for same-day SPX options
• Structure intraday spreads, condors, or volatility-selling strategies
• Quantify expected index movement using implied probability information
• Filter or validate discretionary strike selection decisions
• Analyze historical containment probabilities for intraday index ranges

Endpoint

GET /v1/spx-0dte-strike-band

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/spx-0dte-strike-band"
params = {"api_key": "alp_abc123"}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/spx-0dte-strike-band?api_key=alp_abc123"

Request Parameters

• api_key (required) — your Alphanume API key.
• date — strike band for a single trading date (YYYY-MM-DD).
• date_gte / date_lte / date_gt / date_lt — filter by date range. Any logically valid combination is accepted.

If no date filters are provided, all available historical observations are returned (subject to tier-based limits).

Response Format

{
  "count": 1,
  "data": [
    {
      "date": "2026-03-05",
      "lower_strike": 6740,
      "upper_strike": 6880,
      "instrument": "SPX"
    }
  ]
}

Response Fields

Strike Band Definition

The lower_strike and upper_strikevalues represent the model-derived strike range within which the S&P 500 index is expected to remain through the close of the same-day options session. The band is calculated using forward-looking implied probability distributions, realized volatility data, and broader market risk factors. Strikes are rounded to the nearest listed SPX option increment.

Notes on Data Behavior

• New observations are published daily at 10:30 AM (America/New_York Time)
• Values are point-in-time and reflect information available at calculation time
• Historical strike bands remain fixed once published
• Dates are returned as YYYY-MM-DD
• Results are ordered by date DESC

The S&P 500 Risk Regime dataset provides a daily, point-in-time binary classification of prevailing equity market conditions.

Each observation reflects whether the S&P 500 was classified as being in a risk-off (1) or risk-on (0) regime on that date. The dataset is designed for systematic traders and researchers who require a stable, reproducible market state signal for filtering, sizing, or regime-aware modeling.

Why it's useful

• Filter strategies during elevated volatility or selloff regimes
• Dynamically scale position size based on market conditions
• Improve risk-adjusted returns via regime-aware allocation
• Segment backtests into bull vs stress environments
• Study behavioral or factor performance across volatility states

Endpoint

GET /v1/sp500-risk-regime

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/sp500-risk-regime"
params = {"api_key": "alp_abc123"}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/sp500-risk-regime?api_key=alp_abc123"

Request Parameters

• api_key (required) — your Alphanume API key.
• date (optional) — return regime classification for a single date (YYYY-MM-DD).
• date_gte / date_lte / date_gt / date_lt (optional) — filter by date range. Any logically valid combination is accepted.

If no date filters are provided, all available historical observations are returned (subject to tier-based limits).

Response Format

{
  "count": 522,
  "data": [
    { "date": "2026-02-23", "risk_regime": 1 }
  ]
}

Response Fields

Regime Definition

1 → Risk-Off: elevated volatility and/or stress conditions. Historically associated with defensive positioning and higher downside risk.

0 → Risk-On: lower volatility and constructive equity conditions. Historically associated with trend persistence and risk-seeking behavior.

The classification is derived from forward-looking implied volatility metrics and is stored as a fixed daily regime label. Historical values are not retroactively altered.

Notes on Data Behavior

• New observations are updated daily at 10:10 AM (America/New_York Time)
• Dates are returned as YYYY-MM-DD
• Values are point-in-time
• Historical regime labels remain fixed once published
• Results are ordered by date DESC

The Dilution dataset captures U.S. equity dilution risk at the moment it enters the market. It is a point-in-time record of S-1 registration statements, enriched with market context and lifecycle tracking, designed for traders and researchers who need to identify and manage dilution-driven risk with precision.

Each record represents a filing as it was known on the filing date, labeled for its dilutive impact and later resolved as the filing becomes effective or is withdrawn.

Why it's useful

• Identify dilution risk at inception, not in hindsight
• Filter or size exposure around secondary offerings and resale pressure
• Build short-biased or risk-aware strategies in small- and mid-cap equities
• Study post-filing outcomes, including time-to-effectiveness or withdrawal

Endpoint

GET /v1/dilution

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/dilution"
params = {
    "date_gte": "2026-02-06",
    "api_key": "alp_abc123"
}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/dilution?date_gte=2026-02-01&api_key=alp_abc123"

Request Parameters

• api_key (optional) — your API key. Enables full dataset access and reduces per-request limits. If omitted, a limited subset is returned.
• ticker (optional) — stock ticker filter (case-insensitive, exact match). If omitted, data across all tickers are returned.
• date (optional) — filing date filter (YYYY-MM-DD). If omitted, a ticker must be provided.

Date Filtering

All dates must be provided in YYYY-MM-DD format. Supported parameters:

• date_gte
• date_lte
• date_gt
• date_lt

Any logically valid combination is accepted.

Example Response

{
  "count": 1,
  "data": [
    {
      "date": "2026-02-02",
      "filing_timestamp": "2026-02-02T16:05:51-05:00",
      "ticker": "IVDA",
      "company_name": "Iveda Solutions, Inc.",
      "market_cap_at_filing": 2557918.88,
      "dilutive": 1,
      "resale": 0,
      "shares_offered": 5434782.0,
      "became_effective": 0,
      "effective_date": "",
      "days_to_effective": null,
      "offering_withdrawn": 0,
      "withdrawal_date": "",
      "days_to_withdrawal": null,
      "root_file_number": "333-293126",
      "accession_number": "0001493152-26-004743",
      "filing_url": "https://www.sec.gov/Archives/edgar/data/1397183/000149315226004743/0001493152-26-004743-index.htm",
      "last_updated": "2026-02-02 23:01:15.364519-05:00"
    }
  ]
}

Core Filing Fields (Point-in-Time)

Market Context (Point-in-Time)

Dilution Classification

Lifecycle Resolution

Metadata

Notes on Data Behavior

• Records are never removed once published
• Point-in-time fields remain fixed
• Only lifecycle fields update as events occur
• All dates are returned as YYYY-MM-DD strings

The De-SPAC Events dataset provides a point-in-time record of completed de-SPAC transactions, identifying when special purpose acquisition companies (SPACs) formally consummate their business combinations and transition into operating companies.

Each observation represents a confirmed de-SPAC completion event derived from SEC filings (typically Super 8-K disclosures). These events mark the structural transition from a blank check company into a publicly traded operating entity.

All observations are stored historically and remain fixed once published, allowing the dataset to be used safely in systematic research and backtesting workflows without lookahead bias.

Why it's useful

• Identify newly public companies emerging from SPAC mergers
• Build event-driven strategies around post de-SPAC performance
• Study structural inefficiencies following SPAC business combinations
• Track regime shifts in liquidity, float, and ownership post-merger
• Construct short-bias or mean-reversion strategies targeting de-SPAC cohorts
• Backtest systematic workflows conditioned on corporate transition events

Endpoint

GET /v1/de-spac-events

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/de-spac-events"
params = {"api_key": "alp_abc123"}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/de-spac-events?api_key=alp_abc123"

Request Parameters

• api_key (required) — your Alphanume API key.
• date (optional) — return observations for a single date (YYYY-MM-DD).
• date_gte / date_lte / date_gt / date_lt (optional) — filter by date range. Any logically valid combination is accepted.

If no date filters are provided, all available historical observations are returned.

Response Format

{
  "count": 2,
  "data": [
    {
      "date": "2026-03-20",
      "ticker": "MRLN",
      "filing_url": "https://www.sec.gov/Archives/edgar/data/0000000000/..."
    },
    {
      "date": "2026-03-09",
      "ticker": "FTW",
      "filing_url": "https://www.sec.gov/Archives/edgar/data/0000000000/..."
    }
  ]
}

Response Fields

Dataset Definition

Each observation corresponds to a confirmed de-SPAC completion event, identified through systematic parsing of SEC filings. A de-SPAC event is defined as the consummation of a business combination in which a SPAC merges with or acquires an operating company and ceases to function as a shell entity.

Events are primarily sourced from filings that explicitly indicate completion of the transaction, including language such as:

• “consummated the business combination”
• “completion of the business combination”
• “closed the business combination”

Additional confirming signals may include change in shell-company status, name change following the transaction, and commencement of trading under a new ticker. Only filings that clearly indicate completion (not proposals or pending transactions) are included.

Notes on Data Behavior

• Events are recorded using the filing date of the de-SPAC completion disclosure
• This date may occur shortly after the first day of trading under the new ticker
• Observations are point-in-time and reflect only information available at the time of filing
• Historical records are not retroactively altered
• Dates are returned as YYYY-MM-DD
• Results are ordered by date DESC

The Corporate Default Events dataset provides a historical, point-in-time log of public-company default events, labeled from SEC filing text and normalized into a clean event feed.

Each observation represents a date where a company was flagged as being in default status (is_default = 1), along with the associated ticker and the SEC filing URL used as source evidence.

The dataset is designed for systematic traders and researchers who need a reproducible event series for distress screens, event studies, short baskets, and credit-risk proxies.

Why it's useful

• Build distress / default event studies and measure post-event drift
• Screen for credit-like equity behavior without requiring CDS data
• Create short candidate universes based on documented default status
• Filter long strategies to avoid names entering default or restructuring conditions
• Train ML models using default events as labels or regime triggers

Endpoint

GET /v1/corporate-default-events

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/corporate-default-events"
params = {"api_key": "alp_abc123"}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/corporate-default-events?api_key=alp_abc123"

Request Parameters

• api_key (required) — your Alphanume API key.
• date (optional) — return events for a single date (YYYY-MM-DD). Cannot be combined with range parameters.
• date_gte / date_lte / date_gt / date_lt (optional) — filter events by date range. Any logically valid combination is accepted.

Validation rules:

• date_lte must be ≥ date_gte
• date_lte must be > date_gt
• date_lt must be > date_gte

If no date filters are provided, all available historical observations are returned (subject to tier-based limits).

Response Format

{
  "count": 517,
  "data": [
    {
      "event_date": "2026-02-09",
      "ticker": "ESGH",
      "filing_url": "https://www.sec.gov/Archives/edgar/data/1883835/000152013826000054/0001520138-26-000054-index.htm"
    }
  ]
}

Response Fields

Notes on Data Behavior

• Results are filtered to default-only events (is_default = 1)
• Dates are returned as YYYY-MM-DD
• Results are ordered by event_date DESC
• Invalid date format returns a 400 with the expected format
• If date is combined with any date range parameter, the API returns a 400

The Historical Optionable Tickers dataset captures the point-in-time universe of U.S. equities with listed options chains.

It is a monthly snapshot of stocks with available options contracts, enriched with structural expiration information to help traders construct optionable universes with precision. Each record reflects the option listing structure as it existed on the first trading day of the respective month.

Why it's useful

• Construct historically accurate optionable universes
• Filter equities by expiration density (weekly vs non-weekly structures)
• Study the evolution of options availability over time
• Backtest strategies that require confirmed option chain presence
• Identify securities with robust weekly expiration coverage

This dataset is especially useful for systematic traders who need to avoid survivorship bias in options-based research.

Snapshot Methodology

• Snapshots are taken on the first trading day of each month
• Each snapshot reflects listed option expirations available at that time
• Historical records correspond to the first trading day of their respective month
• Records are point-in-time and do not retroactively change

Endpoint

GET /v1/optionable-tickers

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/optionable-tickers"
params = {"api_key": "alp_abc123"}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/optionable-tickers?api_key=alp_abc123"

Request Parameters

• api_key (optional) — your API key. Enables full dataset access and reduces per-request limits. If omitted, a limited subset is returned.
• date (optional) — snapshot date (YYYY-MM-DD). If omitted, all existing snapshots are returned.

Date Filtering

All dates must be provided in YYYY-MM-DD format. Supported parameters:

• date
• date_gte
• date_lte
• date_gt
• date_lt

Any logically valid combination is accepted. If querying across all tickers without specifying a ticker, date ranges may be restricted depending on your access tier.

Example Response

{
  "count": 1,
  "has_more": false,
  "next_cursor": null,
  "data": [
    {
      "date": "2026-02-02",
      "ticker": "PFE",
      "avg_days_between": 7.0,
      "has_weeklies": 1
    }
  ]
}

Response Fields

Field Definitions

avg_days_between represents the average number of days between the next six consecutive option expiration dates after the first week window (expirations 1 through 6). Values close to 7 indicate dense weekly expiration structures; higher values indicate less frequent expiration spacing (e.g., biweekly or monthly listings).

has_weeklies is a binary indicator: 1 means multiple consecutive weekly expirations were listed at the snapshot date; 0 means weekly expiration continuity was not present.

Pagination

The Optionable Tickers endpoint uses cursor-based pagination for efficient retrieval of large result sets. Results are ordered deterministically:

ORDER BY date DESC, ticker DESC

When paginating, you must provide both cursor_date and cursor_ticker. These must match the next_cursor object from the previous response. If only one cursor field is provided, the request returns a 400 error.

Notes on Data Behavior

• Snapshots are taken on the first trading day of each month
• Records are never retroactively altered
• Each snapshot reflects only information known at that time
• Historical records remain fixed once published
• All dates are returned as YYYY-MM-DD strings

The Ticker Sector & Industry Classification dataset provides a mapping of equity tickers into Alphanume-defined sector and industry groups.

Each observation assigns a ticker to a consistent, internally defined classification system derived from underlying business activity. These classifications are designed for quantitative workflows and are not intended to replicate standardized taxonomies.

The dataset is structured to be stable, URL-safe, and directly queryable for use in filtering, grouping, and feature engineering pipelines.

Why it's useful

• Filter universes by sector or industry exposure
• Build sector-neutral or industry-relative strategies
• Group tickers for cross-sectional analysis
• Construct features based on economic exposure
• Standardize classification across research pipelines
• Join with other datasets for consistent segmentation

Endpoint

GET /v1/ticker-classification

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/ticker-classification"
params = {
    "api_key": "alp_abc123",
    "sector": "technology"
}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/ticker-classification?sector=technology&api_key=alp_abc123"

Request Parameters

• api_key (required) — your Alphanume API key.
• ticker (optional) — filter results by a specific ticker. Example: ?ticker=AAPL
• sector (optional) — filter results by sector. Must be one of the accepted sector keywords (lowercase, underscore-separated). Example: ?sector=technology
• industry (optional) — filter results by industry. Must be one of the accepted industry keywords. Example: ?industry=semiconductors

Available Sector Values

The following sector values are accepted for the sector parameter. All values must be lowercase and underscore-separated.

Available Industry Values

The following industry values are accepted for the industry parameter. All values must be lowercase and underscore-separated.

Parameter Behavior

• All parameters are optional
• If no parameters are provided, the full dataset is returned (subject to tier limits)
• Parameters can be combined

Examples:

?ticker=AAPL
?sector=finance
?industry=software
?sector=finance&industry=banking
?ticker=JPM&sector=finance

Invalid sector or industry values will return a 400 error.

Response Format

{
  "count": 2,
  "data": [
    {
      "ticker": "AAPL",
      "alphanume_sector": "technology",
      "alphanume_industry": "hardware_devices"
    },
    {
      "ticker": "MSFT",
      "alphanume_sector": "technology",
      "alphanume_industry": "software"
    }
  ]
}

Response Fields

Notes on Data Behavior

• Classifications are deterministic and consistent
• Values are not dynamically inferred at query time
• Results are ordered by ticker (ascending)
• No date dimension is applied
• The dataset represents the current mapping of tickers to classifications

The Historical Market Cap dataset provides point-in-time market capitalization and shares outstanding for equities, as they were known on each historical date.

It is designed for research and production workflows that require true point-in-time fundamentals (e.g., avoiding lookahead bias when modeling size, liquidity regimes, or dilution / float dynamics).

Why it's useful

• Build point-in-time size factors (market cap) without future leakage
• Normalize signals by shares outstanding / float regime
• Backtest strategies that depend on historical capitalization thresholds (e.g., “only trade > $X market cap at the time”)
• Monitor structural shifts from issuance / buybacks via share count changes

Endpoint

GET /v1/historical-market-cap

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/historical-market-cap"
params = {
    "ticker": "AAPL",
    "date": "2026-02-06",
    "api_key": "alp_abc123"
}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/historical-market-cap?ticker=AAPL&date=2026-02-06&api_key=alp_abc123"

Request Parameters

• api_key (optional) — your API key. Enables full dataset access and removes per-request limits. If omitted, a limited subset is returned.
• ticker (optional) — equity ticker filter (case-insensitive, exact match). If omitted, data across all tickers are returned.
• date (optional) — trading date filter (YYYY-MM-DD). If omitted, a ticker must be provided.

Date Filtering

All dates must be provided in YYYY-MM-DD format. Supported parameters:

• date_gte
• date_lte
• date_gt
• date_lt

Any logically valid combination is accepted.

Response Fields

Example Response

{
  "count": 1,
  "has_more": false,
  "next_cursor": null,
  "data": [
    {
      "date": "2026-02-06",
      "ticker": "AAPL",
      "market_cap": 4109599296360,
      "shares_outstanding": 14776353000
    }
  ]
}

Pagination

The Historical Market Cap endpoint uses cursor-based pagination for efficient retrieval of large result sets. Results are ordered deterministically:

ORDER BY date DESC, ticker DESC

Each response includes:

• count — number of rows returned in this page
• has_more — whether additional data is available
• next_cursor — cursor object to retrieve the next page

When paginating, you must provide both cursor_date and cursor_ticker. These must match the next_cursor object from the previous response. If only one cursor field is provided, the request returns a 400 error.

import requests

base_url = "https://api.alphanume.com/v1/historical-market-cap"
headers = {"X-API-Key": "alp_abc123"}
params = {"ticker": "AAPL"}

all_rows = []
while True:
    r = requests.get(base_url, headers=headers, params=params).json()
    all_rows.extend(r["data"])
    if not r["has_more"]:
        break
    cursor = r["next_cursor"]
    params["cursor_date"] = cursor["date"]
    params["cursor_ticker"] = cursor["ticker"]

print(f"Retrieved {len(all_rows)} rows.")

The Wikipedia Views dataset provides daily Wikipedia page view counts for equities, along with rolling 30-day statistics (mean, standard deviation, and z-score) measuring how unusual current attention is relative to the recent baseline.

It is designed for research and production workflows that incorporate retail attention as a feature — whether as a standalone signal, a regime filter, or an input to event-driven and cross-sectional models.

Why it's useful

• Build attention-based factors that capture shifts in investor interest before they show up in price or volume
• Detect anomaly days where ticker-level attention deviates sharply from its 30-day baseline (high z-score events)
• Filter or contextualize event-driven setups (earnings, news, filings) by the level of public attention surrounding them
• Backtest strategies conditioned on attention regimes (e.g., “only trade names with zscore_30d > 2”)

Endpoint

GET /v1/wikipedia-views

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/wikipedia-views"
params = {
    "ticker": "AAPL",
    "date": "2026-02-06",
    "api_key": "alp_abc123"
}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/wikipedia-views?ticker=AAPL&date=2026-02-06&api_key=alp_abc123"

Request Parameters

• api_key (required) — your API key. This endpoint requires Pro-tier authentication.
• ticker (optional) — equity ticker filter (case-insensitive, exact match). If omitted, data across all tickers are returned.
• date (optional) — observation date filter (YYYY-MM-DD). Cannot be combined with date range parameters.

If no filters are provided, the endpoint returns the full dataset ordered by date descending. Use cursor pagination to walk back through history.

Date Filtering

All dates must be provided in YYYY-MM-DD format. Supported parameters:

• date_gte
• date_lte
• date_gt
• date_lt

Any logically valid combination is accepted.

Z-Score Filtering

The zscore_30d field can be filtered to isolate attention anomalies. All values are floats. Supported parameters:

• zscore_30d_gte
• zscore_30d_lte
• zscore_30d_gt
• zscore_30d_lt
• zscore_30d_eq

zscore_30d_eq cannot be combined with z-score range parameters. Any logically valid combination of the range parameters is accepted.

Common use cases:

• zscore_30d_gte=2 — surface days with abnormally high attention
• zscore_30d_lte=-2 — surface days with abnormally low attention
• zscore_30d_gte=2&date=2026-02-06 — find every ticker with anomalous attention on a given date

Response Fields

Example Response

{
  "count": 1,
  "has_more": false,
  "next_cursor": null,
  "data": [
    {
      "ticker": "AAPL",
      "name": "Apple Inc.",
      "date": "2026-02-06",
      "views": 48213,
      "avg_30d": 21847.3,
      "std_30d": 6412.8,
      "zscore_30d": 4.11
    }
  ]
}

Pagination

The Wikipedia Views endpoint uses cursor-based pagination for efficient retrieval of large result sets. Results are ordered deterministically:

ORDER BY date DESC, ticker ASC

When paginating, you must provide both cursor_date and cursor_ticker. These must match the next_cursor object from the previous response. If only one cursor field is provided, the request returns a 400 error.

import requests

base_url = "https://api.alphanume.com/v1/wikipedia-views"
headers = {"X-API-Key": "alp_abc123"}
params = {"ticker": "AAPL"}

all_rows = []
while True:
    r = requests.get(base_url, headers=headers, params=params).json()
    all_rows.extend(r["data"])
    if not r["has_more"]:
        break
    cursor = r["next_cursor"]
    params["cursor_date"] = cursor["date"]
    params["cursor_ticker"] = cursor["ticker"]

print(f"Retrieved {len(all_rows)} rows.")

Tier Access

This endpoint is Pro-only. Free / Trial accounts will receive a 403 response:

{
  "error": {
    "code": "PRO_TIER_REQUIRED",
    "message": "This endpoint requires a Pro subscription.",
    "hint": "Upgrade to Pro for access to Wikipedia page view data."
  }
}

The Filing Intensity dataset provides daily SEC filing counts per equity, capturing how actively a company is interacting with the SEC on any given day. Filing activity is a leading indicator: corporate actions, capital raises, insider activity, and material events all leave fingerprints in the EDGAR filing stream before they're priced in.

It is designed for research and production workflows that incorporate corporate filing behavior as a feature — whether as a standalone signal, an event-detection trigger, or an input to event-driven and cross-sectional models.

Why it's useful

• Detect spikes in corporate activity that often precede material announcements, capital structure changes, or insider transactions
• Build event-driven signals around tickers entering periods of unusually heavy SEC engagement
• Filter or rank universes by recent filing intensity to surface names with active corporate developments
• Backtest strategies conditioned on filing-burst regimes (e.g., “only trade names with filing_count >= 5 on a given day”)

Endpoint

GET /v1/filing-intensity

Base URL

https://api.alphanume.com/v1

Authentication

All requests require an API key. Pass it as a query parameter (?api_key=your_key) or via header (X-API-Key: your_key).

Sample Request

import requests

url = "https://api.alphanume.com/v1/filing-intensity"
params = {
    "ticker": "AAPL",
    "date": "2026-02-06",
    "api_key": "alp_abc123"
}

r = requests.get(url, params=params)
print(r.json())

curl "https://api.alphanume.com/v1/filing-intensity?ticker=AAPL&date=2026-02-06&api_key=alp_abc123"

Request Parameters

• api_key (required) — your API key. This endpoint requires Pro-tier authentication.
• ticker (optional) — equity ticker filter (case-insensitive, exact match). If omitted, data across all tickers are returned.
• date (optional) — observation date filter (YYYY-MM-DD). Cannot be combined with date range parameters.

If no filters are provided, the endpoint returns the full dataset ordered by date descending. Use cursor pagination to walk back through history.

Date Filtering

All dates must be provided in YYYY-MM-DD format. Supported parameters:

• date_gte
• date_lte
• date_gt
• date_lt

Any logically valid combination is accepted.

Filing Count Filtering

The filing_count field can be filtered to isolate periods of elevated or quiet filing activity. All values are non-negative integers. Supported parameters:

• filing_count_gte
• filing_count_lte
• filing_count_gt
• filing_count_lt
• filing_count_eq

filing_count_eq cannot be combined with range parameters. Any logically valid combination of the range parameters is accepted.

Common use cases:

• filing_count_gte=5 — surface days with elevated filing activity
• filing_count_eq=0 — isolate quiet days for baselining
• filing_count_gte=3&date=2026-02-06 — find every ticker with elevated filing activity on a given date

Response Fields

Example Response

{
  "count": 1,
  "has_more": false,
  "next_cursor": null,
  "data": [
    {
      "ticker": "AAPL",
      "name": "Apple Inc.",
      "date": "2026-02-06",
      "filing_count": 7
    }
  ]
}

Pagination

The Filing Intensity endpoint uses cursor-based pagination for efficient retrieval of large result sets. Results are ordered deterministically:

ORDER BY date DESC, ticker ASC

When paginating, you must provide both cursor_date and cursor_ticker. These must match the next_cursor object from the previous response. If only one cursor field is provided, the request returns a 400 error.

import requests

base_url = "https://api.alphanume.com/v1/filing-intensity"
headers = {"X-API-Key": "alp_abc123"}
params = {}

all_rows = []
while True:
    r = requests.get(base_url, headers=headers, params=params).json()
    all_rows.extend(r["data"])
    if not r["has_more"]:
        break
    cursor = r["next_cursor"]
    params["cursor_date"] = cursor["date"]
    params["cursor_ticker"] = cursor["ticker"]

print(f"Retrieved {len(all_rows)} rows.")

Update Frequency

The Filing Intensity dataset is refreshed nightly at 11:30 PM EST. Each update incorporates all SEC filings submitted during the current trading day, ensuring data is available ahead of the next session's open. Filings submitted after the cutoff will appear in the following night's update.

Tier Access

This endpoint is Pro-only. Free / Trial accounts will receive a 403 response:

{
  "error": {
    "code": "PRO_TIER_REQUIRED",
    "message": "This endpoint requires a Pro subscription.",
    "hint": "Upgrade to Pro for access to SEC filing intensity data."
  }
}