We love Pine Script & TradingView. But visual charts cap your data.

No Data = No Edge

TradingView limits you to ~25k bars—that's only 3 months of 5-minute data. Not enough to find real patterns. QuantQuack analyzes years of data with no limits, then export to Pine Script and run on TradingView. Find statistical edges that limited data can't reveal.

📝 Example question:

"What's the historical probability of breakouts in London session?"

⚙️ DuckScript (Pine-like) that answers it—or let AI generate it from your question (at launch):

input threshold = 0.5

breakout = high > high[1] * (1 + threshold)

stats by session:
  count(breakout) as total_breakouts
  percent(breakout) as probability

output stats

📊 Results (from 2.8M candles, analyzed in 2.3 seconds):

Session    | Breakouts | Probability | Dataset
-----------|-----------|-------------|----------
asia       | 124,503   | 32.1%       | NQ 5min
london     | 198,742   | 38.4%       | NQ 5min
new_york   | 251,892   | 41.2%       | NQ 5min

TradingView can't do this. We can.

Get Beta Access →See Features

What is QuantQuack? (and who is it for?)

What it is:

QuantQuack is a batch analysis platform for historical market data.

Think TradingView, but built for analyzing years of historical data instead of real-time charting. Upload your data, run DuckScript (Pine-like) or use pre-built reports, and get statistical insights from complete historical datasets.

No data limits. No artificial restrictions. Just upload, analyze, get results.

Who it's for:

✅ For:

📈 Traders who want to find patterns in years of data
🔄 Traders validating strategies across multiple market cycles
⏰ Traders looking for session-based edges
📊 Traders who need statistical insights, not just charts
💪 Anyone who wants to trade with data-backed confidence

❌ Not for:

📺 Real-time charting (use TradingView)
📉 Visual technical analysis (use TradingView)
⚡ Day trading signals (use TradingView)

If you need to analyze 5 years of data (2.8M+ candles) to find historical patterns, TradingView can't. We can.

The Trader's Pain: You Can't Find Statistical Edge with Limited Data

The Real Problem

📊You need years of data to find statistical edge, but TradingView caps you at ~25k bars. That's only ~3 months of 5-minute data.
🔄You can't validate strategies over multiple market cycles. Without enough data, you're trading blind.
🔍You can't find session patterns or seasonal edges. Limited data = limited insights.
🎲You're making decisions based on incomplete information. That's not trading—that's gambling.

TradingView Limitations

🚫 Max bars: ~25,000-40,000 (hard limit)
❌ Batch analysis: Not possible
📉 Session stats: Limited/None
📤 Export: CSV only, limited rows
⚠️ Determinism: Partial (depends on data source)
🐌 Performance: Slow on large datasets

Other Tools:

Need to be a programmer level "NASA engineer". Or level "I can build a rocket in my garage" to set up your own stack.

We do the coding. You do the trading. Easy.

To find statistical edge, you need complete historical data. TradingView can't give you that. We can.

Find Statistical Edge: Complete Data, Rigorous Analysis

🎯

Find Statistical Edge

Analyze years of data to discover real patterns. Validate strategies across multiple market cycles. Find session edges, seasonal patterns, and statistical advantages that limited data can't reveal.

⚡

Unlimited Data, Fast Analysis

Process datasets of any size—we've tested with 10M+ candles. No artificial restrictions. Ever. Analyze millions of candles in seconds. 2.8M candles analyzed in 2.3 seconds.

✅

Deterministic & Reproducible

Same script + same data = same results. Always. No surprises. DuckDB-powered batch processing; export JSON, CSV, Parquet, or Pine Script to run on TradingView.

🤖

AI-Powered Insights

AI generates scripts from natural language, explains results, detects patterns, and suggests next analyses. Available at launch.

📈

Backtesting + Statistical Analysis

