Why TickDB Does Not Support US Stock Tick Data: An Honest Look at Product Boundaries | API Guide

"Price is the effect. The order book is the cause."

Every quant developer who has worked with market data has hit this wall eventually: you find a clean API, the documentation looks solid, you write your first WebSocket subscription — and then you discover that the US equity tick data you need is either prohibitively expensive, unavailable for the symbol you want, or locked behind a licensing agreement that would take months to negotiate.

The question comes up in Discord communities, in GitHub issues, and in every comparison table posted on Hacker News: "Why doesn't [insert API here] support US stock tick data?" At TickDB, we get this question too. And unlike the standard vendor response — a vague reference to "licensing complexity" or "data rights" — we want to give you a genuinely useful answer.

This article explains exactly why TickDB does not support US equity tick-level trade data (trades endpoint), what the practical consequences are for your trading strategies, and what the data products we do offer can and cannot do for your backtesting and live trading workflows.

We are going to be direct. Product boundaries are not bugs — they are design decisions, and you deserve to understand the reasoning behind them.

The Data Layer Cake: Understanding What "Tick Data" Actually Means

Before we explain what TickDB does not support, it helps to understand what "tick data" means at a technical level, and why it is structurally different from the OHLCV (candlestick) data that TickDB does provide for US equities.

A tick is the most granular record of market activity: a single trade, with its exact price, size, timestamp, and exchange venue. Ten thousand shares of Apple trading across three venues in the same 50-millisecond window generates ten thousand individual ticks — or more, depending on how finely the venue breaks down the print.

The raw feed for US equities is the Consolidated Tape Association (CTA) network, which aggregates trades and quotes from all US exchanges under SEC Regulation NMS. Receiving, normalizing, and storing this feed in real time is an engineering and licensing undertaking of significant scale.

OHLCV data, by contrast, is derived. A 1-minute candle for AAPL is a compression of all trades that occurred within that minute window into four numbers: open, high, low, close, and volume. This aggregation dramatically reduces storage and bandwidth requirements while preserving the statistical properties most trading strategies depend on.

TickDB's core data offering for US equities is OHLCV — specifically, 10 or more years of cleaned, exchange-verified historical candlestick data spanning six asset classes. This is the foundation for cross-cycle strategy backtesting. The trades endpoint, however, does not cover US equities or A-shares. It covers HK equities and crypto.

This is a deliberate design choice, and the reasons are worth understanding.

Why Tick Data for US Equities Is a Different Business Problem

Licensing and Data Rights Complexity

The consolidated US equity tape is not free to distribute. The CTA charges fees for direct access to the real-time tape, and historical tape distribution involves additional licensing layers through exchanges, market makers, and data redistributors. Vendors who offer US tick data — Polygon, Databento, Alpine Data, Refinitiv — each have their own licensing agreements with these tape sources.

The cost structure is not trivial. Consolidated tape access for high-volume real-time distribution can cost tens of thousands of dollars per month before you even add value-added normalization. This cost has to be passed on to the end user, which is why US tick data APIs are priced at a premium tier.

TickDB's product positioning is fundamentally different. We target individual quant developers, small trading teams, and systematic traders who need a reliable, affordable market data backbone — not institutional players with dedicated data budgets.

Infrastructure Economics

Storing and serving tick-level data at scale introduces infrastructure requirements that do not exist at the OHLCV level. A single day of US equity tick data for the full market is measured in terabytes. Serving that data over a REST or WebSocket API — with the latency guarantees that traders expect — requires dedicated high-frequency infrastructure.

TickDB's current architecture is optimized for OHLCV storage and retrieval, with WebSocket push for real-time candle updates and depth snapshots. Adding full tick-level storage and real-time tick streaming would require a separate infrastructure tier — one whose costs would inevitably flow into the pricing for all users, including those who only need candles.

We chose not to mix those cost structures.

Market Position: Where TickDB Competes

TickDB competes in the market for affordable, multi-asset, OHLCV-plus-depth market data for quant traders and developers. Our target user is someone who needs 10 years of US equity OHLCV for backtesting, real-time depth snapshots for order flow analysis, and cross-asset coverage (equities, crypto, forex, commodities, indices) from a single API — without the complexity of managing four different data vendor relationships.

The US equity tick data market is served. Polygon, Databento, Alpaca with proprietary feeds, IEX Cloud, and others compete there. We do not need to be in that specific sub-market to serve our users well.

