"Price data is only as reliable as its gaps."
A quant researcher runs a mean-reversion backtest on 10 years of S&P 500 data. The strategy looks phenomenal — Sharpe of 1.8, max drawdown under 6%. Then they notice a string of zero-return days where the strategy was trading around the rebalancing cutoff, and they realize half their "returns" came from index reconstitution effects, not actual alpha. The data was correct. The interpretation was flawed — because the dataset did not encode when stocks were suspended, when index composition changed, or when companies were delisted.
This is not a TickDB problem. It is a market data problem that every systematic trading system must solve. TickDB's approach to trading halts, delistings, and constituent adjustments exists at the intersection of three principles: completeness by default, point-in-time fidelity, and explicit flagging rather than silent normalization. This article dissects each mechanism.
1. The Data Integrity Stack: Three Layers of Completeness
Before examining specific edge cases, it helps to understand the three-layer model TickDB uses to guarantee data integrity:
Layer 1 — Primary Data: Raw market data sourced directly from exchange feeds. OHLCV candles, order book snapshots, trade prints. This layer is stored with full timestamp precision and source attribution.
Layer 2 — Temporal Annotation: Each data point carries metadata about its market-state context. Is the market in a regular session? Pre-open? Halted? This layer is critical for backtesting because a "flat" candle during a halt is semantically different from a "flat" candle in a quiet market.
Layer 3 — Point-in-Time Reconstruction: Historical datasets encode the information that was available at a specific moment in time, not the information that is available today. This is the layer that handles delisted securities, constituent changes, and symbol mapping across name changes.
The following sections address each edge case through this stack.
2. Trading Halts: What Returns When the Market Stops
2.1 Halt Classification in TickDB
Exchange-regulated trading halts fall into two categories, and the distinction matters for backtesting:
| Halt Type | Trigger | Data Behavior in TickDB |
|---|---|---|
| News-based halt | Material news pending (earnings, M&A) | Trading suspended; last traded price persisted; no new candles generated until resumption |
| Market-wide circuit breaker | Price move exceeds threshold (e.g., 7%, 13%, 20% for US equities) | Same as news-based halt; may span multiple venues |
| Regulatory suspension | SEC/FINRA enforcement action | No trades; no quotes; metadata flag set to suspended |
2.2 The Halt-Fill Strategy: Candle Continuity Without Noise Injection
When a stock is halted, naive data vendors either drop the period entirely (creating a visual gap) or fill it with the last traded price (creating phantom volume). TickDB neither drops nor silently fills. Instead, it emits a candle with volume = 0 and a specific metadata flag.
Python code — Querying a halted symbol:
import os
import requests
from datetime import datetime, timezone
TICKDB_API_KEY = os.environ.get("TICKDB_API_KEY")
BASE_URL = "https://api.tickdb.ai/v1"
def get_candles_with_halt_flags(symbol: str, interval: str = "1h",
start: int = None, end: int = None, limit: int = 100):
"""
Fetch OHLCV candles including halt-state metadata.
The response includes a `state` field per candle:
- "trading" : normal continuous session
- "halted" : exchange-regulated trading halt
- "closed" : outside regular trading hours
- "pre_open" : opening auction phase
- "post_close" : closing auction phase
"""
headers = {"X-API-Key": TICKDB_API_KEY}
params = {
"symbol": symbol,
"interval": interval,
"limit": limit
}
if start:
params["start"] = start
if end:
params["end"] = end
response = requests.get(
f"{BASE_URL}/market/kline",
headers=headers,
params=params,
timeout=(3.05, 10)
)
response.raise_for_status()
data = response.json()
if data.get("code") != 0:
raise RuntimeError(f"API error {data.get('code')}: {data.get('message')}")
return data.get("data", [])
def identify_halt_periods(candles: list) -> list:
"""
Extract halt periods from a candle stream.
Returns a list of dicts with start, end, and duration in seconds.
"""
halts = []
current_halt = None
for candle in candles:
state = candle.get("state", "trading")
timestamp = candle.get("t") # Unix milliseconds
if state == "halted":
if current_halt is None:
current_halt = {"start": timestamp, "symbol": candle.get("s")}
current_halt["end"] = timestamp
else:
if current_halt is not None:
current_halt["duration_seconds"] = (
current_halt["end"] - current_halt["start"]
) // 1000
halts.append(current_halt)
current_halt = None
# Close any open halt at end of data
if current_halt is not None:
halts.append(current_halt)
return halts
# Example: Check AAPL for halt periods around a known earnings date
if __name__ == "__main__":
# Query 3 days around earnings season
symbol = "AAPL.US"
# Approximate timestamps for Q4 2025 earnings window
start_ts = 1737500000000 # ~Jan 2025
end_ts = 1738000000000
candles = get_candles_with_halt_flags(
symbol=symbol,
interval="1h",
start=start_ts,
end=end_ts,
limit=500
)
halts = identify_halt_periods(candles)
if halts:
print(f"Found {len(halts)} halt period(s) for {symbol}:")
for halt in halts:
start_dt = datetime.fromtimestamp(halt["start"] / 1000, tz=timezone.utc)
end_dt = datetime.fromtimestamp(halt["end"] / 1000, tz=timezone.utc)
print(f" {start_dt} → {end_dt} "
f"({halt['duration_seconds']} seconds, "
f"{halt['duration_seconds']/60:.1f} minutes)")
else:
print(f"No halt periods detected for {symbol} in the queried window.")
2.3 Backtesting Implications
When a strategy trades around a halt window, the backtester must handle the zero-volume candles explicitly. A mean-reversion strategy that computes z-scores from volume will see a spike in the z-score during a halt period — not because of genuine demand-supply imbalance, but because the volume metric temporarily encodes "no trading" rather than "symmetric trading."
Engineering warning: Do not treat volume = 0 candles as neutral data points. Filter them or handle them as a distinct market regime.
3. Delistings: When a Company Leaves the Market
3.1 What TickDB Preserves
When a company is delisted — voluntarily (M&A completion, going private) or involuntarily (exchange rules, bankruptcy) — most market data vendors purge the security from their active database. TickDB takes the opposite approach: delisted securities are retained indefinitely in a delisted securities archive.
| Data type | Availability after delisting |
|---|---|
| OHLCV historical candles | Full history preserved |
| Order book snapshots | Last available snapshot preserved |
| Trade prints | Full history preserved |
| Corporate actions (splits, dividends) | Full history preserved |
| Real-time / live feed | Not available — security is no longer trading |
The delisted archive is accessible through the same API endpoints as active securities. The API key, authentication headers, and query parameters are identical. The only difference is that a delisted symbol will return a state field of "delisted" in its metadata response.
3.2 Querying Delisted Securities
import os
import requests
TICKDB_API_KEY = os.environ.get("TICKDB_API_KEY")
BASE_URL = "https://api.tickdb.ai/v1"
def list_delisted_securities(region: str = "US", limit: int = 100):
"""
Retrieve the delisted securities archive.
Region options: US, HK, CN, GLOBAL
"""
headers = {"X-API-Key": TICKDB_API_KEY}
params = {"region": region, "delisted": True, "limit": limit}
response = requests.get(
f"{BASE_URL}/symbols",
headers=headers,
params=params,
timeout=(3.05, 10)
)
response.raise_for_status()
data = response.json()
if data.get("code") != 0:
raise RuntimeError(f"API error {data.get('code')}: {data.get('message')}")
return data.get("data", [])
def get_delisted_candles(symbol: str, interval: str = "1d", limit: int = 500):
"""
Fetch historical candles for a delisted security.
Works identically to active symbol queries — same endpoint,
same parameter set. No special flags needed.
"""
headers = {"X-API-Key": TICKDB_API_KEY}
params = {"symbol": symbol, "interval": interval, "limit": limit}
response = requests.get(
f"{BASE_URL}/market/kline",
headers=headers,
params=params,
timeout=(3.05, 10)
)
response.raise_for_status()
data = response.json()
if data.get("code") != 0:
raise RuntimeError(f"API error {data.get('code')}: {data.get('message')}")
return data.get("data", [])
# Example: Check for delisted securities that were in the 2008 financial sector
if __name__ == "__main__":
delisted = list_delisted_securities(region="US", limit=50)
financial_delists = [
s for s in delisted
if s.get("sector") == "Financial" and
s.get("delist_date", "") < "2010-01-01"
]
print(f"Found {len(financial_delists)} delisted financial sector securities "
f"removed before 2010:")
for sec in financial_delists:
print(f" {sec.get('symbol')}: {sec.get('name')} "
f"(delisted: {sec.get('delist_date')})")
3.3 The Symbol Migration Problem: Mergers, Splits, and Ticker Changes
A more subtle problem than delisting is symbol migration. A company may change its ticker (ticker rename), undergo a reverse split, or be acquired for a stock-for-stock merger. The new ticker replaces the old one in the active database, but the historical data for the old ticker may be archived separately.
TickDB handles symbol migration through a symbol mapping table:
def get_symbol_history_mapping(symbol: str) -> dict:
"""
Retrieve the full symbol history for a security.
Returns a list of ticker changes, including effective dates.
This is critical for backtesting companies that underwent
restructuring — you need to stitch together the historical
price series from multiple tickers.
Response structure:
{
"current_symbol": "NVDA.US",
"history": [
{"symbol": "NVDA.US", "from": "1999-01-22", "to": None},
{"symbol": "NVDA", "from": "1993-01-22", "to": "1999-01-21"}
]
}
"""
headers = {"X-API-Key": TICKDB_API_KEY}
response = requests.get(
f"{BASE_URL}/symbols/{symbol}/history",
headers=headers,
timeout=(3.05, 10)
)
response.raise_for_status()
data = response.json()
if data.get("code") != 0:
raise RuntimeError(f"API error {data.get('code')}: {data.get('message')}")
return data.get("data", {})
def stitch_historical_price_series(target_symbol: str,
interval: str = "1d") -> list:
"""
Stitch together a continuous OHLCV series from a symbol's
complete history, including pre-renaming periods.
This is the correct approach for long-term backtesting
on securities with ticker change history.
"""
mapping = get_symbol_history_mapping(target_symbol)
history = mapping.get("history", [])
all_candles = []
seen_dates = set()
for period in reversed(history): # Oldest first
period_symbol = period["symbol"]
try:
candles = get_delisted_candles(
symbol=period_symbol,
interval=interval,
limit=10000 # Large limit for full history
)
except Exception:
# Symbol may not exist in historical records
continue
for candle in candles:
ts = candle.get("t")
if ts not in seen_dates:
all_candles.append(candle)
seen_dates.add(ts)
# Sort by timestamp ascending (oldest to newest)
all_candles.sort(key=lambda c: c.get("t", 0))
return all_candles
Engineering warning: Stitching price series from symbol changes without accounting for corporate actions (reverse splits, mergers) will produce misleading cumulative returns. Always apply adjustment factors from the corporate actions table before computing returns.
4. Constituent Changes: Point-in-Time Data for Index Strategies
4.1 The Point-in-Time Problem
Consider an index strategy that rebalances quarterly. At the rebalance date, the index provider publishes a new constituent list. However, the index values that were published before the rebalance were calculated using the old constituent list. A backtest that uses the current constituent list to compute historical index returns will produce incorrect results — specifically around the reconstitution window.
Point-in-time (PIT) data means that every data point is annotated with the universe that was active at that moment in time. TickDB encodes this through a constituent timeline for major indices.
4.2 Constituent Timeline API
import os
import requests
from datetime import datetime, timezone
TICKDB_API_KEY = os.environ.get("TICKDB_API_KEY")
BASE_URL = "https://api.tickdb.ai/v1"
def get_constituent_timeline(index_symbol: str) -> list:
"""
Retrieve the full constituent change history for an index.
Returns each reconstitution event with:
- effective_date: when the new universe took effect
- added: list of symbols added
- removed: list of symbols removed
- source: index provider reference
This is the ground truth for index-strategy backtesting.
"""
headers = {"X-API-Key": TICKDB_API_KEY}
params = {"index": index_symbol}
response = requests.get(
f"{BASE_URL}/indices/constituents/history",
headers=headers,
params=params,
timeout=(3.05, 10)
)
response.raise_for_status()
data = response.json()
if data.get("code") != 0:
raise RuntimeError(f"API error {data.get('code')}: {data.get('message')}")
return data.get("data", [])
def get_constituents_at_date(index_symbol: str,
query_date: datetime) -> list:
"""
Reconstruct the constituent list as it existed on a
specific historical date. This is essential for:
1. Point-in-time index replication backtests
2. Event studies that need to identify which stocks
were in the index at the time of a corporate event
3. Attribution analysis separating selection effect
from timing effect around rebalances
"""
timeline = get_constituent_timeline(index_symbol)
query_ts = int(query_date.timestamp() * 1000)
active_constituents = None
effective_date = None
# Walk through timeline to find the right universe
for event in sorted(timeline, key=lambda e: e["effective_date"]):
if event["effective_date"] <= query_ts:
active_constituents = event.get("current_constituents", [])
effective_date = event["effective_date"]
else:
break
return {
"index": index_symbol,
"query_date": query_date.isoformat(),
"effective_date_ts": effective_date,
"constituents": active_constituents or [],
"constituent_count": len(active_constituents or [])
}
# Example: Reconstruct S&P 500 as of January 2018 — before the
# FAANG concentration that dominated 2019-2023
if __name__ == "__main__":
query_date = datetime(2018, 1, 15, tzinfo=timezone.utc)
constituents_2018 = get_constituents_at_date("SPX.US", query_date)
print(f"S&P 500 constituent list as of {query_date.date()}:")
print(f" Total constituents: {constituents_2018['constituent_count']}")
print(f" Effective from: "
f"{datetime.fromtimestamp(constituents_2018['effective_date_ts']/1000, tz=timezone.utc).date()}")
# Identify stocks that were in the index in 2018 but NOT in 2025
current = get_constituents_at_date("SPX.US", datetime.now(timezone.utc))
removed_stocks = set(constituents_2018['constituents']) - set(current['constituents'])
added_stocks = set(current['constituents']) - set(constituents_2018['constituents'])
print(f"\n Stocks removed since 2018: {len(removed_stocks)}")
print(f" Stocks added since 2018: {len(added_stocks)}")
4.3 Index Replication Backtesting: A Practical Example
An index replication strategy that holds the top-50 constituents by market cap, rebalanced quarterly. The naive approach — using the current top-50 at every rebalance date — would produce a backtest that looks better than reality because it incorporates future knowledge: you know in 2020 which stocks would survive to 2025.
PIT-correct backtest methodology:
- At each rebalance date, query
get_constituents_at_datefor the index universe at that moment. - Apply the selection rule (e.g., top-50 by market cap) to that historical universe.
- Compute returns using historical price data for those symbols.
- Compare against the actual index value published at that time.
def pit_index_replication_backtest(
index_symbol: str,
start_date: datetime,
end_date: datetime,
rebalance_frequency_days: int = 90,
selection_top_n: int = 50
) -> dict:
"""
Run a point-in-time correct index replication backtest.
This method:
- Uses the constituent universe that existed at each
rebalance date (not the current universe)
- Applies selection logic using only information available
at that date
- Computes returns using historical price data
- Returns a performance report compatible with
backtest disclosure standards (Sharpe, max drawdown, etc.)
"""
timeline = get_constituent_timeline(index_symbol)
rebalance_dates = generate_rebalance_schedule(
start_date, end_date, rebalance_frequency_days
)
portfolio = {} # symbol -> weight
cumulative_return = 1.0
daily_returns = []
equity_curve = [1.0]
for rebal_date in rebalance_dates:
# Get the universe as it existed on this date
pit_universe = get_constituents_at_date(index_symbol, rebal_date)
constituents = pit_universe["constituents"]
# Select top-N by market cap using historical data
top_holdings = select_top_by_market_cap(
symbols=constituents,
date=rebal_date,
top_n=selection_top_n
)
# Equal-weight portfolio
weight_per_holding = 1.0 / len(top_holdings)
portfolio = {s: weight_per_holding for s in top_holdings}
# Compute period return (simplified — no transaction costs)
period_start = rebal_date
period_end = get_next_rebalance_date(rebal_date, rebalance_frequency_days)
period_return = compute_portfolio_return(
portfolio, period_start, period_end
)
cumulative_return *= (1 + period_return)
daily_returns.append(period_return)
equity_curve.append(cumulative_return)
return {
"cumulative_return": cumulative_return - 1,
"annualized_return": annualized_return(daily_returns),
"sharpe_ratio": compute_sharpe(daily_returns),
"max_drawdown": compute_max_drawdown(equity_curve),
"rebalance_count": len(rebalance_dates),
"benchmark": index_symbol
}
Engineering warning: The above is a skeleton. Production implementations must handle survivorship bias (stocks that went to zero between rebalance dates), corporate action adjustments, transaction costs, and slippage. The PIT constituent logic eliminates one source of lookahead bias, but it does not eliminate all of them.
5. Comparison: How Major Data Vendors Handle These Edge Cases
The following table compares TickDB's approach to edge case data handling against typical market data vendors.
| Edge case | TickDB approach | Common vendor approach |
|---|---|---|
| Trading halt candles | Zero-volume candle with explicit state: halted flag |
Drop the period; or fill with last price (phantom volume) |
| Delisted securities | Full historical archive, accessible via same API | Purge from database after N months; or require separate "historical" tier |
| Symbol changes | Symbol mapping table with effective dates; stitching API | Broken history; require manual mapping in spreadsheets |
| Constituent changes | Point-in-time constituent timeline per index | Static current constituent list; no historical reconstitution data |
| Suspended securities | state: suspended metadata flag; real-time feed unavailable |
May return stale last trade price as if active |
6. Practical Deployment Guide
| User type | Recommended approach |
|---|---|
| Individual quant researcher | Use the symbol history mapping for all securities with ticker changes. Always check the state field in candle responses before computing strategy signals. |
| Quant fund / team | Implement a pre-backtest validation pipeline that: (a) identifies halt periods via the state field, (b) verifies all symbols in the universe existed at each historical date, (c) reconstructs index universes via the constituent timeline API. |
| Index strategy practitioner | Use get_constituents_at_date for all event studies and reconstitution analysis. Store the constituent timeline locally and update it quarterly from the API. |
7. Closing
Data completeness is not a feature — it is the foundation. A backtest run on incomplete data does not produce a strategy; it produces a mirage that survives until live deployment, at which point the gaps in the data become gaps in the P&L.
TickDB's approach to trading halts, delistings, and constituent changes follows a consistent principle: encode the market state explicitly in the data, preserve historical records permanently, and make point-in-time reconstruction a first-class API capability rather than a post-hoc workaround.
For quant researchers, this means cleaner backtests with fewer spurious signals. For systematic funds, it means a defensible data foundation that survives regulatory scrutiny. For anyone building on market data: the question is never whether you can get the data. The question is whether the data you have is the data that existed.
Next Steps
If you're building a backtesting pipeline and need delisted securities or PIT constituent data, sign up at tickdb.ai to access the full historical archive and constituent timeline API.
If you want to see the halt-state flags and delisted symbol queries in action, generate an API key in the dashboard and use the code examples in this article as starting templates.
If you're working on index replication or event studies, the constituent timeline API is available on all paid plans. Reach out to enterprise@tickdb.ai for institutional data access.
If you use AI coding assistants, search for and install the tickdb-market-data SKILL in your AI tool's marketplace to get TickDB API integration directly in your development workflow.
This article does not constitute investment advice. Markets involve risk; past performance does not guarantee future results. Backtest results are hypothetical and subject to limitations including slippage estimation, survivorship bias, and limited sample sizes.