Simulate real strategy execution with multi-timeframe support AND perform deep statistical analysis. Generate signals in 5min, execute in 1min. Calculate probabilities, session statistics, and patterns across years of data. No 2M bar limit, no Premium subscription. Unlike TradingView, we do both: strategy backtesting AND statistical analysis.

Pre-Built Reports & Quality Analysis

Production-ready reports with rigorous quality analysis. Real insights from traders using QuantQuack. See what's possible with unlimited historical data.

📈

NQ Futures: Session Breakout Analysis

Analyzed 2.8M candles across 3 sessions. Found 38.4% breakout probability in London session.

2.8M candles • 3 sessions • 5 years

by @trader_juan

FuturesSession AnalysisBreakouts

View in app →

📈

ES Session Volatility Patterns

Comprehensive volatility analysis by session. Discovered consistent patterns in NY session.

1.5M candles • Volatility analysis • 3 years

by @quant_dev

VolatilityES FuturesPatterns

View in app →

📈

Forex: London vs NY Session Comparison

Compared EUR/USD patterns across sessions. Found significant differences in breakout behavior.

3.2M candles • EUR/USD • 7 years

by @fx_researcher

ForexSession ComparisonEUR/USD

View in app →

Custom Built Reports

Your strategies, built into actionable insights. With custom report requests, we transform your trading ideas into rigorous analysis, so you can trade with data-backed confidence.

Build Custom Report See Features

Share your analysis with the community

Browse in app

How it works

Simple. Fast. Powerful. Three steps to find your edge.

📤

Upload Your Data

Upload CSV or Parquet from TradingView, NinjaTrader, or any broker. Or pull data via the CLI from FMP, Polygon, or Databento. No bar limits—upload as much history as you have.

Example (CLI):

quantquack dataset upload NQ_5min.parquet -n "NQ 5min"

quantquack providers configure fmp --api-key "..."

Drag and drop in the app, or use the CLI. Your choice.

💬

Request Your Analysis

Write a DuckScript (Pine-like syntax) or use pre-built reports. Full control: stats by session, probabilities, backtesting. Same script + same data = same results every time.

DSL Guide (DuckScript): syntax, functions, and examples →

📊

Get Your Results

Receive statistical insights, probabilities, and patterns. Download your complete results. Use the insights to trade with confidence.

Example Results:

London Session: 38.4% breakout probability

New York Session: 41.2% breakout probability

Based on 2.8M candles over 5 years

Real numbers (not marketing fluff)

Performance Benchmarks

Dataset:NQ Futures 5min

Size:2,847,392 candles

Analysis time:2.3 seconds

Memory usage:128 MB

Export time:0.8 seconds

Current Beta Stats

Beta users:Growing (beta)

Total analyses:1,203

Candles processed:847M

Avg analysis time:3.2s

Uptime:99.7% (last 30 days)

Built with: DuckDB • Parquet • TypeScript • PostgreSQL

Open source components: GitHub

Real use cases (with actual code and results)

Case 1: Session Probabilities

📝 Example question:

"What's the historical probability of breakouts in London session?"

⚙️ DuckScript (Pine-like):

input threshold = 0.5

breakout = high > high[1] * (1 + threshold)

stats by session:
  count(breakout) as total_breakouts
  percent(breakout) as probability

output stats

📊 Results (from 2.8M candles):

Session    | Breakouts | Probability | Dataset
-----------|-----------|-------------|----------
asia       | 124,503   | 32.1%       | NQ 5min
london     | 198,742   | 38.4%       | NQ 5min
new_york   | 251,892   | 41.2%       | NQ 5min

TradingView can't do this. We can.

Case 2: Advanced Pattern Analysis

📝 Example question:

"Find patterns in volatility by day of week."

⚙️ DuckScript (weekday(date)):

atr14 = atr(14)
volatility = atr14 / close

stats by weekday(date):
  avg(volatility) as avg_volatility
  max(volatility) as max_volatility
  min(volatility) as min_volatility