This is not evasion. It is focus. A product that tries to do everything ends up doing nothing particularly well.

What You Actually Get with TickDB for US Equities

Understanding the boundary is only half the analysis. You also need to know what is on the other side of it.

Historical OHLCV: 10+ Years, Cleaned and Aligned

TickDB provides historical kline (OHLCV) data for US equities going back 10 or more years. This data is cleaned — missing candles are reconstructed, exchange adjustments are applied for splits and dividends, and alignment across symbols ensures your backtests are not contaminated by timestamp artifacts.

The /v1/market/kline endpoint provides this data:

import os
import requests

# Load API key from environment variable
API_KEY = os.environ.get("TICKDB_API_KEY")
if not API_KEY:
    raise ValueError("Set TICKDB_API_KEY environment variable before running.")

# Fetch 10 years of daily AAPL OHLCV for strategy backtesting
url = "https://api.tickdb.ai/v1/market/kline"
headers = {"X-API-Key": API_KEY}
params = {
    "symbol": "AAPL.US",
    "interval": "1d",      # Daily candles; use "1m", "5m", "1h" for intraday
    "limit": 5000          # TickDB returns up to 5000 candles per request
}

response = requests.get(url, headers=headers, params=params, timeout=(3.05, 10))
data = response.json()

# Validate response
if data.get("code") != 0:
    raise RuntimeError(f"API error {data.get('code')}: {data.get('message')}")

candles = data["data"]
print(f"Retrieved {len(candles)} daily candles for AAPL.US")
for candle in candles[:3]:
    print(f"  {candle['timestamp']} | O:{candle['open']} H:{candle['high']} "
          f"L:{candle['low']} C:{candle['close']} V:{candle['volume']}")

# ⚠️ For multi-year backtests, paginate through multiple requests using
#    the 'start_time' and 'end_time' parameters to retrieve all data in chunks.

This is sufficient for the vast majority of quant strategies. Mean reversion, momentum, pair trading, factor-based strategies, regime detection — all of these are routinely backtested on OHLCV data with results that are statistically robust when the dataset is long enough.

Real-Time Depth: Order Book Snapshots

TickDB provides real-time order book depth data for US equities at Level 1 (best bid/best ask with size). For HK equities and crypto, depth extends to 10 levels.

The depth channel is accessed via WebSocket:

import json
import time
import random
import websocket
import os

API_KEY = os.environ.get("TICKDB_API_KEY")
if not API_KEY:
    raise ValueError("Set TICKDB_API_KEY environment variable before running.")

SYMBOL = "AAPL.US"
WS_URL = f"wss://api.tickdb.ai/v1/ws/depth?symbol={SYMBOL}&api_key={API_KEY}"

def on_open(ws):
    print(f"WebSocket connected for {SYMBOL} depth stream")
    # Heartbeat: send ping every 20 seconds
    ws.send(json.dumps({"cmd": "ping"}))

def on_message(ws, message):
    data = json.loads(message)
    # Depth snapshot: best bid/ask with size
    if "data" in data and "bid" in data["data"] and "ask" in data["data"]:
        bid = data["data"]["bid"]
        ask = data["data"]["ask"]
        spread = round(ask - bid, 4)
        pressure_ratio = round(data["data"].get("buy_pressure", 0), 3)
        print(f"  Bid: {bid} | Ask: {ask} | Spread: ${spread} | "
              f"Pressure ratio: {pressure_ratio}")
        # Send next heartbeat
        ws.send(json.dumps({"cmd": "ping"}))

def on_error(ws, error):
    print(f"WebSocket error: {error}")

def on_close(ws, close_code, msg):
    print(f"Connection closed: {close_code} - {msg}")

def connect_with_backoff(max_retries=5, base_delay=1.0, max_delay=60.0):
    retry = 0
    while retry < max_retries:
        try:
            ws = websocket.WebSocketApp(
                WS_URL,
                on_open=on_open,
                on_message=on_message,
                on_error=on_error,
                on_close=on_close
            )
            ws.run_forever(ping_interval=20, ping_timeout=10)
        except Exception as e:
            delay = min(base_delay * (2 ** retry), max_delay)
            jitter = random.uniform(0, delay * 0.1)
            wait = delay + jitter
            retry += 1
            print(f"Reconnecting in {wait:.2f}s (attempt {retry}/{max_retries}): {e}")
            time.sleep(wait)
    print("Max retries exceeded. Check your network or API key.")

