FlashAlpha metrics,
pushed in real time
One WebSocket. 500+ streamable metrics: GEX, dealer positioning, options flow, volatility, VRP, surfaces. Subscribe to a symbol, a metric, and a cadence, and receive a sequenced update each time that metric recomputes. No polling loops, no wasted calls.
From $4,500/mo, one commercial bundle: dedicated node, streaming compute, data licence, and 500 concurrent subscriptions included. Endpoint provisioned during onboarding. Internal use only, no redistribution. The REST API and Historical API remain self-serve on standard plans.
The server recomputes your subscribed metrics on your cadence and pushes each new value to you. Your integration reacts to updates instead of burning a request budget asking whether anything changed.
Updates coalesce per subscription server-side. A slow consumer always receives the newest value, never a growing backlog. Every frame carries a per-subscription sequence number and a UTC timestamp so gaps are detectable.
Nothing recomputes without a subscriber, and identical subscriptions share one recompute. The commercial tier adds dedicated streaming compute, so your subscription set never queues behind another client's.
How streaming works
A deliberately small protocol: one socket, JSON text frames, snake_case fields. You send requests; the server sends frames. Four moves cover the whole lifecycle.
Connect and authenticate
Open a WebSocket to your provisioned endpoint with your FlashAlpha API key - the same X-Api-Key you use against the REST API, sent as a handshake header (or ?api_key= for browser clients). Authentication happens before the upgrade, so a rejected key comes back as a readable HTTP 401 or 403, not a silent socket close.
wss://<your-endpoint>/ws
// header: X-Api-Key: <your key>
// endpoint and entitlements are provisioned
// during commercial onboardingSubscribe to (symbol, metric, cadence)
Each subscription is one triple: a ticker, a dotted metric id, and how often you want it recomputed. cadence_ms accepts 0 (continuous, as fast as the source allows) or any target from 100 to 60000 milliseconds. The server acks with a sub_id that tags every later frame for that subscription. Commercial plans include 500 concurrent subscriptions, expandable in blocks of 500.
{ "action": "subscribe", "symbol": "SPY",
"metric": "exposure.gex.net_gex", "cadence_ms": 1000 }
{ "type": "ack", "sub_id": "a1b2c3d4e5f6", "symbol": "SPY",
"metric": "exposure.gex.net_gex", "cadence_ms": 1000 }Receive sequenced updates
Every time the metric recomputes, an update frame arrives. seq increases monotonically per subscription so gaps and reordering are detectable; ts is Unix epoch milliseconds, UTC; value is always a JSON number, and non-finite results are dropped rather than sent as NaN. A heartbeat frame arrives roughly every 5 seconds while idle, as a liveness signal.
{ "type": "update", "sub_id": "a1b2c3d4e5f6",
"symbol": "SPY", "metric": "exposure.gex.net_gex",
"cadence_ms": 1000, "seq": 42,
"ts": 1753165293123, "value": 2735133184.5 }
{ "type": "heartbeat", "ts": 1753165298123 }Manage the lifecycle
Unsubscribe by sub_id when a stream is no longer needed. Errors arrive as frames with a machine-readable code (unknown_metric, invalid_cadence, no_capacity, ...) and do not close the connection. If the socket drops, reconnect and re-subscribe: subscriptions are per-connection and released on close.
{ "action": "unsubscribe", "sub_id": "a1b2c3d4e5f6" }
{ "type": "error", "code": "unknown_metric",
"message": "unknown metric; read the live catalog" }What you can stream
500+ metrics across 12 groups, each mapped one-to-one to a field of the REST API, so the number you backtested is the number you stream. Metric ids are dotted: endpoint.method.field.
Net GEX, gamma flip, call/put walls, DEX, VEX, CHEX, key levels, 0DTE magnet
exposure.gex.net_gexLive flow-adjusted GEX, dealer risk, pin risk, intraday OI shift, signals
flow.dealer_risk.live_net_gexATM IV, skew, term structure, butterfly, IV-RV spreads
volatility.skew_term.butterfly_25dSVI parameters and surface diagnostics per expiry
surface.svi.atm_ivVariance risk premium level and z-score
vrp.snapshot.z_scoreMax pain strike and distance from spot
maxpain.summary.max_pain_strikeChain execution and liquidity scoring
liquidity.snapshot.chain_execution_scoreStraddle-implied expected move for the nearest expiry
expected_move.nearest.expected_move_pctSuitability scores for 10 systematic strategies
strategies.zero_dte.scorePre-earnings expected move and event timing
earnings.expected_move.days_to_eventFair vol and variance diagnostics from the SVI surface
adv_volatility.snapshot.fair_volQuotes and summary fields for the underlying
stock.summary.midMetrics that only change once a day (realized and forecast volatility, spot-vol correlation, historical earnings and VRP series) intentionally stay on the REST API. What streams is what actually moves intraday. The live catalog is served by the streaming engine at runtime, so clients discover it instead of hardcoding a list.
Engineered for honest real-time
The mechanics below are how the engine behaves, not marketing abstractions. We would rather you size your integration correctly on day one.
Per-subscription cadence
cadence_ms: 0 streams continuously, as fast as the data source allows; 100 to 60000 sets a target interval. Cadence is an upper bound on recompute frequency, not a latency guarantee.
Shared recompute, deduplicated
N subscribers to the same (symbol, metric, cadence) share one recompute, and metrics of the same symbol share one chain hydration and Greeks pass. Costs scale with distinct compute keys, not raw subscriber count.
Backpressure by design
One pending-update slot per subscription, latest wins. If your consumer stalls, you skip intermediate values instead of accumulating a queue, and you can detect the skip from seq.
Subscribe to what you need
A focused set of 10 to 50 metrics at a 1-second cadence behaves far better than the whole catalog at continuous. During onboarding we size your dedicated compute to the subscription set you actually plan to run.
A client in 20 lines
No SDK required: any WebSocket library works. Your endpoint URL is provisioned during onboarding.
import asyncio, json, os, websockets
API_KEY = os.environ["FA_API_KEY"]
ENDPOINT = "wss://<your-endpoint>/ws"
async def main():
async with websockets.connect(
ENDPOINT,
additional_headers={"X-Api-Key": API_KEY},
max_size=None,
) as ws:
for metric in ["exposure.gex.net_gex",
"exposure.gex.gamma_flip",
"flow.live.live_gex"]:
await ws.send(json.dumps({
"action": "subscribe", "symbol": "SPY",
"metric": metric, "cadence_ms": 1000}))
async for raw in ws:
f = json.loads(raw)
if f["type"] == "update":
print(f["metric"], f["value"], f["seq"])
asyncio.run(main())const WebSocket = require('ws');
const ws = new WebSocket('wss://<your-endpoint>/ws', {
headers: { 'X-Api-Key': process.env.FA_API_KEY }
});
ws.on('unexpected-response', (_req, res) => {
console.error(`handshake refused: HTTP ${res.statusCode}`);
});
ws.on('open', () => {
for (const metric of ['exposure.gex.net_gex',
'flow.live.live_gex']) {
ws.send(JSON.stringify({ action: 'subscribe',
symbol: 'SPY', metric, cadence_ms: 1000 }));
}
});
ws.on('message', (raw) => {
const f = JSON.parse(raw);
if (f.type === 'update')
console.log(f.metric, f.value, 'seq=' + f.seq);
});Backtest on history, go live on streaming
Streaming metrics map one-to-one to REST API fields, and the Historical API replays those same fields point-in-time since 2017. Validate the signal on years of history, then subscribe to the identical metric definition live. No re-derivation, no live-versus-backtest drift.
Streaming
One bundled tier, no add-on menu: dedicated node, streaming compute, and data licensing scoped to your requirement. We provision your endpoint with your engineering team, typically within days, not procurement quarters. Additional streaming capacity is added in blocks of 500 subscriptions at $1,500/mo per block.
- Real-time WebSocket streaming across the full catalog, 500 concurrent subscriptions included
- Dedicated node and streaming compute sized to your workload
- Commercial licence for your desk's internal research and trading
- Engineering onboarding, direct line to the team that built it
- Expand capacity in blocks of 500 subscriptions, $1,500/mo per block
Or email [email protected] - we answer within one business day.
Internal use only. FlashAlpha-derived data may not be redistributed, embedded for third parties, published to subscribers, or white-labelled.
Streaming, honestly answered
Is FlashAlpha streaming available today?
How is streaming different from REST polling?
What can I stream?
exposure.gex.net_gex or flow.live.live_gex. Metrics that only change once a day (realized vol, historical VRP series) intentionally stay on the REST API; what streams is what actually moves intraday. The live catalog is served by the streaming engine at runtime, so clients discover it rather than hardcoding a list.