Order Flow Imbalance, Toxicity & Market Maker Internalization

PFOF & Internalization: Where Your Order Actually Goes

Your Market Order Doesn't Go to an Exchange

When a retail trader places a market or marketable limit order through most major U.S. brokers, that order is typically routed not to a public exchange (NYSE, Nasdaq) but to a wholesale market maker — firms like Citadel Securities, Virtu Financial, and a small number of other large wholesalers who specialize in "internalizing" retail flow: taking the other side of the trade directly out of their own inventory rather than sending it to a public order book.

In exchange for the right to see and fill this flow, wholesalers pay brokers a small fee per share or per order — payment for order flow (PFOF) — which is a major reason many retail brokers can offer commission-free trading. This isn't a hidden or illegal arrangement; it's disclosed, regulated, and has been a defining feature of U.S. retail equity market structure for years.

Why Wholesalers Want Retail Flow Specifically

Retail order flow is valuable to wholesalers precisely because it is, on average, less likely to be "informed" — i.e., less likely to be trading ahead of news, earnings, or short-term price-moving information — than order flow from sophisticated institutional or algorithmic traders. A wholesaler that fills a large, diversified stream of retail orders can generally expect the average trade to be close to random with respect to short-term price direction, which is what makes internalizing that flow, and earning the bid-ask spread on it, a statistically favorable business.

SEC Rule 605/606: Reading Your Broker's Execution Report Card

What These Disclosures Actually Contain

SEC Rule 605 requires market centers (including wholesalers) to publish standardized monthly execution-quality statistics — effective spread, price improvement rates, and speed of execution, broken out by order size and type. SEC Rule 606 requires brokers to disclose quarterly where they route customer orders and any payment-for-order-flow arrangements or other compensation received for that routing.

Price Improvement Statistics Don't Tell the Whole Story

A high headline price-improvement rate looks good but doesn't capture everything that matters — it says nothing about how that improvement compares across order sizes, how much worse fills get during volatile periods, or whether the wholesaler is systematically slower to fill orders that would be unprofitable to internalize (routing those out while keeping the profitable ones). Rule 605 data is aggregated at the venue level; it is not a guarantee about any individual order's outcome.

The Order Flow Imbalance (OFI) Formula

The Core Idea: Order Book Pressure Predicts Short-Term Price Moves