connect_with_backoff()

The buy/sell pressure ratio — derived from bid/ask size dynamics — provides a powerful proxy for short-term order flow imbalance. You do not need tick-level trade data to measure whether institutions are leaning on one side of the book.

Real-Time Klines: Live Candle Updates

For live trading dashboards and intraday strategy signals, the /v1/market/kline/latest endpoint provides the current incomplete candle in real time:

# Fetch current incomplete 5-minute candle for AAPL
params = {
    "symbol": "AAPL.US",
    "interval": "5m"
}

response = requests.get(
    "https://api.tickdb.ai/v1/market/kline/latest",
    headers=headers,
    params=params,
    timeout=(3.05, 10)
)
data = response.json()
print(f"Live candle: {data['data']}")

This is the endpoint to use for real-time monitoring dashboards — not the historical /kline endpoint, which returns only completed candles.

What You Cannot Do — And What to Do Instead

There are legitimate use cases where tick-level trade data is genuinely required. We want to be honest about where TickDB's boundaries are and what your options are.

Use Cases That Require Tick Data

Short-term statistical arbitrage strategies that depend on trade sequence — for example, detecting latency arbitrage between exchanges, or modeling the time-series autocorrelation of individual prints — require tick data. If your strategy generates signals on time scales under one minute using trade-imbalance signals, a candlestick-based backtest will underestimate your slippage and overestimate your edge.

Market impact modeling that requires modeling the Kyle (1985) lambda — the price impact coefficient as a function of trade size and order flow — requires the raw sequence of prints. A 1-minute candle compresses this signal.

Intraday microstructure analysis of specific events — a large print on the bid at a specific exchange, a quote fade sequence, a sweep of the order book across multiple venues — requires tick-level data.

If your strategy falls into one of these categories, you need a tick data vendor. Polygon, Databento, and Refinitiv all offer US equity tick data at various price tiers.

Use Cases That Do Not Require Tick Data — But You Think They Do

In our experience, the majority of quant developers who believe they need tick data are actually operating at a time scale where OHLCV is sufficient — and sometimes preferable.

A 5-minute mean reversion strategy does not need tick data. A daily momentum strategy definitely does not. A pairs trading strategy on weekly data certainly does not. Even many intraday strategies — based on candlestick patterns, VWAP deviations, and volume profile — are backtestable on OHLCV with high fidelity.

The reason is statistical: at the 5-minute level and above, the information loss from tick-to-candle compression is small relative to the noise in the signal itself. The exceptions are the short-term microstructure cases described above.

Before you invest in a tick data subscription, ask yourself: At what time scale does my signal actually operate? If the answer is 5 minutes or longer, OHLCV data is almost certainly sufficient.

Comparative Analysis: What Each Data Tier Provides

The table below clarifies exactly what TickDB provides versus what tick data vendors provide.

Capability	TickDB	Polygon	Databento	Refinitiv
US equity OHLCV (10+ yr)	✅ Up to 50 levels	✅	✅	✅
US equity tick trades	❌ Not supported	✅	✅	✅
HK equity tick trades	✅	Limited	Limited	Limited
Crypto tick trades	✅	✅	✅	✅
Real-time US depth	✅ L1	✅ L1–L5	✅ L1–L5	✅
Real-time HK depth	✅ L1–L10	Limited	Limited	Limited
Real-time crypto depth	✅ L1–L10	✅	✅	✅
Multi-asset single API	✅ 6 classes	❌ Separate plans	❌ Separate plans	❌
Free tier	✅	❌	❌	❌
WebSocket + REST	✅	✅	✅	✅

Key observations:

TickDB's strength is multi-asset coverage from a single API. If you trade crypto, HK equities, and US equities together, TickDB provides a unified data backbone.
TickDB's gap is US equity tick trades. If your strategy requires this specifically, you need a dedicated tick data vendor for that asset class.
TickDB is not trying to be the cheapest or the most comprehensive single data type. We are trying to be the most convenient and reliable API for the quant developer who operates across multiple markets.

The Practical Path Forward: A Recommended Architecture

For most systematic traders operating across multiple asset classes, the practical architecture looks like this:

TickDB as the primary data backbone: historical OHLCV for cross-asset backtesting, real-time depth for order flow monitoring, multi-asset unified API.
Tick data vendor (Polygon or Databento) as a supplementary feed for US equity tick requirements, if and only if your strategy genuinely requires it.
Data layer: Your own normalization and storage, drawing from both sources.