output stats

📊 Results:

Weekday(0=Sun) | Avg Volatility | Max Volatility
---------------|----------------|---------------
0              | 0.0234         | 0.0456
1              | 0.0218         | 0.0421
2              | 0.0192         | 0.0389
3              | 0.0221         | 0.0432
4              | 0.0256         | 0.0487
5              | 0.0201         | 0.0412
6              | 0.0189         | 0.0398

Case 3: Export & Integration

📝 Use case:

Export results as Parquet or CSV and continue analysis in Python, Excel, or your stack.

📤 Export formats:

JSON, CSV, Parquet, and Pine Script. Export DuckScript to Pine Script and run on TradingView. Download from the app or via CLI (--format csv --output results.csv).

# Example: load exported Parquet in Python
import pandas as pd
df = pd.read_parquet('quantquack_results.parquet')
df.groupby('session')['breakout'].mean()

Same deterministic results. Use in Excel, Python, or any tool you prefer.

Case 4: Candle-by-Candle Backtesting with Multi-Timeframe

📝 Example:

Backtest golden cross: signals on 5min, execution on 1min with SL/TP. Multi-timeframe supported.

⚙️ DuckScript (signals + levels):

input fast_ma = 12
input slow_ma = 26
input atr_period = 14
input stop_multiplier = 2.0
input target_multiplier = 3.0

ma_fast = sma(close, fast_ma)
ma_slow = sma(close, slow_ma)
atr14 = atr(atr_period)

signal entry = crossover(ma_fast, ma_slow)
signal exit = crossunder(ma_fast, ma_slow)

stop_loss_level = close - (atr14 * stop_multiplier)
take_profit_level = close + (atr14 * target_multiplier)

output table

📋 Strategy Configuration:

Setting	Value
Entry Signals (Long)	entry
Entry Signals (Short)	—
Exit Signals (Long)	exit
Stop Loss Source	stop_loss_level (from script)
Take Profit Source	take_profit_level (from script)

📊 Backtest Results:

Total Trades:     342
Win Rate:         58.2%
Profit Factor:     1.87
Total Return:      +24.3%
Max Drawdown:      -8.1%
Sharpe Ratio:      1.42

Signal Timeframe:  5min (clean signals)
Execution:         1min (precise entry/exit)
SL/TP Checked:     Every 1min candle

✨ Key Advantages: Multi-timeframe analysis (signals in 5min, execution in 1min), real-time SL/TP evaluation, candle-by-candle simulation. No 2M bar limit, no Premium subscription required, flexible configuration via intuitive UI.

QuantQuack vs TradingView / Pine Script

Direct comparison. No marketing fluff. Just facts.

Feature	TradingView	QuantQuack
Max bars	25,000	Unlimited
Batch analysis	❌	✅
Session statistics	Limited (only with strategies, no deep analysis)	Full (stats by session, probabilities)
Export formats	CSV only	CSV/JSON/Parquet + Pine Script
Export to Pine Script	N/A (native)	✅ (DuckScript → Pine Script)
Determinism	Partial	Total
Performance (1M candles)	~30s	~2s
Self-hostable	❌	✅
Open source	❌	✅ (partial)
AI Assistant	❌	✅ (at launch)
Candle-by-candle backtesting	✅ (only strategies, requires Premium for deep)	✅ (strategies + statistical analysis)
Deep backtesting limit	2M bars, 1M trades (Premium, only strategies)	Unlimited (strategies + stats)
Deep statistical analysis	❌ (only strategies, no general statistics)	✅ (stats by session, probabilities, etc.)
Multi-timeframe execution	✅ (with security() in Pine Script)	✅ (flexible configuration with metadata)

TradingView is great for real-time charting. We're built for historical batch analysis. Different tools for different jobs.

AI-Powered Analysis

Let AI help you discover patterns and understand your results.

Script Generation

Describe your analysis in plain English. AI generates the code for you.

