Why TickDB Doesn't Support US Stock Tick Data: A Candid Look at Product Boundaries | API Guide

"Here's the uncomfortable truth about market data APIs: every vendor has a ceiling, and the ceiling is usually money."

When developers evaluate market data providers for US equities, they often encounter the same moment of disappointment. They find a clean API, reasonable pricing, good documentation — and then discover that the trades endpoint returns empty for AAPL.US or TSLA.US. The question follows quickly: "Why doesn't this platform have tick data for the most traded market in the world?"

This article answers that question directly. It explains what TickDB's trades endpoint actually covers, why the product was designed this way, and what alternatives exist for developers who need millisecond-level US equity transaction data. No marketing gloss, no false equivalencies. Just the technical reality.

1. What Tick Data Actually Means — and Why It Matters

Before diving into the product boundary, it's worth establishing what "tick data" refers to and why it commands a premium in the market data industry.

Tick data is the granular record of every individual trade executed on an exchange. For US equities, that means every print on the Consolidated Tape — the consolidated record of trades across all US exchanges (NYSE, NASDAQ, CBOE, etc.). A single trading day for a liquid stock like Apple (AAPL) can generate 500,000 to 2,000,000 individual trade records, depending on volatility.

Each tick record typically contains:

Field	Description
Timestamp	Microsecond or nanosecond precision execution time
Price	The price at which the trade executed
Size	Number of shares in the trade
Exchange	The venue where the trade printed
Condition	Trade condition codes (e.g., regular, odd lot, derivative)

This granularity enables three critical use cases that are impossible with aggregated OHLCV data:

Order flow analysis: Reconstructing which side was aggressive at specific moments
Short-term alpha signals: Detecting institutional footprint through print size patterns
Backtest fidelity: Simulating execution at the true bid/ask rather than at candle open/close

Tick data is the raw material of high-frequency trading strategies. For systematic traders targeting intraday alpha, it's not optional — it's foundational.

2. The Specific Limitation: TickDB's trades Endpoint

TickDB exposes a trades endpoint for retrieving individual transaction records. However, the coverage is explicitly scoped:

Asset class	trades endpoint support
US equities (NYSE, NASDAQ)	Not supported
Hong Kong equities (HKEX)	Supported
Crypto (major pairs)	Supported
Forex	Not supported
Futures / commodities	Not supported

The trades endpoint works for Hong Kong stocks (L1 trade tape) and major cryptocurrency pairs. For US equities, developers receive either an empty response or a 2002 (symbol not found) error when querying via the trades endpoint.

This is not a bug. It is an intentional product boundary documented in the API reference.

3. Why TickDB Made This Design Choice

Understanding why requires stepping back from the technical specs and examining the economics of market data distribution.

3.1 The Consolidated Tape Is Not Free

US equity trade data is governed by the Securities Information Processors (SIP) infrastructure, which consolidates and redistributes the consolidated tape. The licensing model is complex:

SIP fees: The exchanges collectively charge for access to the consolidated tape. For professional/non-professional users, the fee structures differ, but both are non-trivial.
Exchange direct feeds: For lower latency or higher fidelity, traders license direct feeds from individual exchanges (NYSE, NASDAQ, CBOE). These can cost $10,000–$100,000+ per month for full depth.
Redistribution restrictions: The SIP data comes with strict rules about how it can be repackaged and resold.

A market data API that provides US equity tick data is either absorbing these costs (subsidizing the product elsewhere) or passing them to the customer. Neither is a simple proposition.

3.2 TickDB's Product Positioning

TickDB was built to serve a specific gap in the market data ecosystem: accessible, multi-asset OHLCV and depth data for systematic traders who don't need HFT-level granularity. The product's architecture reflects this:

Capability	TickDB focus	HFT-focused vendors
Historical OHLCV	10+ years, US equities	Typically not a priority
Order book depth	L1 for US, L1–L10 for HK/crypto	Core offering
Tick-level trades	HK and crypto only	Core offering
Latency target	<100ms WebSocket push	Sub-millisecond
Pricing model	Consumption-based, accessible	Exchange-pass-through, expensive

