Price doesn’t tell
the whole story.

See the activity behind the price. Track large trades, buying and selling pressure, and the levels where volume concentrates.
Futures order flow indicators, computed for you and delivered to your tools through one API.

No credit card required. Includes a 10-minute delayed stream and 7 days of history.

Market explorer DEMOFATHOM / NQ
NQZ6Nasdaq-100 futures
Loading the session… buy sell

THE MARKET MOVES. YOUR TOOLS FOLLOW.

We compute your indicators and push them over WebSocket. No polling: the stream comes to you.
  1. ComputationServer-side, on every trade
  2. WebSocket APIPushed in real time
  3. Your toolsInstant update
messages replayed
0
Fathom Trades ≥ 20
0
contracts traded
0
demo
real session, replayed

Real trades, read by Fathom.

Less noise.
More context.

Not every trade matters. Move the Fathom Trades threshold to keep only the biggest ones. The chart follows, and so does your API request.

50
big trades kept
—
per hour (projected)
—
total contracts
—
data received (bytes)
—
FATHOM TRADES / 25 MIN≥ 50 CONTRACTS

Buy Sell · size = volume · grey dots = below the threshold

The same setting, on the API side
{
  "t": "subscribe",
  "sub": "bt",
  "instrument": "NQ.front",
  "indicator": "big-trades",
  "params": {
    "minimum": 50
  },
  "mode": "confirmed",
  "from": "live"
}

Build your tools.
We compute the order flow.

Add order flow to your charts and research without building the indicator engine. Our API delivers computed results, while SDKs for TypeScript, Python, C# and Rust handle reconnection and resume the stream where it left off.

  • wss Your indicators in real time, over a single connection
  • REST The same computations on historical data
  • NDJSON Compressed exports for your backtests
Connect my first stream
stream.ts
import { FathomChartsStream } from '@fathom-charts/sdk';
import type { BigTradesData } from './fathom-charts-types.js';

const stream = new FathomChartsStream({
  url: 'wss://stream.fathomcharts.com/v1',
  apiKey: process.env.FATHOM_CHARTS_API_KEY!,
});

const bigTrades = stream.subscribe<BigTradesData>({
  instrument: 'NQ.front',
  indicator: 'big-trades',
  params: { minimum: 30 },
  mode: 'confirmed',
});

for await (const event of bigTrades) {
  if (event.type === 'upsert') {
    console.log(event.data.side, event.data.volume, event.data.price);
  }
}
stream.py
async with FathomChartsStream(url="wss://stream.fathomcharts.com/v1", api_key=os.environ["FATHOM_CHARTS_API_KEY"]) as stream:
    big_trades: Subscription[BigTradesData]
    async with stream.subscribe(
        instrument="NQ.front",
        indicator="big-trades",
        params={"minimum": 30},
        mode="confirmed",
    ) as big_trades:
        async for event in big_trades:
            if isinstance(event, Upsert):
                print(event.data["side"], event.data["volume"], event.data["price"])
Program.cs
await using var stream = new FathomChartsStream(new StreamOptions
{
    Url = "wss://stream.fathomcharts.com/v1",
    ApiKey = Environment.GetEnvironmentVariable("FATHOM_CHARTS_API_KEY"),
});

var bigTrades = stream.Subscribe<BigTradesData>(new SubscribeOptions
{
    Instrument = "NQ.front",
    Indicator = IndicatorIds.BigTrades,
    Params = new BigTradesParams { Minimum = 30 },
    Mode = Mode.Confirmed,
});

await foreach (var e in bigTrades)
{
    if (e is Upsert<BigTradesData> upsert)
        Console.WriteLine($"{upsert.Data.Side} {upsert.Data.Volume} {upsert.Data.Price}");
}
main.rs
let stream = FathomChartsStream::builder("wss://stream.fathomcharts.com/v1")
    .api_key(std::env::var("FATHOM_CHARTS_API_KEY").map_err(|_| "FATHOM_CHARTS_API_KEY is not set")?)
    .build()?;

let mut big_trades = stream.subscribe::<BigTradesData>(
    SubscribeOptions::new("NQ.front", "big-trades")
        .params(json!({ "minimum": 30 }))
        .mode(Mode::Confirmed),
)?;

while let Some(event) = big_trades.next().await {
    if let StreamEvent::Upsert(upsert) = event? {
        println!("{:?} {} {}", upsert.data.side, upsert.data.volume, upsert.data.price);
    }
}

Already on TradingView?
Draw Fathom on your chart.

A Chrome extension draws Fathom indicators directly on your TradingView futures charts. No code: paste your API key, tick the indicators, open your chart.

  • All 10 Fathom indicators, from the footprint to the opening range
  • Follows your symbol, interval and scroll
  • Real time with a Live plan, 10-minute delay on the free Sandbox