You: "Find breakouts in London session"
AI: Generates script automatically

Results Explanation

Get plain-language explanations of your statistical results. Understand what the data means.

“London session shows 38.4% breakout probability, significantly higher than Asia (32.1%). This suggests…”

Pattern Detection

AI automatically detects patterns in your historical data. Find hidden insights.

• Detected: Higher volatility in first hour of NY session
• Pattern: Breakouts more likely after consolidation periods

Analysis Suggestions

Based on your results, AI suggests next analyses to run. Explore deeper.

“Consider analyzing volatility by day of week”
“Try comparing pre-market vs regular session patterns”

AI integration is real. Script generation and explanations ready at launch.

Bring your data

Upload CSV or Parquet, or pull data via CLI from FMP, Polygon, or Databento. Choose your market below; more broker and plugin integrations are coming soon.

CME, ICE, Eurex futures data. NQ, ES, CL, GC, and more.

📊

Upload CSV

Export from TradingView, NinjaTrader, or any platform. We support CME, ICE, Eurex formats.

# Upload futures CSV
quantquack dataset upload NQ_futures_5min.csv

# Or Parquet (faster)
quantquack dataset upload NQ_futures_5min.parquet

📈

TradingView Export

Export futures data from TradingView and import to QuantQuack.

# Export from TradingView
# Then upload
quantquack dataset upload tradingview_futures_export.csv

🔌

NinjaTrader Plugin

Coming soon

Connect directly from NinjaTrader. Export CME, ICE, Eurex data automatically.

# Install NinjaTrader plugin
# Export → QuantQuack → Auto-upload

🔗

Broker API (IBKR, CQG)

Coming soon

Connect to Interactive Brokers, CQG, or other futures brokers via API.

# Connect to broker API
quantquack connect --broker ibkr
quantquack sync --symbol NQ --interval 5min

Get Started with Futures

Pricing (beta phase)

Beta Access

• Unlimited datasets
• Unlimited candles
• All export formats (JSON, CSV, Parquet, Pine Script)
• Full API access
• Community support

Note: Beta phase. Pricing TBD for v1.0

We're in beta. Help us build it better.
When we launch v1.0, early users get grandfathered pricing.

Frequently Asked Questions

What is QuantQuack exactly?

A batch analysis platform for historical market data. You upload datasets, write analysis scripts, get statistical results. Optimized for historical research, not real-time charting.

Who should use QuantQuack?

Quantitative traders doing historical research, quants validating strategies, traders calculating session probabilities, developers needing batch analysis. Not for real-time charting (use TradingView for that).

Is it compatible with Pine Script?

Yes. Our DuckScript is Pine-like syntax, so you'll feel at home. We also export to Pine Script: write once in QuantQuack, export, and run the same logic on TradingView for charts or reuse.

What data formats do you support?

CSV and Parquet (Parquet recommended for speed). CLI and providers (FMP, Polygon, Databento) for data sync. More broker integrations coming soon.

Is my data secure?

Enterprise-grade encryption. Data processed server-side, never stored permanently. S3-compatible storage with access controls. We don't train AI on your data.

What's the pricing?

Beta access is free during development. We'll announce pricing before launch. No hidden fees, transparent usage limits.

Can I export my results?

Yes! JSON, CSV, Parquet, and Pine Script. Export your DuckScript to Pine Script and run it on TradingView. Direct database connections coming soon.

What's the performance like?

Fast. DuckDB engine processes millions of rows in seconds. Batch processing means you can analyze entire histories instantly.

Is there AI support?

Yes. At launch, AI generates DuckScript from natural language, explains results, and suggests next analyses. No need to learn syntax first—describe what you want and get scripts and insights.

Ready to try it?

Analyze years of data. No bar limits. Get statistical edge with complete historical datasets.

Get Beta Access →Read DSL Guide (DuckScript)

CLI & open source components available for self-hosting.