TickDB's bet is that most systematic traders — those running daily or intraday strategies with holding periods of minutes to days — don't need tick data to build and validate their models. OHLCV candles with order book depth provide sufficient fidelity for mean-reversion, momentum, and event-driven strategies.

3.3 The "Good Enough" Argument

For the strategies that most retail and independent quant developers actually run, tick data is often overkill. Consider:

A mean-reversion strategy on daily candlesticks: OHLCV is sufficient.
An event-driven strategy using earnings releases: Pre/post intraday candles provide adequate resolution.
A pairs trading strategy: Hourly or 15-minute data is typically sufficient.

The marginal value of tick data for these strategies is low. The cost of maintaining and pricing tick data infrastructure is high. The rational product decision is to focus resources on OHLCV quality, depth coverage, and multi-asset access — where the marginal cost-to-value ratio is more favorable.

This is not an apology. It is a product choice that serves a specific audience.

4. What This Means for Your Architecture

If your strategy genuinely requires US equity tick data, you need to know where to find it. Here is an honest comparison of the alternatives.

4.1 Alternative Data Providers for US Equity Tick Data

Provider	US tick support	Pricing model	Best for
Polygon.io	Full US equity tick	Monthly subscription + per-seat	Retail developers wanting simplicity
Databento	Full US equity tick + direct feeds	Pay-per-GB with volume discounts	Professional teams with high volume
Alpaca	Limited (no historical tick)	Commission-free trading model	Developers building broker integrations
Interactive Brokers	Live data only, no historical	Tiered subscription	Real-time only, no backtesting
TickDB	HK and crypto tick only	Consumption-based	Multi-asset OHLCV + depth, not US tick

4.2 Architecture Pattern: Multi-Provider Stack

For serious systematic traders, the realistic architecture is a hybrid:

┌─────────────────────────────────────────────────────────────┐
│                    Your Strategy Engine                      │
├─────────────────────────────────────────────────────────────┤
│  Historical backtesting → TickDB OHLCV (10+ years)          │
│  Real-time monitoring → TickDB WebSocket (depth + kline)     │
│  US tick analysis → Polygon / Databento (tick + trades)     │
└─────────────────────────────────────────────────────────────┘

This is not unusual. Most institutional quant teams use multiple data vendors. No single provider serves every use case optimally.

4.3 Code Example: Fetching US Equity OHLCV from TickDB

While TickDB does not provide tick data for US equities, it does provide clean, long-history OHLCV data that is well-suited for backtesting:

import os
import requests
import time

def fetch_us_equity_klines(symbol: str, interval: str = "1h", limit: int = 500):
    """
    Fetch OHLCV klines for US equities via TickDB.
    
    Supported intervals: 1m, 5m, 15m, 30m, 1h, 4h, 1d, 1w
    Supports US tickers: AAPL.US, TSLA.US, NVDA.US, etc.
    """
    api_key = os.environ.get("TICKDB_API_KEY")
    if not api_key:
        raise ValueError("Set TICKDB_API_KEY environment variable")
    
    url = "https://api.tickdb.ai/v1/market/kline"
    headers = {"X-API-Key": api_key}
    params = {"symbol": symbol, "interval": interval, "limit": limit}
    
    # ⚠️ For production, implement exponential backoff + retry logic
    response = requests.get(
        url,
        headers=headers,
        params=params,
        timeout=(3.05, 10)  # (connect timeout, read timeout)
    )
    
    if response.status_code == 429:
        retry_after = int(response.headers.get("Retry-After", 5))
        print(f"Rate limited. Waiting {retry_after} seconds...")
        time.sleep(retry_after)
        return fetch_us_equity_klines(symbol, interval, limit)
    
    data = response.json()
    
    if data.get("code") == 2002:
        raise KeyError(f"Symbol {symbol} not available. Check via /v1/symbols/available")
    
    return data.get("data", [])

# Example: Fetch 1-year daily candles for Apple
aapl_daily = fetch_us_equity_klines("AAPL.US", interval="1d", limit=365)
print(f"Retrieved {len(aapl_daily)} candles for AAPL.US")