Order Flow Imbalance, as formalized in academic market microstructure research (notably Rama Cont, Arseniy Kukanov, and Sasha Stoikov's work, "The Price Impact of Order Book Events"), measures the net change in buy-side versus sell-side pressure at the top of the order book over a short time interval. The core finding is that OFI has strong, statistically robust predictive power for very short-term price changes — considerably stronger than looking at trade volume or order book depth alone.

OFI_t = ΔBidSize_t - ΔAskSize_t

where, for each event at time t:
  ΔBidSize_t = +BidSize_t  if bid price increases (new best bid, price improves)
             = 0           if bid price unchanged and bid size increases
             = -BidSize_(t-1)  if bid price decreases (best bid canceled/moves down)
             (analogous logic applies symmetrically for size-only changes)

  ΔAskSize_t = mirror-image definition for the ask side

Net Order Flow Imbalance over an interval:
  OFI = Σ (bid-side contribution - ask-side contribution) across all
        top-of-book events in the interval

In plain terms: OFI increases when buy-side pressure builds (bid size grows or the bid price improves) relative to sell-side pressure, and decreases when the reverse happens. Cont et al.'s research found that price changes over short intervals are, on average, close to linear in OFI — more net buy-side pressure at the top of book predicts a small upward price move over the next interval, and vice versa.

Detecting Toxic, Informed Order Flow

What "Toxicity" Means to a Market Maker

"Toxic" order flow, in market-making terminology, is flow that is more likely to be informed — i.e., the counterparty knows something (or has a statistical edge) that makes the trade likely to move against the market maker shortly after execution. A market maker who fills a large sell order right before the price drops has been adversely selected: they bought right before the informed seller's information got reflected in price.

The VPIN Concept

One widely referenced academic approach to estimating order flow toxicity is Volume-Synchronized Probability of Informed Trading (VPIN), developed by Easley, López de Prado, and O'Hara. VPIN buckets trading activity by volume rather than by clock time and estimates the imbalance between buy-classified and sell-classified volume within each bucket as a proxy for the probability that informed trading is present. It gained particular attention as a proposed early-warning signal around liquidity-driven stress events. It's a useful conceptual framework for understanding how institutional desks think about toxicity — full production VPIN implementations require tick-level classified trade data most retail traders don't have continuous access to.

Adverse Selection: The Cost Hidden Inside "Price Improvement"

Why a "Better Than NBBO" Fill Isn't Automatically a Good Fill

Price improvement means your fill was better than the quoted National Best Bid/Offer at the moment your order arrived — it says nothing about what the price does immediately afterward. If you buy with a small amount of price improvement and the stock immediately drops because your order was filled right as a wave of selling pressure was building, you experienced adverse selection despite technically getting a "good" execution by the price-improvement metric.

Why This Matters More for Larger or Less Liquid Orders

Adverse selection cost scales with order size relative to available liquidity and with how "informed" the flow around your trade happens to be. A small market order in a highly liquid large-cap during calm conditions faces minimal adverse selection cost. The same order type on a thinly traded small-cap, or during a fast-moving news event, faces meaningfully higher risk of being filled right before an unfavorable move — precisely the conditions where OFI tends to be strongly one-sided.

Python Implementation: OFI Calculator & Toxicity Flag

Full implementation: Order book event processing, OFI calculation per the Cont et al. framework, a simple rolling toxicity flag, and a post-trade adverse selection measurement helper.

Complete Python Code

"""
Order Flow Imbalance (OFI) & Toxicity Estimation
Retail-adapted implementation of the Cont, Kukanov, Stoikov (2014)
OFI framework, plus a simple post-trade adverse selection measure.

Author: Plan My Retire
Date: March 2026
"""

import numpy as np
import pandas as pd


class OrderFlowImbalance:
    """
    Computes Order Flow Imbalance (OFI) from a stream of top-of-book
    quote updates, following Cont, Kukanov & Stoikov (2014).

    Expects a DataFrame of quote snapshots with columns:
    ['timestamp', 'bid_price', 'bid_size', 'ask_price', 'ask_size']
    """

    def compute_event_ofi(self, quotes_df):
        """
        Computes per-event OFI contribution between consecutive
        top-of-book snapshots.
        """
        df = quotes_df.copy().reset_index(drop=True)
        ofi_contributions = [0.0]  # first row has no prior snapshot

        for i in range(1, len(df)):
            prev, curr = df.iloc[i - 1], df.iloc[i]

            # Bid-side contribution
            if curr['bid_price'] > prev['bid_price']:
                bid_contrib = curr['bid_size']
            elif curr['bid_price'] < prev['bid_price']:
                bid_contrib = -prev['bid_size']
            else:
                bid_contrib = curr['bid_size'] - prev['bid_size']

            # Ask-side contribution (mirror logic, sign-flipped)
            if curr['ask_price'] < prev['ask_price']:
                ask_contrib = curr['ask_size']
            elif curr['ask_price'] > prev['ask_price']:
                ask_contrib = -prev['ask_size']
            else:
                ask_contrib = curr['ask_size'] - prev['ask_size']

            ofi_contributions.append(bid_contrib - ask_contrib)

        df['event_ofi'] = ofi_contributions
        return df

    def rolling_ofi(self, df_with_ofi, window):
        """Sum event-level OFI over a rolling window of events."""
        return df_with_ofi['event_ofi'].rolling(window=window).sum()

    def normalize_ofi(self, ofi_series, avg_depth_series):
        """
        Normalizes OFI by average book depth so readings are
        comparable across names with different typical liquidity.
        """
        return ofi_series / avg_depth_series.replace(0, np.nan)


class ToxicityFlag:
    """
    Simple rolling toxicity heuristic combining OFI persistence
    and order-size anomalies. Illustrative, not a production
    VPIN implementation.
    """

    def __init__(self, ofi_zscore_threshold=2.0, size_zscore_threshold=2.5):
        self.ofi_threshold = ofi_zscore_threshold
        self.size_threshold = size_zscore_threshold

    def flag(self, ofi_series, trade_size_series, lookback=100):
        ofi_z = self._zscore(ofi_series, lookback)
        size_z = self._zscore(trade_size_series, lookback)

        toxic = (ofi_z.abs() > self.ofi_threshold) & (size_z > self.size_threshold)
        return pd.DataFrame({
            'ofi_zscore': ofi_z,
            'size_zscore': size_z,
            'toxicity_flag': toxic
        })

    def _zscore(self, series, lookback):
        mean = series.rolling(lookback).mean()
        std = series.rolling(lookback).std()
        return (series - mean) / std.replace(0, np.nan)


class AdverseSelectionMeasure:
    """
    Measures realized adverse selection cost: the price move against
    your fill direction over a short post-trade window, net of any
    price improvement received at execution.
    """

    def measure(self, fill_price, side, nbbo_mid_at_fill, mid_price_series_after,
                horizon_events=10):
        """
        side: 'buy' or 'sell'
        mid_price_series_after: mid-price observations following the fill
        """
        price_improvement = (
            (nbbo_mid_at_fill - fill_price) if side == 'buy'
            else (fill_price - nbbo_mid_at_fill)
        )

        post_trade_mid = mid_price_series_after.iloc[:horizon_events].mean()
        realized_move = (
            (post_trade_mid - fill_price) if side == 'buy'
            else (fill_price - post_trade_mid)
        )

        return {
            'price_improvement': price_improvement,
            'post_trade_realized_move': realized_move,
            'net_adverse_selection_cost': -realized_move,  # negative move = cost
            'improvement_offset_adverse_selection': price_improvement > -realized_move
        }


# Example usage
if __name__ == "__main__":
    # Synthetic top-of-book quote stream
    quotes = pd.DataFrame({
        'timestamp': pd.date_range('2026-03-12 09:30:00', periods=8, freq='s'),
        'bid_price': [100.00, 100.00, 100.01, 100.01, 100.01, 100.00, 99.99, 99.99],
        'bid_size':  [500, 700, 300, 450, 200, 600, 800, 900],
        'ask_price': [100.02, 100.02, 100.02, 100.03, 100.03, 100.02, 100.01, 100.01],
        'ask_size':  [600, 550, 500, 300, 250, 400, 700, 750],
    })

    ofi_calc = OrderFlowImbalance()
    df = ofi_calc.compute_event_ofi(quotes)
    df['rolling_ofi'] = ofi_calc.rolling_ofi(df, window=3)

    print(df[['timestamp', 'event_ofi', 'rolling_ofi']])

    toxicity = ToxicityFlag()
    trade_sizes = pd.Series([500, 700, 300, 450, 200, 600, 800, 5000])  # last trade is anomalous
    flags = toxicity.flag(df['event_ofi'], trade_sizes, lookback=4)
    print("\nToxicity flags:")
    print(flags)

    adverse = AdverseSelectionMeasure()
    result = adverse.measure(
        fill_price=100.015,
        side='buy',
        nbbo_mid_at_fill=100.02,
        mid_price_series_after=pd.Series([100.01, 100.00, 99.99, 99.98, 99.98]),
    )
    print("\nAdverse selection measurement:")
    print(result)

Routing Algorithms: Limit vs. Midpoint Peg

Two Fundamentally Different Ways to Express an Order

A standard limit order rests at a fixed price you specify and waits to be filled — it has no adverse selection protection built in beyond the price itself. A midpoint peg order instead continuously tracks the midpoint between the NBBO bid and ask, adjusting its price as the market moves, and typically only fills against other midpoint-seeking or price-improving flow.

How OFI and Toxicity Concepts Apply to Order Type Choice

A resting limit order is most vulnerable to adverse selection precisely when OFI is building strongly against its side — a stale bid sitting in the book while sell-side pressure accelerates is exactly the setup that gets picked off by faster participants. Midpoint peg orders reduce (but don't eliminate) this risk by repricing continuously rather than sitting fixed, at the cost of lower fill certainty when you need to trade urgently.

Illustrative Execution Quality Impact

The figures below are hypothetical illustrations of how order type and timing choices affect realized execution cost — they are not a guarantee and will vary by broker, venue, name, and market conditions. They exist to make the cost trade-offs concrete.

Common Mistakes That Cost You Execution Quality

Your Action Plan

Phase 1: Audit Your Own Execution Quality (2-4 Weeks)

Timeline: Before changing any trading behavior, understand your current baseline.

1. Pull your broker's most recent Rule 606 report and identify where your flow is routed and what PFOF arrangement exists
2. Compare Rule 605 execution-quality statistics across your broker's routing venues versus competitors
3. Journal your own fills — note fill price versus NBBO at order time, and price 30-60 seconds later, for a sample of your recent trades

Phase 2: Deliberate Order-Type Selection (1-3 Months)

Timeline: Start applying order-type discipline based on trade urgency.

1. Use limit or midpoint peg orders (where your broker offers them) for any trade without genuine time pressure
2. Reserve marketable orders for situations where speed genuinely matters more than price
3. Avoid sending large orders during known high-volatility windows (open, close, scheduled news) unless the trade specifically requires it
4. Continue journaling realized adverse selection using the post-trade price-move framework above

Phase 3: Systematic Execution Review (6+ Months)

Timeline: Only after building a real sample of journaled trades across order types.

1. Automate the adverse-selection measurement using the Python framework above against your own trade log and a market data feed
2. Re-evaluate your broker choice if Rule 605/606 data and your own journal consistently show worse-than-peer execution quality
3. Build OFI awareness into trade timing for any strategy sensitive to short-term execution cost, not as a standalone signal

Recommended Reading

• Institutional & Regulatory Research:
  • SEC Rule 605/606 disclosures — publicly available execution-quality and order-routing data
  • Rama Cont, Arseniy Kukanov, Sasha Stoikov — "The Price Impact of Order Book Events" (Order Flow Imbalance framework)
  • Citadel Securities / Virtu Financial — public market structure and execution quality research
• Related PMR Articles:
  • 0DTE Options Microstructure & Gamma Pinning (companion dealer-hedging framework)
  • HRT: Microstructure (companion piece on high-frequency market making)