Available on the Chrome Web StoreSee the extension
One-minute NQ1! chart on TradingView with Fathom Footprint ladders between the bars and Fathom Trades circles, drawn by the Fathom Charts extension.

Start for free.
Go real time whenever you want.

Start with the free Sandbox, no credit card required. Add real-time streaming, historical data, or both when you’re ready. Save with yearly Live billing or the bundle.

Scroll the table to see all four plans

Fathom Charts plans and the limits enforced by the API
YOUR ACCESS

One engine.
At your pace.

01

Sandbox

FreeNo credit card needed

Your first integration, no commitment.

02

Live

Monthly or yearly subscription

Your indicators in real time, in your tools.

03

Historical

One-time purchase, lifetime access

Backtest with the full available history, including future additions.

04

Live + Historical

One-time purchase: Historical for life and 12 months of Live

Research and stream with one purchase: lifetime Historical access and 12 months of Live.

Create my free account Subscribe to Live Buy Historical Buy the bundle
WebSocket streamIndicators are pushed to you continuously over a WebSocket connection. When delayed, everything arrives that far behind the market.10-min delayReal time10-min delayReal time
Concurrent connectionsHow many WebSocket connections your account can keep open at the same time, across all your keys. One connection can carry many subscriptions.1515
Concurrent subscriptionsA subscription is one indicator followed on one instrument. This counts all your subscriptions active at the same time, across all your connections and keys.250250
Custom configurationsAn indicator used on an instrument with parameters other than its defaults on that ticker, for example Fathom Trades with a minimum volume other than the current default of its ticker. Each combination counts once, however many subscriptions use it.125125
Historical APIHow far back you can go: REST queries, exports and subscriptions that start in the past. The full history goes back to around 2011, depending on the instrument, and includes every history added later.Last 7 daysLast 7 days, unlimitedFull available historyFull available history
Compute budget per monthWhat you can spend on history each month: queries, exports and subscriptions that start in the past. Each trade in the requested range costs 1 compute unit, whatever the indicator; a full NQ trading day holds roughly 300,000 to 1 million trades. Real time costs nothing, and with Live, ranges that start within the last 7 days cost nothing either.50 million compute unitsUnlimited on the last 7 days20 billion compute units20 billion compute units
Exports per monthHow much your exports can download each month, measured compressed, as you receive it. It comes on top of the compute budget: an export uses both.Not includedNot included20 GiB20 GiB
REST requests per minuteCalls to the REST API per minute, across all the keys of your account. Beyond that, requests are refused with 429.603001,2001,200

Before you
get started.

Do I need to write code to use Fathom?

Fathom is an API for integrating computed order flow into your own tools. You need to write code or use an integration built for Fathom. Our SDKs for TypeScript, Python, C# and Rust help you get started; the charts on this page demonstrate the indicators.

Where does the data come from?

Our indicators are computed from market trades. If the source is delayed or down, the stream tells you: no data is ever made up or filled in.

How can I try it for free?

Create an account with your email address: you start on the Sandbox, no credit card needed. 10-minute delayed stream, 7 days of history, the same computations as in real time. When you move to Live, the same keys switch to real time: your code stays the same.

How does payment work?

Choose a monthly or yearly Live subscription, a one-time Historical purchase with lifetime access (for as long as we operate the historical API), or a bundle with lifetime Historical access and 12 months of Live. Prices are in euros including tax in metropolitan France, the rest of Europe and the French overseas territories that use the euro, in US dollars before tax elsewhere. Payment details are covered in Plans and billing.

Can I redistribute the live or historical data?

No. Live and historical data alike are derived from market data: they are for the account holder only, under the market data license terms included in our terms of use. Any distribution to third parties (public app, resale, display to your clients) requires a specific license agreement.

Does historical data match the real-time stream?

Yes, for the same parameters. Both use the same trades and the same computation engine, and we compare results field by field on real sessions. Default values are updated per ticker over time: pass your parameters explicitly to keep results identical. If a period is not covered, the API responds with NOT_COVERED instead of returning partial data.

Which instruments are covered?

The futures streamed by the service, listed with their tick size by GET /v1/instruments. An alias such as NQ.front follows the active contract and switches at rollover, announced by a reset message.

What if my app can't keep up with the live stream?

The API merges pending provisional updates and never drops a final result. If your app stays stuck, the connection is closed and you resume from the last cursor received. Thresholds and resumption are covered in the WebSocket protocol.

Does Fathom Charts place orders?

No. Fathom Charts provides indicators to feed your analysis: it does not connect to your broker, never places orders and gives no investment advice.

Look beyond
the candles.

Bring order flow into your own charts, research and backtests.
Start with the free Sandbox. Add real time when you’re ready.