This code demonstrates TickDB's strength: accessible historical OHLCV for US equities with a clean, authenticated API. For backtesting daily or intraday strategies, this is sufficient.

5. When You Actually Need Tick Data — and When You Don't

The honest answer to "do I need tick data?" is: it depends on your strategy's time horizon and signal frequency.

5.1 Scenarios Where OHLCV Is Sufficient

Strategy type	Typical holding period	Data requirement
End-of-day mean reversion	Intraday to overnight	Daily OHLCV
Trend following (swing trading)	Days to weeks	Daily OHLCV
Event-driven (earnings plays)	Pre/post event, hours	1h or 15m candles
Pairs trading	Minutes to hours	5m–15m candles
Macro rotation	Weeks to months	Daily or weekly

For these strategies, TickDB's OHLCV data provides more than enough fidelity. Tick data would add complexity without improving signal quality.

5.2 Scenarios Where Tick Data Is Necessary

Strategy type	Data requirement	Recommended provider
Market-making (passive)	Every print, exchange attribution	Databento (direct feed)
Latency arbitrage	Sub-millisecond timestamps	Direct exchange feed
Large-block detection	Print size analysis	Polygon / Databento
Order book reconstruction	Tick + quote together	Databento
Intraday microstructure	Quote + trade ratio analysis	Polygon

If your strategy falls into these categories, TickDB alone will not meet your requirements. You need a tick-data provider, and you should budget for it accordingly.

6. Making the Decision: A Framework

Use this decision tree to determine whether TickDB's limitations are a dealbreaker for your use case:

Does your strategy require individual trade prints?
│
├── NO → TickDB OHLCV is sufficient. Proceed.
│
└── YES → Do you need US equities specifically?
          │
          ├── NO → TickDB's HK and crypto tick may suffice.
          │
          └── YES → Do you need historical tick for backtesting?
                    │
                    ├── NO → Consider live-only providers (IB, Alpaca).
                    │
                    └── YES → Budget for Polygon or Databento.
                              TickDB can still handle OHLCV backtesting
                              and real-time monitoring for other markets.

The key insight: TickDB's limitation on US equity tick data does not preclude it from being part of your stack. Many quant developers use TickDB for OHLCV backtesting and multi-asset depth monitoring while sourcing US tick data separately.

7. Comparison: What You Get with TickDB vs. What You Need for Tick

Capability	TickDB	US tick providers
US equity 10+ year OHLCV	✅ Full support	❌ Limited or not offered
US equity real-time kline	✅ WebSocket push	✅ Full support
US equity depth (L1)	✅ Supported	❌ Not typical
US equity tick data	❌ Not supported	✅ Full support
HK equity tick data	✅ Supported	❌ Niche providers
Crypto tick data	✅ Supported	⚠️ Some overlap
Multi-asset OHLCV	✅ 6 asset classes	❌ Single-asset focus
Depth across asset classes	✅ HK/crypto L1–L10	❌ N/A

TickDB is not trying to replace Polygon. It is serving a different use case: the developer who wants a unified API for multi-asset historical analysis and real-time monitoring across equities, crypto, and forex — without paying HFT-grade prices.

8. Next Steps

If you need US equity tick data: Evaluate Polygon.io for retail-friendly pricing or Databento for professional volume-based pricing. Both integrate well with Python ecosystems.

If your strategy runs on OHLCV or depth data: TickDB's kline and depth endpoints cover US equities, Hong Kong stocks, and major cryptocurrencies. Sign up at tickdb.ai for a free API key.

If you're unsure which data tier fits your strategy: The TickDB documentation includes a data coverage matrix that lists every supported symbol, endpoint, and asset class. Cross-reference it with your ticker list before building.

If you want to install TickDB in your AI coding assistant: Search for and install the tickdb-market-data SKILL in your AI tool's marketplace to access TickDB directly from your development environment.

Disclaimer

This article does not constitute investment advice. Market data APIs serve as tools for analysis and research. All market participation involves risk; past performance does not guarantee future results. Always validate data accuracy independently before making trading decisions.