When you send a market order to a perp venue, you pay two costs on top of the position itself: the taker fee the venue charges, and slippage — the difference between the mid price and the price you actually fill at. FRAGMENTED measures both, live, for a specific trade size, on every venue simultaneously. Type BTC 250K LONG and each venue answers the question: “what would this exact order cost right now?”

All costs are quoted in basis points (bp) of trade notional: 1bp = 0.01%. A 4.5bp total cost on a $250,000 order is $112.50.

<TICKER> <SIZE> <SIDE>      e.g.  BTC 250K LONG · ETH 1M S · NVDA 50000
SIZE:  plain USD, or K/M suffix ($ notional, not contracts)
SIDE:  LONG/L/BUY or SHORT/S/SELL — defaults to LONG
Word order is free. Crypto and TradFi tickers both work (NVDA, XAU, EURUSD…).

For venues with a public limit orderbook (Hyperliquid, Lighter, Paradex, Extended, Aster, dYdX, Pacifica, edgeX, Hibachi, ApeX, GRVT, Ethereal, Velocity, Bluefin, Carbon-Cryp) we fetch the live L2 ladder and simulate the fill. A long consumes the ask side, a short the bid side, level by level, cheapest first, until the full USD size is filled:

given levels (p₁,q₁), (p₂,q₂), …  sorted best-first, order size S (USD):

  take from level i:   fillᵢ = min(remaining, pᵢ·qᵢ)   [USD]
  accumulate quantity: Q += fillᵢ / pᵢ
  stop when remaining = 0

  VWAP  = S / Q                     (volume-weighted average fill price)
  slip  = (VWAP − mid) / mid        (long;  short: (mid − VWAP) / mid)
  mid   = (best_bid + best_ask) / 2

Worked example — mid 100.00, asks 10 @ 100.10, 10 @ 100.30, 50 @ 101.00, buy $2,000:

level 1: capacity 10 × 100.10 = $1,001 → take all      Q = 10.0000
level 2: remaining $999 @ 100.30   → Q += 9.9601       Q = 19.9601
VWAP = 2000 / 19.9601 = 100.20
slip = (100.20 − 100.00) / 100.00 = 20.0bp

If the ladder runs out before the order is filled, no honest price exists for that size and the venue shows INSUF DEPTH instead of a number.

Carbon-Cryp is an orderbook venue with a twist: its ARFQ solvers hedge every fill on Binance, so the trader’s real cost is size-dependent Binance-book impact plus Carbon’s per-market hedger fee. We walk the live Binance book (via its public data mirror, since Binance futures is geoblocked server-side) and truncate it to Carbon’s per-market notional cap — beyond the cap it reads INSUF DEPTH. Its crypto and TradFi products are separate venues (overlapping tickers, different pricing), hence Carbon-Cryp / Carbon-RWA.

Some venues have no book — the whole order fills at one quoted price. Each is modeled from its own published pricing, never a guess:

VARIATIONAL   venue publishes bid/ask at three size tiers ($0 / $1k / $100k).
              fill price = linear interpolation between tiers at your size,
              extrapolated (never tightening) beyond $100k. Quote distances
              from mid are clamped monotonic so cost never improves with size.

OSTIUM        oracle feed publishes executable bid/ask per pair.
              long fills at ask, short at bid, size-independent.
              per-pair opening fee from the protocol subgraph
              (BTC/ETH 10bp · stocks 6bp · FX+metals 3bp). capped $10M.

CARBON-RWA    fill = feed ask×(1+f) / bid×(1−f)   [per-pair f: equities 3bp,
              metals 4bp, EURUSD 1bp] — reproduces the Long/Short prices and
              mid-spread shown in Carbon's own UI. Ticks older than 10min
              (weekends/after-hours) ⇒ MARKET CLOSED.

VEST          zkRisk AMM. public depth is decorative, so we quote the
              published top-of-book bid/ask, refusing sizes > $50k
              (NO QUOTE) rather than inventing a depth curve.

Fees are base-tier taker rates. Wherever the venue publishes per-market fees via API, the live value overrides the static one:

orderbook   HYPERLIQUID 4.5bp (HIP-3 markets e.g. NVDA: 9bp — 2× base)
            LIGHTER 0 · PARADEX 0.75bp · EXTENDED 2.5bp
            ASTER 3.5bp (stock perps 0) · DYDX 5bp · PACIFICA 2bp
            EDGEX per-contract (BTC 3.8bp) · HIBACHI 4.5bp · APEX 5bp
            GRVT 4.5bp · ETHEREAL per-product (BTC 3bp)
            VELOCITY 10bp · BLUEFIN 3.5bp
            CARBON-CRYP per-market hedger fee (BTC 10bp, NVDA 12bp)
rfq         VARIATIONAL 0 (cost is the spread) · OSTIUM per-pair (3–10bp)
            CARBON-RWA 0 (cost is the per-pair hedger-fee spread)
            VEST per-symbol (crypto 1bp · stocks 10bp)

total_bps  = fee_bps + slip_bps
total_usd  = size × total_bps / 10,000

The detail panel shows each venue’s funding normalized to a common unit — % per hour — plus the annualized equivalent (×24×365). Venues publish different native cadences, converted as:

hourly-native   Hyperliquid · dYdX · Extended · Pacifica · Hibachi · Ethereal · Vest
per-8h ÷ 8      Paradex · Aster · ApeX · GRVT · Lighter · Carbon-Cryp · Bluefin
per-day ÷ 24    Carbon-RWA
annualized ÷ 8760   Variational

Funding is displayed for context only — it is not added to execution cost, since it depends on holding time, not on execution.

Instead of sending the whole order to one venue, you can split it. The solver finds the cheapest split by greedy marginal-cost allocation:

1. cut the order into N = 200 equal slices (S/200 each)
2. for each slice, ask every venue: "what would THIS slice cost you,
   given what you've already been allocated?"
     book venue:  next unconsumed level price + fee
     rfq venue:   Δcost = cost(x+s) − cost(x) at allocated size x
3. give the slice to the cheapest venue; repeat 200×

cost_v(x) = x·fee_v + x·slip_v(x)        [venue v's total cost at size x]
minimize  Σᵥ cost_v(xᵥ)   s.t.  Σᵥ xᵥ = S

Why greedy is optimal here: every venue’s cost curve is convex — eating deeper into a book only gets more expensive, and RFQ tiers only widen with size. For convex curves, marginal costs are non-decreasing, so always buying the cheapest next slice converges to the allocation where all venues in use have equal marginal cost — the KKT optimality condition of the quadratic-programming formulation. Greedy and QP land on the same split; greedy just gets there without a solver.

The marginal cost of the next slice. A slice of size s routed to venue v that already holds x adds

MCᵥ(x) = [ cost_v(x+s) − cost_v(x) ] / s      (cost of the next dollar, in bp)

  book venue:  fee_v  +  (price of the level the next slice eats − mid)/mid
  rfq  venue:  fee_v  +  (quoted price at x+s − mid)/mid   (from the tier curve)

Each slice goes to argminᵥ MCᵥ(x). Because MCᵥ rises with x (convex cost),
the winner changes as cheap venues fill up — the split self-balances until
every funded venue shares one common marginal cost λ:

  MC_A(x_A) = MC_B(x_B) = … = λ        ⇐  optimum (equal-marginal / KKT)

Worked split. Buy $300k of an asset (mid = 100.00) across three venues:

VENUE  fee   ask-side book (price × size, cumulative $)
─────  ───   ──────────────────────────────────────────────
  A    2bp   100.02 ×2,000 ($200k)   then 100.08 (thin)
  B    0bp   100.05 ×2,500 ($250k)   then 100.20 (thin)
  C    5bp   100.00 flat RFQ, any size (fee is the only cost)

marginal cost (fee + slip vs mid) while each is still on its deep level:
  MC_A = 2 + (100.02−100)/100·1e4 = 2 + 2  =  4.0 bp
  MC_B = 0 + (100.05−100)/100·1e4 = 0 + 5  =  5.0 bp
  MC_C = 5 + 0                            =  5.0 bp

fill order (200 slices of $1,500):
  • cheapest is A @ 4.0bp → route slices to A until its $200k deep level is
    eaten; its next level (100.08) would jump MC_A to 10bp.
  • now B and C tie at 5.0bp → split the remaining $100k between them; B's
    deep level covers $50k of it before B also jumps, C is flat forever.
  result:  A $200k (66.7%)  ·  B $50k (16.7%)  ·  C $50k (16.7%)

blended cost = Σ (allocᵥ/S) × total_bpsᵥ
             = 0.667×4.0  +  0.167×5.0  +  0.167×5.0
             = 2.67 + 0.835 + 0.835   ≈  4.34 bp   ($130 on $300k)

best single venue for the full $300k:  C at a flat 5.0 bp ($150)
SAVES VS BEST SINGLE = 5.00 − 4.34   =  0.66 bp   ($20 saved)

SAVES VS BEST SINGLE = (cheapest single venue’s total cost for the full size) − (blended cost of the split). The blended cost is always ≤ the best single venue, and the panel also reports the weighted-average fee and slippage separately. Venues that error, can’t fill even partially, or fail the stale-price check are excluded from the split.

OK             fully fillable — numbers are real
INSUF DEPTH    book can't absorb the size (book venues)
NO QUOTE       size exceeds what the venue will quote (rfq venues)
STALE PX       mid deviates >1% from the cross-venue median — dead/stale
               book; shown but excluded from ranking and SOR
ERR            ticker not listed there, market closed, or API failure

Every query fetches all venues fresh in parallel (9s timeout each; one slow venue never blocks the rest). Results auto-refresh every 15s while a query is active. The stale-price filter compares each venue’s mid to the cross-venue median — with 15+ independent venues, the median is a robust reference price.

The same asset is named differently everywhere: NVDA is xyz:NVDA on Hyperliquid’s HIP-3 dex, NVDA_24_5-USD on Extended, NVDAUSDT on Aster, NVDA-INTX on Carbon-RWA; gold is XAU / GOLD / XAUT. Every venue symbol is reduced to its base asset and matched through alias groups. “USD” is ambiguous — quote currency for XAUUSD but part of the pair for EURUSD — so both interpretations are kept and either may match.

Snapshots, not fills: books move between quote and execution. Fees are base tier — volume discounts, rebates, and token discounts are ignored. RFQ venues may re-quote at execution time. Funding, borrow, and holding costs are excluded from execution cost. Nothing here is financial advice.