Quant Data has an options flow API. It returns options trades in two forms, consolidated flow (one row per sweep, block or split) and unconsolidated flow (one row per exchange print), for the current session and past sessions, with history from January 2, 2025.
Each request is one POST with a JSON body, or one MCP tool call. The API costs $149.99 a month or $1,499.99 a year.
Checked November 9, 2026. The responses below were requested October 29, 2026 and re-run November 9, 2026 with the same rows. Times are Eastern (ET).
Key takeaways
Filter in the request. Ticker (6,000+ covered), premium range, trade side, trade type and flags such as isUnusual all go in the body, so you pull the rows you want, not the whole tape.
Totals come with the rows. With includeStatistics, page 1 also returns call and put premium, trade count and volume by trade side for every row that matched.
Past sessions use the same request. Add a sessionDate; nothing else changes.
The same data in AI clients. Both flow endpoints are tools on the Quant Data MCP server at https://api.quantdata.us/mcp: qd_get_order_flow_consolidated and qd_get_order_flow_unconsolidated.
What is an options flow API?
An options flow API returns options order flow as records your code or AI client can filter, sort and total. Each record names the contract, the size and premium, the trade time, and codes for trade side and trade type.
Quant Data serves two views of the same trades:
Consolidated flow (order-flow/consolidated): one row is one sweep, block or split. Use it to find the large trades in a ticker or a session.
Unconsolidated flow (order-flow/unconsolidated): one row is one print on one exchange, tagged with its OSI contract symbol. Use it for the full tape of one contract.
For scale, one contract-statistics request for SPY in the October 28, 2026 session returned $1,423,501,064 in gross call and put premium across 7,867,066 contracts traded; the walk further down keeps the 263 consolidated rows of $250K or more.
If sweeps, blocks and splits are new to you, Options Flow: Blocks, Splits, Sweeps, and Unusual Activity explains each one.
What unconsolidated flow looks like for one contract
Here is the tape for one contract, the SPY December 15, 2028 $695 put, in the October 28, 2026 session. Its OSI symbol, SPY281215P00695000, is the ticker, the expiry as YYMMDD, P for put, and the strike times 1,000 in eight digits. Send this body to https://api.quantdata.us/v1/options/tool/order-flow/unconsolidated with the same two headers as the curl sample below:
{
"sessionDate": "2026-10-28",
"size": 1000,
"sort": {"field": "TRADE_TIME", "direction": "ASCENDING"},
"filter": {"osi": "SPY281215P00695000"},
"includes": ["ID", "OSI", "EXCHANGE", "TRADE_SIDE", "SIZE",
"PREMIUM", "TRADE_TIME", "TRADE_TYPE"]
}
All 28 prints came back on one page: from 4:04 PM to 4:11 PM ET, after the 4:00 PM stock close, on 12 exchanges, for 1,601 contracts and $6,091,549 in gross premium.
The 28 prints in the SPY Dec 15, 2028 $695 put on October 28, 2026, by exchange (requested October 29, 2026).
How much does the options flow API cost, and what are the limits?
The Quant Data API costs $149.99 a month or $1,499.99 a year and allows 240 requests a minute, with no monthly quota. One plan covers every endpoint, over REST and MCP, on one key.
Quant Data API plan | |
Price | $149.99 a month or $1,499.99 a year |
Requests | 240 a minute plus a burst cap of 20 a second, per user, shared by REST and MCP; no monthly quota |
Endpoints and tools | 30 REST endpoints; 31 MCP tools (30 data tools plus qd_ping) |
History | Order flow from January 2, 2025 (checked November 9, 2026) |
Requirements | An active API subscription and a signed market-data subscriber agreement |
Who can use it | Personal use only. Not for external redistribution. |
Prices as of November 9, 2026; current plans are on quantdata.us/api.
How do I get options flow data with one request?
Send one POST to the REST API, or ask an AI client connected to the Quant Data MCP server. Both use the same key and the same request limit, and both return the same data: for the October 28, 2026 session, the REST endpoint and the MCP tool, called without an AI client, returned the same five SPY sweeps.
Before you send a request. Get a key (steps in the Quant Data API overview) and sign the market-data subscriber agreement; until you do, options requests return HTTP 403 with the signing link (Authentication). Then set the key as QD_API_KEY: export QD_API_KEY="<your key>" on macOS or Linux, $env:QD_API_KEY = "<your key>" in Windows PowerShell.
REST: curl or Python
Both samples ask for the five largest SPY sweeps of $500K or more on October 28, 2026. The curl sample is for bash (macOS, Linux, Git Bash or WSL); in Windows PowerShell, use the Python sample.
curl -X POST https://api.quantdata.us/v1/options/tool/order-flow/consolidated \
-H "Authorization: Bearer $QD_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"sessionDate": "2026-10-28",
"size": 5,
"includeStatistics": true,
"sort": {"field": "PREMIUM", "direction": "DESCENDING"},
"filter": {
"ticker": "SPY",
"tradeConsolidationTypes": ["SWEEP"],
"premiumRange": {"min": 500000}
},
"includes": ["TICKER", "CONTRACT_TYPE", "EXPIRATION_DATE", "STRIKE_PRICE", "SIZE",
"PREMIUM", "TRADE_SIDE", "TRADE_CONSOLIDATION_TYPE", "TRADE_TYPE",
"IS_GOLDEN_SWEEP", "IS_UNUSUAL", "TRADE_TIME"]
}'
The same request in Python (pip install requests):
import os
import requests
API_KEY = os.environ["QD_API_KEY"]
resp = requests.post(
"https://api.quantdata.us/v1/options/tool/order-flow/consolidated",
headers={"Authorization": f"Bearer {API_KEY}"},
json={
"sessionDate": "2026-10-28", # leave out for the most recent session
"size": 5,
"includeStatistics": True,
"sort": {"field": "PREMIUM", "direction": "DESCENDING"},
"filter": {
"ticker": "SPY",
"tradeConsolidationTypes": ["SWEEP"],
"premiumRange": {"min": 500000},
},
"includes": ["TICKER", "CONTRACT_TYPE", "EXPIRATION_DATE", "STRIKE_PRICE",
"SIZE", "PREMIUM", "TRADE_SIDE", "TRADE_CONSOLIDATION_TYPE",
"TRADE_TYPE", "IS_GOLDEN_SWEEP", "IS_UNUSUAL", "TRADE_TIME"],
},
timeout=60,
)
if not resp.ok:
raise SystemExit(f"{resp.status_code}: {resp.text}")
page = resp.json()
for row in page["data"]:
print(row["ticker"], row["expirationDate"], row["strikePrice"], row["contractType"],
row["size"], f"${row['premium']:,.0f}", row["tradeSideCode"])
for contract_type, sides in page["statistics"].items():
for side, cell in sides.items():
print(contract_type, side, cell["tradeCount"], f"${cell['premium']:,.0f}", cell["volume"])
Real response, session 2026-10-28 (row 1 of 5; the other rows have the same fields):
{
"data": [
{
"contractType": "PUT",
"expirationDate": "2028-12-15",
"isGoldenSweep": false,
"isUnusual": false,
"premium": 2488049.0,
"size": 651,
"strikePrice": 695.0,
"ticker": "SPY",
"tradeConsolidationType": "SWEEP",
"tradeSideCode": "BID",
"tradeTime": 1793218291916,
"tradeType": "AUTO"
},
...
All five rows, with tradeTime (epoch milliseconds) converted to ET:
Row | Contract | Size | Premium | tradeSideCode | Time (ET) |
1 | SPY 2028-12-15 695 put | 651 | $2,488,049 | BID | 4:11:31 PM |
2 | SPY 2026-10-28 771 call | 6,207 | $1,415,201 | BID | 12:37:02 PM |
3 | SPY 2026-12-18 750 call | 400 | $1,370,000 | ASK | 1:11:31 PM |
4 | SPY 2027-12-17 735 put | 388 | $1,339,764 | BID | 3:38:49 PM |
5 | SPY 2027-04-30 710 call | 148 | $1,320,451 | BELOW_BID | 2:51:32 PM |
Page 1 also carried the statistics, which cover every row that matched the filter, not just the five on the page: 49 SPY sweeps of $500K or more, 20 calls with $16,670,751 and 29 puts with $23,672,702 in gross premium.
One REST detail: the ticker goes inside filter. A top-level tickers key is ignored without an error, so the request returns rows for every ticker.
MCP: ask your AI client
The Quant Data MCP server is at https://api.quantdata.us/mcp and carries 31 tools: 30 data tools, one per REST endpoint, plus qd_ping, a connection check. In Claude Code, save this config to a file and start Claude Code with claude --mcp-config <file>:
{
"mcpServers": {
"quant-data": {
"type": "http",
"url": "https://api.quantdata.us/mcp",
"headers": {"Authorization": "Bearer ${QD_API_KEY}"}
}
}
}
Claude Code fills in ${QD_API_KEY} from your environment, so the key is not saved in the file. This config connected and listed all 31 tools on October 29, 2026. Ask the client to run qd_ping; a short reply confirms that the URL and the key both work. Then ask in plain English:
Ask | Tool with that data |
“Show the five largest SPY sweeps of $500K or more on October 28, 2026.” | qd_get_order_flow_consolidated |
“List every print in SPY281215P00695000 on October 28, 2026.” | qd_get_order_flow_unconsolidated |
“What was SPY’s gross call and put premium on October 28, 2026?” | qd_get_contract_statistics |
For other MCP clients that accept a server URL and an Authorization header, see the MCP Server docs listed at the end.
Which endpoint answers which options flow question?
Four endpoints answer most options flow questions, and each is also an MCP tool.
Question | Endpoint | One record is | MCP tool |
What were the largest sweeps, blocks and splits? | One sweep, block or split | qd_get_order_flow_consolidated | |
What printed in one contract, exchange by exchange? | One print on one exchange | qd_get_order_flow_unconsolidated | |
How much call and put premium traded in a session? | CALL and PUT gross premium, trade count and volume | qd_get_contract_statistics | |
How did that premium split by trade side? | One value per contract type and trade side | qd_get_contract_trade_side_statistics |
The API docs list all 30 endpoints. The same key also serves gamma exposure, open interest, implied volatility and dark pool data; for gamma, see Gamma Exposure (GEX) API: Python Quickstart.
What does one options flow record contain?
An untrimmed consolidated row carries 32 fields, with greeks and moneyness nested. Unconsolidated rows add osi and have no tradeConsolidationType or isGoldenSweep.
Group | Fields |
Contract | ticker, contractType, expirationDate, strikePrice, dte, osi (unconsolidated rows) |
Identity and time | id, exchange, tradeTime (epoch milliseconds) |
Size and prices | premium, size, volume, openInterest, optionPrice, bidPrice, askPrice, bidAskSpread, stockPrice |
Codes | tradeSideCode (ABOVE_ASK, ASK, MID_MARKET, BID, BELOW_BID), tradeType, tradeConsolidationType (BLOCK, SPLIT, SWEEP; consolidated rows) |
Flags | isUnusual, isGoldenSweep (consolidated rows), isOpeningPosition, isVolumeGreaterThanOpenInterest |
Greeks and moneyness | greeks: delta, gamma, theta, vega, rho, charm, vanna, vomma, veta, speed, zomma, color, ultima, omega, sigma; moneyness: degree, degreeInPercent, moneyType |
Also on every row | impliedVolatility, sentimentType, sector, industry, isETF, isIndex |
To trim rows, pass includes with Field Reference names in upper snake case (TRADE_SIDE returns tradeSideCode), as every sample here does; ID is listed on the Projection page.
How do I pull a whole session of options flow?
Page through it with the cursor each response returns. This script walks every SPY consolidated row of $250K or more on October 28, 2026, de-duplicates by id, waits when rate limited, and checks its totals against the page 1 statistics.
Paging. Pass each nextSearchAfter back, unchanged, as searchAfter; a missing or null nextSearchAfter means no more pages (Pagination).
Page size. 50 rows unless you set size; up to 100 on order-flow/consolidated and 1,000 on order-flow/unconsolidated. A larger size returns HTTP 400.
import os
import time
import requests
API_KEY = os.environ["QD_API_KEY"]
URL = "https://api.quantdata.us/v1/options/tool/order-flow/consolidated"
body = {
"sessionDate": "2026-10-28",
"size": 100,
"includeStatistics": True,
"filter": {"ticker": "SPY", "premiumRange": {"min": 250000}},
"includes": ["ID", "CONTRACT_TYPE", "PREMIUM", "TRADE_TIME",
"TRADE_TYPE", "TRADE_CONSOLIDATION_TYPE"],
}
rows, stats, calls, dupes = {}, None, 0, 0
for _ in range(60): # hard stop, so a bad loop never runs forever
resp = requests.post(URL, json=body, timeout=60,
headers={"Authorization": f"Bearer {API_KEY}"})
calls += 1
if resp.status_code == 429: # rate limited: wait, then retry the same page
time.sleep(float(resp.headers.get("Retry-After", "1")) + 0.5)
continue
resp.raise_for_status()
page = resp.json()
stats = stats or page.get("statistics") # statistics arrive on page 1
for row in page["data"]:
dupes += row["id"] in rows
rows[row["id"]] = row # de-duplicate by id
cursor = page.get("nextSearchAfter")
if not cursor:
break # no cursor: the walk is complete
body["searchAfter"] = cursor # pass it back unchanged
time.sleep(0.3)
else:
raise RuntimeError("walk did not finish")
print(calls, "requests,", len(rows), "unique rows,", dupes, "duplicates")
for ct in ("CALL", "PUT"):
mine = [row for row in rows.values() if row["contractType"] == ct]
walk = sum(row["premium"] for row in mine)
stat = sum(cell["premium"] for cell in (stats or {}).get(ct, {}).values())
count = sum(cell["tradeCount"] for cell in (stats or {}).get(ct, {}).values())
print(f"{ct}: walk {len(mine)} rows ${walk:,.0f} | "
f"statistics {count} trades ${stat:,.0f} | difference ${walk - stat:,.0f}")
Real response, session 2026-10-28 (the script’s printed output):
3 requests, 263 unique rows, 0 duplicates
CALL: walk 120 rows $87,144,253 | statistics 120 trades $87,144,253 | difference $0
PUT: walk 143 rows $83,714,386 | statistics 143 trades $83,714,386 | difference $0
Every row the script above returned, one dot each (session October 28, 2026; requested October 29, 2026).
About half the premium was multi-leg. 105 of the 263 rows had multi-leg trade types (the
MULTI_*,M2M_FLRandTIED_MULTI_*codes) and carried $85,090,480, 49.8% of the $170,858,639 gross total. To leave multi-leg orders out, add IS_COMPLEX = false to filterExpression (Filter Expression).Keep the cross-check. Rows can repeat when new trades arrive between pages, hence the id key. If the walk and the statistics disagree, re-run the walk and compare again; if they still differ, contact support.
Share of the session. The contract-statistics request near the top split SPY’s gross premium that day into $753,332,162 for calls and $670,168,902 for puts, so the walk covers 11.57% and 12.49% of them.
When a request fails. Over a limit, the API returns HTTP 429 with a Retry-After header, which the script waits out (Rate Limiting). Other errors come back as JSON: 400 for a bad request, 401 for a missing or invalid key, 403 for no active subscription or an unsigned agreement, and 422 when market data the request depends on is unavailable (Errors). A date with no trades is not an error: it returns an empty list.
Why use Quant Data for options flow data?
The Quant Data options flow API serves exchange-licensed data, the same data behind the Quant Data dashboards, from a company that has delivered licensed options data for six years.
Licensed at the source. Each subscriber signs a market-data subscriber agreement before options requests go through.
A community of 20,000+ members around the same data.
Checkable before you buy. Every endpoint’s request and response fields are in the public API docs, and every response on this page is a real one, with its date.
Both views of the tape on one key. Consolidated and unconsolidated flow with their totals, 6,000+ tickers and history from January 2, 2025, over REST and MCP.
FAQ
Does Quant Data have an options flow API?
Yes. The Quant Data API serves consolidated options flow through POST /v1/options/tool/order-flow/consolidated (sweeps, blocks and splits) and unconsolidated options flow through POST /v1/options/tool/order-flow/unconsolidated (every exchange print), at https://api.quantdata.us. Both filter by ticker, premium, trade side and trade type, and both are tools on the Quant Data MCP server.
Is Quant Data’s options flow data licensed?
Yes. The API serves exchange-licensed options data, the same data as the Quant Data dashboards. Until a subscriber signs the market-data subscriber agreement, options requests return HTTP 403 with a link to sign it.
What is the difference between consolidated and unconsolidated options flow?
Consolidated flow has one row per sweep, block or split. Unconsolidated flow has one row per exchange print, tagged with the contract’s OSI symbol.
Can I get historical options flow from the API, and how far back does it go?
Yes. Both Quant Data order-flow endpoints accept a past sessionDate, with history from January 2, 2025 (checked November 9, 2026). A request for SPY prints on October 28, 2025 returned that session’s last trades, at 4:14:59 PM ET, and requests on November 9, 2026 for January 2, 2025 returned rows from both endpoints.
Is there an unusual options activity API?
Yes. Every Quant Data order-flow row carries an isUnusual flag, and a request can ask for just the flagged rows: pass isUnusual: true to the MCP tool, or add IS_UNUSUAL = true to filterExpression over REST. For what the flag means in Quant Data, see Options Flow: Blocks, Splits, Sweeps, and Unusual Activity.
How much is the options flow API?
$149.99 a month or $1,499.99 a year, for every endpoint over REST and MCP.
Can I use the options flow API from Claude or another AI client?
Yes, in Claude Code: it connected to the Quant Data MCP server at https://api.quantdata.us/mcp and listed all 31 tools with the config shown above (October 29, 2026). For other clients that accept a server URL and an Authorization header, see the MCP Server docs listed below.
Can I pull today’s options flow during market hours?
Yes. Leave out sessionDate and the response holds trades from the current session: a request with no sessionDate at 1:19 PM ET on October 29, 2026 returned 50 rows, all from that day.
What are the rate limits?
240 requests a minute per user, plus a burst cap of 20 a second, shared by REST and MCP, with no monthly quota. Over the limit, the API returns HTTP 429 with a Retry-After header.
Where are the full API docs?
Quant Data API overview: API key setup and an overview
API docs: every endpoint
Concepts: Field Reference, Filter Expression, Pagination, Projection, Rate Limiting, Authentication, Errors
MCP Server docs and the machine-readable summary at llms.txt
I have not signed up for the Quant Data API. How do I?
If you want options flow data in your own code or AI client, click here to see the API plan and get your API key. Click on Learn More if you would like to learn more about what we offer.
Would you like further assistance?
If you have any questions or need further assistance, please don’t hesitate to reach out to the Quant Data team at support@quantdata.us or via our live chat located on the bottom right-hand corner of your screen. We are available on our live chat between 9:30 AM and 5:00 PM (eastern time), Monday through Friday.