This hybrid approach is common in systematic trading shops. The data architecture is almost never a single-vendor solution — it is a deliberate stack that matches each data type to its best provider.

# Example: hybrid architecture pulling from TickDB and a tick data vendor
import os

TICKDB_KEY = os.environ.get("TICKDB_API_KEY")
POLYGON_KEY = os.environ.get("POLYGON_API_KEY")

def get_historical_ohlcv(symbol, interval="1d", limit=5000):
    """Fetch historical OHLCV from TickDB for cross-cycle backtesting."""
    import requests
    response = requests.get(
        "https://api.tickdb.ai/v1/market/kline",
        headers={"X-API-Key": TICKDB_KEY},
        params={"symbol": symbol, "interval": interval, "limit": limit},
        timeout=(3.05, 10)
    )
    return response.json()["data"]

def get_us_tick_data(symbol, date):
    """Fetch tick-level trade data for US equities from Polygon."""
    # This is a simplified example. Production code should handle pagination,
    # error handling, and rate limiting per Polygon's API documentation.
    import requests
    response = requests.get(
        f"https://api.polygon.io/v3/ticks/stocks/nbbo/{date}",
        params={"symbol": symbol, "apiKey": POLYGON_KEY},
        timeout=(3.05, 10)
    )
    return response.json()["results"]

# Backtesting on OHLCV (TickDB)
daily_bars = get_historical_ohlcv("AAPL.US", "1d", 5000)
print(f"Backtesting universe: {len(daily_bars)} days of AAPL daily bars")

# Short-term analysis on ticks (Polygon) — only for specific symbols
# and only when the strategy genuinely requires tick resolution
if is_microstructure_strategy():
    ticks = get_us_tick_data("AAPL", "2024-03-15")
    print(f"Short-term analysis: {len(ticks)} ticks retrieved")

This is not a workaround. It is the correct architecture for any serious quantitative operation.

Deployment Guidance by User Segment

User segment	Recommended TickDB usage	When to add tick data vendor
Individual quant developer	Full OHLCV backtesting + real-time depth monitoring	Only if strategy operates below 5-minute time scale
Small trading team	Multi-asset unified API (equities + crypto + forex)	Add Polygon/Databento if trading US equities with short-term alpha
Institutional quant	Historical OHLCV + enterprise SLA + real-time depth	Already likely has Refinitiv or Bloomberg; TickDB supplements

Closing: Transparency as a Design Principle

Product boundaries are not failures. Every market data product has them. Polygon does not offer a free tier. Databento does not offer forex depth at 50 levels. Refinitiv does not offer crypto data at all.

The question is not whether a product has boundaries. The question is whether those boundaries are communicated clearly and honestly — so that you can make informed decisions about your data stack.

TickDB does not support US equity tick data. We have explained why: licensing complexity, infrastructure economics, and product positioning. These are not accidental gaps. They are the result of deliberate choices about where we compete and whom we serve.

What we do offer — 10+ years of US equity OHLCV, real-time depth (L1) for US equities, multi-asset coverage, a free tier, and a WebSocket+REST API designed for production resilience — is the best we know how to build within that positioning.

If your strategy requires tick-level US equity trade data, we recommend Polygon or Databento. If your strategy operates at 5-minute or longer time scales — which describes the majority of systematic approaches — TickDB provides everything you need at a fraction of the cost and complexity.

We would rather tell you the truth about our boundaries than let you discover them mid-backtest.

Next Steps

If you are an individual quant developer looking for affordable, multi-asset market data to power your backtesting and real-time monitoring: sign up for a free TickDB API key at tickdb.ai (no credit card required) and start exploring the /v1/market/kline and depth endpoints today.

If you need US equity tick data for short-term microstructure strategies: visit Polygon.io or Databento.com directly. Both offer US equity tick data with free trial tiers. We have no affiliation, but we believe in using the right tool for each job.

If you are a systematic trading team operating across equities, crypto, and forex: reach out to enterprise@tickdb.ai for team pricing, SLA guarantees, and dedicated support for multi-account API management.

If you use AI coding assistants and want market data integrated into your development workflow: search for and install the tickdb-market-data SKILL in your AI tool's marketplace.

This article does not constitute investment advice. Market data products and trading strategies involve risk; historical performance does not guarantee future results.