How Block Trades Print on the Tape

Block trades print on the tape like every other trade, with two differences a data user notices right away. A negotiated block is reported through a FINRA facility rather than an exchange, and it reaches the public tape after the execution it describes, sometimes by whole seconds. This page covers that print in US stocks, not the cryptocurrency exchange that shares part of the name. For the trade itself, start with what a block trade is.

Where block trades print on the tape

Every US equity trade reaches the consolidated tape through a reporting venue. An exchange reports the trades it matches itself. A trade arranged away from an exchange, on an upstairs desk or inside an alternative trading system, is reported instead to a FINRA trade reporting facility: one of the two TRFs that FINRA operates jointly with Nasdaq and NYSE, or the Alternative Display Facility. The print carries that facility as its venue, never the name of the desk or the dark pool where the two sides met. Off-exchange identity on the public tape stops at "reported through FINRA".

The venue field is a blunt instrument for finding blocks. It separates on-exchange from off-exchange, and nothing finer. The panel below counts, for one liquid name across one session, how many prints of 10,000 shares or more each reporting venue carried, next to the average size of everything that venue reported.

SELECT
    if(venue_name = '', concat('Venue ', toString(venue_id)), venue_name) AS venue,
    prints_10k_plus,
    avg_shares_per_print
FROM
(
    SELECT
        toInt32(exchange)               AS venue_id,
        countIf(size >= 10000)          AS prints_10k_plus,
        round(avg(toFloat64(size)), 0)  AS avg_shares_per_print
    FROM global_markets.stocks_trades
    WHERE ticker = 'AAPL'
      AND sip_timestamp >= toDateTime('2026-06-10 00:00:00', 'UTC')
      AND sip_timestamp <  toDateTime('2026-06-11 00:00:00', 'UTC')
    GROUP BY venue_id
) AS v
LEFT JOIN
(
    SELECT
        toInt32(id) AS venue_id,
        any(name)   AS venue_name
    FROM global_markets.stocks_exchanges
    GROUP BY venue_id
) AS e USING (venue_id)
ORDER BY prints_10k_plus DESC
LIMIT 12

Ranked by prints of 10,000 shares or more, FINRA Alternative Display Facility led that session with 64 of them, at an average of 47 shares across every print it carried. The average column separates a venue that moves size in tiny slices from one that reports few prints of great size.

Why a block print can appear after the price has moved

The execution and the report are two events. An off-exchange trade must be reported as soon as practicable, inside a window measured in seconds, and the length of that window has been revised by rule more than once. The durable part is the shape: a window, not an instant. A negotiated trade also has to be written up before it can be sent, and quotes keep updating during the gap.

Every print carries two clocks. One timestamp comes from the reporting venue at execution, the other from the tape at dissemination. The distance between them is measurable one print at a time.

SELECT
    multiIf(size < 1000,  'under 1,000',
            size < 5000,  '1,000 to 4,999',
            size < 10000, '5,000 to 9,999',
                          '10,000 and up')                        AS print_size,
    round(quantileExact(0.99)(
        toFloat64(dateDiff('millisecond', participant_timestamp, sip_timestamp))
    ), 0)                                                         AS p99_lag_ms,
    round(100 * countIf(dateDiff('millisecond', participant_timestamp, sip_timestamp) >= 1000)
              / count(), 2)                                       AS over_1s_pct
FROM global_markets.stocks_trades
WHERE ticker = 'AAPL'
  AND sip_timestamp >= toDateTime('2026-06-10 00:00:00', 'UTC')
  AND sip_timestamp <  toDateTime('2026-06-11 00:00:00', 'UTC')
  AND participant_timestamp >= toDateTime('2026-06-10 00:00:00', 'UTC')
  AND participant_timestamp <= sip_timestamp
GROUP BY print_size
ORDER BY min(size)

For prints under 1,000 shares, the slowest one percent took at least 1434 milliseconds to travel from execution to tape, and 1.17% crossed the one-second line. For prints of 10,000 shares or more, those two measures read 1843 milliseconds and 1.14%. The useful reading is the shape down the buckets rather than any single row.

How to tell a block print from an ordinary print

Four signals, read together:

• Size. The first hint, and the weakest alone, since one large order is usually sliced into hundreds of ordinary-looking prints.
• Venue. Off-exchange reporting narrows the field without naming a counterparty.
• Sale conditions. Every print carries codes describing how it was priced and how it reached the tape.
• The timestamp gap. A print disseminated well after its execution was reported late by rule, not by accident.

Condition codes are the part most data users skip. The dictionary is public, and the entries that matter here describe a price or an ordering detached from the moment of the print.

SELECT
    name              AS condition_name,
    any(abbreviation) AS code,
    any(type)         AS code_type,
    arrayStringConcat(
        arrayMap(x -> toString(x), arraySort(groupUniqArray(toInt32(id)))), ', ') AS condition_ids
FROM global_markets.stocks_condition_codes
WHERE name ILIKE '%sold%'
   OR name ILIKE '%prior reference%'
   OR name ILIKE '%average price%'
   OR name ILIKE '%derivatively%'
   OR name ILIKE '%contingent%'
   OR name ILIKE '%cross%'
GROUP BY name
ORDER BY condition_name
LIMIT 20

Those 17 entries are the vocabulary. Prior Reference Price marks a print priced from an earlier quote. Sold Out of Sequence marks one that reached the tape outside the order in which it happened. Average Price Trade marks a print whose price is the average of many executions, a level that may never have traded anywhere. Most market data conventions leave these out of the high, the low, and the last price while still counting their shares in volume. The full map from code to meaning lives in trade condition codes.

