Tick Data vs Bar Data

Every exchange emits a firehose of events: this trade happened at this price and size at this microsecond, this quote moved, this order was cancelled. A strategy that traded on the S&P 500 futures book for a single day would see millions of these events. Almost nothing downstream — a backtest, a chart, a signal computed on a laptop — can consume that volume directly, so the industry compresses it. Tick data is the raw event stream; bar data is that stream summarised into fixed chunks, most commonly the familiar open/high/low/close (OHLC) candle.

What each actually contains

A tick record is one row per event: timestamp, price, size, and (for quotes) bid/ask levels. Nothing is thrown away — if a stock trades 40 times in one second, tick data has 40 rows for that second.

A bar takes a window — classically a fixed clock interval like one minute — and reduces every tick inside it to a handful of numbers: the first price (open), highest price (high), lowest price (low), last price (close), and total volume. A day of one-minute bars for a liquid stock is under 400 rows; the tick data behind it can be hundreds of thousands.

That compression is lossy, and what it loses is exactly the thing microstructure researchers care about: the order and spacing of trades inside the bar. A one-minute bar showing open 100, high 101, low 99, close 100 could be one calm walk up and back, or it could be a violent 99→101 spike compressed into two seconds followed by 58 seconds of silence — the bar looks identical either way.

Worked example: reconstructing a bar from ticks

Ticks for one symbol between 09:30:00 and 09:31:00 (price, size):

09:30:03  100.10  200
09:30:19  100.35  100
09:30:22   99.90  500
09:30:41  100.05  300
09:30:58  100.20  150

Building the one-minute bar: open = first tick's price = 100.10. high = max of all prices = 100.35. low = min of all prices = 99.90. close = last tick's price = 100.20. volume = sum of sizes = 200+100+500+300+150 = 1,250.

def make_bar(ticks):                 # ticks: list of (price, size), time-ordered
    prices = [p for p, _ in ticks]
    return {
        "open":  prices[0],
        "high":  max(prices),
        "low":   min(prices),
        "close": prices[-1],
        "volume": sum(s for _, s in ticks),
    }

Result: {open: 100.10, high: 100.35, low: 99.90, close: 100.20, volume: 1250} — five numbers standing in for five ticks, and in a liquid name, for thousands.

Where it shows up

Interview and take-home questions often ask you to reconstruct OHLC bars from a raw tick stream, or to build event-driven bars (dollar bars, volume bars) instead of time bars — a common follow-up, because fixed-clock bars sample more densely in quiet markets and more sparsely in active ones, which distorts statistical properties like volatility clustering. See Bar Construction Methods for the alternatives.

In production, feed handlers (Market Data Feed Handlers) ingest raw tick and quote data (Trade and Quote (TAQ) Data) and a downstream bar-builder service compresses it for anything that doesn't need tick resolution — dashboards, EOD reporting, most factor research. Storage teams keep raw ticks compressed and partitioned by day (see Market Data Compression) precisely because reprocessing history at tick granularity is expensive, so the bar layer exists as a cheap, queryable summary that most consumers never need to bypass.