Size alone is the weakest of the four, and one session's distribution makes the point.

WITH
    (
        SELECT count()
        FROM global_markets.stocks_trades
        WHERE ticker = 'AAPL'
          AND sip_timestamp >= toDateTime('2026-06-10 00:00:00', 'UTC')
          AND sip_timestamp <  toDateTime('2026-06-11 00:00:00', 'UTC')
    ) AS day_prints,
    (
        SELECT sum(size)
        FROM global_markets.stocks_trades
        WHERE ticker = 'AAPL'
          AND sip_timestamp >= toDateTime('2026-06-10 00:00:00', 'UTC')
          AND sip_timestamp <  toDateTime('2026-06-11 00:00:00', 'UTC')
    ) AS day_shares
SELECT
    multiIf(size < 100,   'under 100',
            size < 1000,  '100 to 999',
            size < 5000,  '1,000 to 4,999',
            size < 10000, '5,000 to 9,999',
                          '10,000 and up')                        AS print_size,
    round(100 * toFloat64(count()) / toFloat64(day_prints), 2)    AS prints_pct,
    round(100 * toFloat64(sum(size)) / toFloat64(day_shares), 2)  AS volume_pct
FROM global_markets.stocks_trades
WHERE ticker = 'AAPL'
  AND sip_timestamp >= toDateTime('2026-06-10 00:00:00', 'UTC')
  AND sip_timestamp <  toDateTime('2026-06-11 00:00:00', 'UTC')
GROUP BY print_size
ORDER BY min(size)

Prints of fewer than 100 shares were 90.06% of that day's prints and 30.53% of its shares: the large majority of the print count, and under half the shares. Prints of 10,000 shares or more were 0.01% of prints and 36.27% of shares. Most prints sit in the smallest bucket while most of the shares sit above it, which is the problem with a size screen. Set the threshold high and it misses most of the shares an institution moved. Set it low and it fills with ordinary trading. A size screen also catches the opening and closing auction prints, which are exchange crosses rather than negotiated blocks.

The 10,000-share line in these panels is an analytical convention with a long history in market structure research. Regulatory and exchange definitions of a block use share and value tests of their own, and those have been revised over the years. Read any specific figure as a point-in-time rule.

What a block print does to an OHLCV bar

A bar is a bucket of prints, and how OHLCV bars are built covers the assembly. Two things follow for anyone building or consuming them.

First, a late print lands in a bar by whichever clock the builder chose. Group by dissemination time and a block executed at 10:29 sits in the 10:31 bar. Group by execution time and the 10:29 bar changes after it was published, so the same minute holds one value at 10:30 and a different one a minute later. Either choice is defensible. Mixing them inside one data set is not.

Second, the print can sit outside the bid and the ask at the moment it appears, and it adds volume with no matching quote activity. A negotiated block consumes no displayed liquidity, so a minute can carry a heavy volume bar with an unremarkable number of quote updates. A pipeline that discards trades outside the NBBO discards block prints along with them, and a high or low computed without filtering on sale conditions can be dragged to a price nobody could have traded at that minute.

SELECT
    formatDateTime(toTimeZone(minute, 'America/New_York'), '%H:%i') AS et_time,
    total_volume_k,
    block_volume_k,
    block_pct
FROM
(
    SELECT
        toStartOfMinute(sip_timestamp)                          AS minute,
        round(toFloat64(sum(size)) / 1000, 1)                   AS total_volume_k,
        round(toFloat64(sumIf(size, size >= 10000)) / 1000, 1)  AS block_volume_k,
        round(100 * toFloat64(sumIf(size, size >= 10000))
                  / toFloat64(sum(size)), 1)                    AS block_pct
    FROM global_markets.stocks_trades
    WHERE ticker = 'AAPL'
      AND sip_timestamp >= toDateTime('2026-06-10 19:00:00', 'UTC')
      AND sip_timestamp <  toDateTime('2026-06-10 20:00:00', 'UTC')
    GROUP BY minute
)
ORDER BY minute

In the last minute on that panel, 15:59 ET, the tape carried 924.6 thousand shares, of which 37.9 thousand arrived in prints of 10,000 shares or more, 4.1% of the minute. The block share line moves in steps rather than a curve. One print can account for a large slice of a minute, and a minute with no large print sits flat at zero.

FAQ

Do block trades show up on the public tape?

Yes. Every US equity trade is reported to the consolidated tape, including one negotiated privately between two institutions. What stays private is the identity of the parties and the specific off-exchange venue. The print names the FINRA reporting facility and stops there.

Why does a large trade appear on the tape after the price has already moved?

Execution and reporting are separate steps. An off-exchange trade is written up and reported inside a window measured in seconds, and the market keeps quoting during that gap. The print then shows a price belonging to an earlier moment, which is what the out-of-sequence and prior-reference-price conditions exist to mark.

Can a block trade print outside the bid and the ask?

Yes. A price agreed at one moment can sit outside the spread by the time the print is disseminated, and an average-price print carries a level that may never have been quoted. A pipeline that drops trades outside the NBBO will quietly drop a large share of block prints.

Do block prints count toward a stock's daily volume?

The shares count in volume. Whether the print updates the high, the low, or the last price depends on the sale conditions attached, and most vendors follow conventions that keep average-price and out-of-sequence prints out of the price fields while counting their shares.

How do I tell a block print from a sliced order?

From the tape alone, often you cannot. A block appears once, at one size and one price. A sliced order appears as many ordinary prints across minutes and venues, with no field linking those child prints back to a parent order.

Every panel here ships with the SQL that produced it. To run the same counts on another name or another session, ask the question in plain English on the Strasmore terminal.