Watch Hyperliquid market state in one packet-native workspace.
Etna Monitor shows depth, trades, pressure, crowding, and fragile-book behavior as packet cards you can inspect before anything routes. The packet is still the product: every read carries evidence, replay, quality context, and API paths.
- Market-state context only. Not financial advice.
- No custody, no execution, no raw data resale by default.
Etna Monitor + packet API
Watch first. Route later.
Use the hosted workspace as the front door, then wire the same packet contract into alerts, dashboards, agents, and research loops once the read proves useful.
01 / Agents
Give agents state they can cite.
State, reasons, evidence, replay cursor, and allowed routes without asking an agent to infer from raw rows.
02 / Desks Monitor the read, then reopen the event.Pressure, crowding, fragility, and flow context stay attached for alerts, review, webhooks, and notes.
03 / Researchers Compare retained windows instead of screenshots.Search packet lineage, replay the window, export review sets, and separate routine noise from real state changes.
Inspect proof below
Wire mock schema
Run live after key
Same move. From raw tape to market-state context. Rows show what
happened. Etna Alpha keeps the state, reasons, evidence, replay
identity, and routes attached.
Live proof fills in row counts, window length, and the work left after delivery.
Public proof is customer-safe; full packet routes remain after-key and metered.
What the buyer gets
Market data gives you the tape. Etna Alpha gives your system the market read.
Providers deliver the tape. Etna Alpha turns the same move into one reviewable object: what changed, why it changed, what evidence is attached, and where the packet can route next.
Useful infrastructure, but your systems still have to turn the tape into state, reasons, replay, and route-ready context.
dataset still needs interpretation
The packet is the usable object: compact enough for systems, explicit enough for review, and structured enough for agents.
market_state.v1
Inspect the public proof, work one packet in the hosted Monitor, then use an API-plan key for latest, Workbench, replay, webhook, usage, and feedback receipts.
proof -> monitor -> key -> route
Choose the workflow
One packet, three first-use paths.
Start from the workflow you actually want live, then inspect a concrete packet and pick the plan that fits. The same packet shape can brief an agent, operate a desk monitor, or seed a replay set.
Agents
Read-only context for systems
Give agents and MCP clients bounded state, reasons, evidence, replay, and allowed route context.
Desks
Monitor, route, replay
Run a five-symbol market-state workflow with webhook tests and review receipts.
Research
Replay and export packet sets
Compare tagged windows across the active launch universe.
Why desks use it
Venue data moves quickly. Etna Alpha labels the state.
Price, trades, and depth are necessary. They are not the full condition of the market. Etna Alpha watches Hyperliquid book behavior and emits tagged packets your systems can keep open, route, replay, and review.
Packet reads carry replay context. Each packet carries the current window, state label, confidence, usage context, and the handles your systems need to inspect it again later.
- Read-only API
- Derived packets
- Evidence visible
- Replayable receipts
- Usage visible before expansion
What the packet replaces
The ingestion tax is everything before the market is usable.
Venue flow gives prices, trades, depth, and updates. Your team still has to reconstruct the read, compute features, label state, attach evidence, build replay, route alerts, and prove what happened later.
Venue events have to become a usable market window before a workflow can trust them.
Timestamp, symbol, book, and trade context stay attached instead of becoming a rebuild project.
Pressure, crowding, queue fragility, depth, and replay state become compact tags and reasons.
Evidence and replay cursors travel with the read so the same event can be reopened.
Alerts, agents, dashboards, notebooks, and usage receipts point back to the same object.
Tagged state
Evidence
Replay cursor
Route receipt
Workflow note
Usage receipt
One packet, four lanes
Fast reads stay fast. Slower context attaches without blocking latest.
Etna Alpha treats market context as parallel computation. Hot-path packets keep the current read light, while short-window, session, and retained replay lanes add evidence, quality, and history.
Depth, pressure, and fragile-book context that should stay close to the live read.
~50ms lane budget
Pressure building, crowding shift, and queue fragility become stable enough to route.
~250ms lane budget
Percentile baselines and regime tags calibrate live-during-calibration instead of hiding the read.
GET /demo/compute-lanes
Replay quality, retained packet rows, and evidence handles let the same event reopen later.
GET /replay
Pre-key integration
Wire the shape before live access.
Test deterministic mock packets, Workbench responses, webhook receipts, feedback payloads, OpenAPI, and public proof routes before starting a paid live packet loop.
Live packet access starts only after paid API-plan key issuance; pre-key routes are proof and mock integration only.
GET /mock/latest
Read a stable packet object with the same auth-free shape used by docs examples.
GET /mock/packets/{event_id}/workbench
Inspect fields, evidence, replay starter, webhook receipt shape, and feedback payloads without live capacity.
GET /demo/public-proof-browser
Review buyer-safe packet stories, route boundaries, construction trace, maturity, and claim limits.
Workbench loop
Do not integrate around a screenshot. Open the packet.
The paid loop is designed around one object moving through the workflow: latest packet, Workbench, evidence, row join, replay, feedback, and usage receipt.
Call the current packet for the watched symbol.
GET /latestOpen packet fields, reasons, evidence, routes, and quality context.
GET /packets/{event_id}/workbenchReopen the same window, test delivery, and send the read into one workflow.
GET /replayReview usage, route tests, and feedback before widening symbols or volume.
POST /feedback/packetAfter checkout
Claim key, run loop, review usage from one account page.
After checkout, bind the key to an account, then monitor feature quality, usage, receipts, replay, webhooks, exports, and support from one command surface.
Bind the one-time checkout key to an email/password account without storing raw key material in the browser.
account.html?tab=claim
Call latest, open Workbench, replay context, test webhook delivery, and submit feedback from the same session.
GET /latest
See plan scope, remaining usage units, billing portal access, top-ups, export jobs, and receipt history.
GET /account/overview
Public proof
Inspect proof before checkout.
Event stories, construction trace, route boundaries, readiness, and claim limits stay visible before live packet routes require an API-plan key.
- Event stories4BTC, HYPE, ETH, DOGE review cards
- L4+ sample243h+high-detail packet context
- Replay depth292h+reviewable replay context
- Label traceDeterministicfeature reads and route receipts
- Readiness95.0public-only proof score
- Claim boundaryNo signalread-only context; no raw resale
From proof to live access
Run the live Monitor loop after proof.
Once the packet proof clicks, make it visible in the hosted workspace. Desk Monitor is the default first serious loop: five symbols, HYPE included, latest packets, Workbench evidence, replay, webhook receipts, usage, and feedback routes.
Use Monitor when the job is one BTC/ETH workspace, one replay path, one route, and a usage receipt.
Five approved symbols, HYPE included, replay, webhook receipts, and daily market-read review fit the first serious desk, agent, or dashboard loop.
Ten-symbol launch coverage, longer replay windows, exports, and packet-set review support heavier research and post-event review.
Diligence path
The review packet is public, bounded, and provider-readable.
Cloud, startup-program, processor, and design-partner reviewers can inspect the product boundary before a call: public proof, current infrastructure target, data-rights limits, and a concrete first-loop partner path.
- Infrastructure diligence and 90-day scaling plan
- GCP Tokyo target, Cloudflare edge review, Stripe payment closeout
- Private provisioning and utilization packet available on request
- Derived packet and data-rights boundary
- No raw feed resale by default
- Enterprise data delivery requires written review
- Design partner evaluation lane
- 3-5 workflow owners for dashboards, agents, alerts, or replay review
- Proof to mock to keyed packet loop
For implementation
Go deeper when you are ready to wire the loop.
The first page shows why the packet exists. The docs give your team the exact routes, SDK setup, packet examples, replay/export examples, evidence checks, and usage model needed to test it against a real desk workflow.
They also define the build envelope: API-accessible packets, replay context, catalog-backed exports, usage controls, and the data-use limits attached to API access.
Start
Packet plus row review
Request, quote, inspect evidence, read latest, check rows, replay, estimate usage.
Build
OpenAPI and SDKs
Canonical OpenAPI, Python, TypeScript, route catalog, response shape, and auth.
Wire
Watchlists, webhooks, replay
Controlled delivery, post-event review, export jobs, and briefs.
Scope
Data review and limits
Usage, data-delivery review, and legal disclosure in one place.
Packet anatomy
One packet, all the context.
One object carries the market, trigger, tags, replay handle, search key, workflow targets, and legal context. The packet is composable: each system can use the module it needs without rebuilding the market read.
The selected Hyperliquid pair and the window the packet belongs to.
Pressure, crowding, depth, replay, or source-state changes that deserve review.
market_state.v1
Versioned labels keep the read consistent across monitors, agents, and notebooks.
Replay context lets the desk inspect the setup instead of only the alert.
The same packet can be reviewed later with desk notes, dashboards, or review systems.
Search stays tied to the history currently available for review.
Alerts, APIs, reports, and workflow destinations use the same packet.
Market-state context for monitoring and review. Not financial advice.
Composable packet modules
Use the whole packet, or pull the module your workflow needs.
Monitor, Workbench, Replay, Data, Agents, and Receipts are different views over the same market-state object.
Current market read, confidence, and freshness.
Pressure, crowding, fragility, and replay labels.
Plain evidence-backed context for briefs and review queues.
Hot path, short-window, session, and replay context stay unified.
Proof route, source window, lineage hash, and taxonomy.
Event cursor and same-window route for later inspection.
Webhook, Workbench, export, feedback, and usage handles.
{
"packet_type": "market_state.v1",
"symbol": "BTCUSD-PERP",
"state": "pressure_building",
"tags": ["pressure:bid_building:hot", "pressure:bid_building:short", "depth:watch:hot"],
"reasons": [
"hot-path depth context is computed from the current normalized book snapshot",
"short-window pressure context resolves the buyer-facing state"
],
"reason_details": [
{ "reason_id": "hot_path_depth_read", "compute_lane": "hot_path", "horizon": "current_snapshot_to_5s" },
{ "reason_id": "short_window_state_read", "compute_lane": "short_window", "horizon": "30s_to_5m" }
],
"compute_lanes": [
{ "lane_id": "hot_path", "latency_budget_ms": 50, "blocking_latest_route": true },
{ "lane_id": "short_window", "latency_budget_ms": 250, "blocking_latest_route": false }
],
"confidence": "context_labeled",
"evidence": "capture_and_replay_context",
"replay": { "status": "ready", "cursor": "event_..." },
"workflow_routes": ["agent", "alert", "dashboard", "review"]
}Terminal workspaces
Route packets into your workflow.
Workspaces are not separate products. They open different packet modules for the system using them: monitor, Workbench, replay, data joins, agents, proof, usage, feedback, and receipts.
Markets
Packet review view
GET /latest
Packet monitor
BTC packet workspace
Public proof context is visible before live data hydrates.
| Symbol | Price | Pressure | Depth | Flow | Updated |
|---|---|---|---|---|---|
| BTCUSD-PERP | Public proof read | Building | Fragile | Active | current proof window |
Capture
Packet
Review
Evidence attached
Replay ready
Usage metered
Webhook tested
Review ready
Before / after
Same market. Different layer.
Venue feeds deliver events. Dashboards show charts. Etna Alpha returns a packet your systems can route, replay, and challenge.
Systems reconstruct the book, normalize timestamps, compute features, label events, build replay, and route alerts.
pricetradesdepthorder_updates
The same market becomes one logged object for alerts, agents, dashboards, research, and review.
pressure:bid_building:hotpressure:bid_building:shortcrowding_shift:activereplay:ready
Packet construction
From market window to tagged packet.
Inspect the source window, extracted features, confidence label, replay handle, and final packet before wiring the object into production.
Read the market window
Feature classes are visible without turning the page into a feed dump.
Extract state
Pressure, crowding, queue fragility, depth, and replay state are joined before delivery.
Attach labels
Tags, reasons, confidence, replay, and workflow routes move together.
Deterministic first, explainable by default.
The contract a desk logs.
Clear value, clear limits.
Included now
Quoted separately
Fetch the packet before building around it.
Quality context
Every packet carries its own confidence limits.
Serious systems need to know what to trust, what to review, and what is still calibrating. Etna keeps readiness, replay quality, threshold hygiene, weakest feature, and source boundary beside the packet.
Live-during-calibration fields stay visible with sample and route boundaries.
Replay handles travel with the packet so review is tied to the same event window.
Tags and reasons are versioned so calibration can improve without changing the product contract.
Post-checkout Workbench can show which feature family deserves review before automation expands.
First packet loop
One controlled packet loop.
Activate one account loop: request access, quote the workload, read the latest packet, inspect evidence, replay the same context, route one preview workflow, and review usage before scaling.
Account activation
The first loop proves a retained workflow, not a browsing session.
The same packet powers a monitor, webhook preview, replay review, data row join, and usage estimate.
POST /activation/request
Request access
Share the intended workflow and target symbols without committing to a broad integration.
Result: a buyer starts account activation with a clear plan and no raw-feed purchase.GET /activation/credit-quote
Quote the first workload
Estimate symbols, replay, exports, and context briefs before increasing volume.
Result: plan fit is visible before the loop starts polling.GET /latest
Read the latest packet
Pressure, crowding, fragile depth, tags, confidence, and replay cursor arrive together.
Result: monitor state without rebuilding labels from the raw stream.GET /demo/public-proof-browser
Inspect evidence context
Confidence, market window, and replay status stay visible before the packet is routed.
Result: see the evidence and usage context attached to the read.GET /replay
Replay the same context
Open the packet your system saw across the event window.
Result: turn the packet into review material instead of a disposable alert.POST /webhooks/test
Route one workflow
Record a webhook test, saved search, export, or notebook path before widening delivery.
Result: test automation before committing to a broader workflow.GET /usage/estimate
Convert or stop
Estimate symbols, polling, replay, exports, and summaries before widening the loop.
Result: quote continuation from actual workload instead of guessing upfront.Live / replay / export
The same packet live, replayed, and exported.
Live
Watch tagged state as the book changes instead of waiting for a post-event reconstruction.
Route
Send state changes into alerts, dashboards, agents, watchlists, or desk review.
Replay
Review the packet your system saw across the event window.
Research
Export labeled packets without rebuilding feed plumbing first.
Detect when book pressure changes before the desk treats the tape as normal.
GET /forced-flow/latest
Track one-sided positioning context alongside the packet that triggered review.
GET /crowding-regime/latest
Surface fragile depth and queue pressure as compact packet context.
GET /microstructure/queue-fragility/latest
Reopen the packet your system saw across the event window.
GET /replay
Keep state, confidence, evidence, and workflow route together for downstream systems.
GET /risk-graph/latest
Event replay
Show the packet across the full event window.
Review real packet stories: what changed, what evidence was attached, which routes reopened the event, and what the workflow did next.
Example event
BTCUSD-PERP pressure changed while depth weakened.
Evidence and freshness
Show enough context before a desk widens the loop.
A useful market read needs more than a label. Etna Alpha returns the market window, replay depth, confidence, and usage context beside the packet so buyers can decide where it belongs.
Coverage notes
Current monitoring and deeper research are presented separately.
Live-during-calibration fields stay visible with sample boundaries. Keyed history inventory reports current depth and packet retention; long-horizon exactness claims remain held until measured proof clears.
Account dashboard
A client can see health, spend, and next action.
The dashboard answers the practical questions immediately: is the API live, when did the packet loop refresh, what can be replayed, what did the workload consume, and what would expand next.
History depth
Use the packet loop now; let deeper history compound.
Current monitoring and replay are useful now because the packet carries its own review window. Deeper research features stay tied to available history instead of being implied by the interface.
Capability state
Live now, calibrating, roadmap.
Current packet features stay usable while calibration, replay quality, and longer-history research mature against the captured data set.
- Tagged packet reads from current and retained rows
- Packet detail view
- Short-window replay
- Packet search over available history
- Keyed history inventory and packet retention status
- Alerts, routing, and API preview
- Local percentile baselines
- Symbol and group calibration
- Tag thresholds and noise controls
- Coverage scoring
- Replay quality checks
- Long-horizon analogs
- Long-window statistics
- Deep historical replay
- Full regime comparisons
- Bulk historical exports
Watch BTC and ETH in one workspace with one packet check, one replay, and one lightweight bot or dashboard path.
$167 per month · launch promotion Annual $1,670/yr Regular $199/mo- 1M API usage units
- BTC + ETH symbols
- 6h replay window
- $40 / 250k micro-burst packs
Recommended for active desk or agent workflows: five symbols, HYPE included, alerts, webhook receipts, and daily packet review.
$427 per month · launch promotion Annual $4,270/yr Regular $499/mo- 5M API usage units
- 5 approved symbols
- 24h replay window
- Business-day support
Replay tagged windows, export packet datasets, and brief research agents from the launch universe.
$1,297 per month · launch promotion Annual $12,970/yr Regular $1,499/mo- 30M API usage units
- 10 active symbols
- Longer replay windows
- Data exports
Contract custom capacity, private delivery, data-rights review, and support around a proven packet loop.
Custom by application Contracted capacity and support terms- SLA and uptime terms
- Private endpoints
- Dedicated support
- Data-rights review
Monitor, Desk Monitor, and Research include monthly API usage allowance with monthly or annual billing. Monitor starts with BTC and ETH, Desk Monitor covers five approved symbols with HYPE included, and Research covers the active launch universe. Active accounts can add $40 / 250k micro-burst packs for temporary overflow; sustained volume moves to a higher plan or Enterprise review. Automatic overages stay off.
Expansion recipes
Continue only where the packet loop proved useful.
After the first loop, continuation is based on the workflows that actually stuck: watched symbols, routed state changes, replay reviews, exports, and API volume.
API
Tags, evidence, confidence, and replay in one response.
Poll compact JSON where current or retained tags, reasons, confidence labels, replay cursors, and workflow routes are already attached for monitors, agents, dashboards, and research jobs.
- Pre-tagged JSON for monitors, agents, dashboards, and notebooks
- Confidence and evidence context travel with each packet
- Packet reads replay cleanly with notes, dashboards, and review
- Workflow routes stay account-scoped
Try
POST /activation/request
GET /activation/credit-quote
GET /start/first-packet
GET /workbench/current
GET /demo/activation-kit
GET /demo/public-proof-browser
GET /demo/public-packet-construction
GET /latest
GET /replay
GET /status/proof
GET /usage/estimate
POST /webhooks/test
Data Catalog
Market rows stay beside the packet, not around it.
The public data plane gives builders normalized rows, connector specs, replay windows, and join keys so the packet remains the integration center. Customers can keep their own vendor pulls while Etna Alpha supplies the replayable market-state layer.
Usage estimator
Estimate the workload before widening symbols or replay windows.
Usage units map to actual API work. Latest packet checks stay light; replay, exports, and context briefs consume more allowance.
This page is a planning estimate; GET /usage/estimate
returns the API quote for a specific route and workload.
Packet feedback loop
Every account loop should leave a packet trail.
API access should not end with a vague demo impression. The loop records what was opened, what replayed, what was useful, what was missing, and what capacity would make sense next.
Retention workflows
Turn the packet loop into a daily habit.
Retained workflows do more than call /latest. They use
packets to brief the desk, collect anomalies, reopen event windows,
and close the week with receipts.
Pricing FAQ
Fair capacity without forcing feed lock-in.
What happens when usage allowance runs low?
Requests throttle or cap according to plan settings. Additional capacity is quoted before upgrade or contract work.
Are usage units the same as API requests?
No. Latest packet checks are lightweight. Replay scans, exports, and context briefs consume more capacity.
Can this replace a data vendor?
It can reduce how much plumbing clients build around a vendor, but the core product is tagged packet context, normalized public rows, replay, exports, and workflow receipts. API access does not grant rights to resell, republish, sublicense, or redistribute raw datasets outside your organization.
What legal disclosure should compliance expect?
Etna Alpha provides market-state context for monitoring, replay, and review. Not financial advice.
Desk workflows
What clients use it for.
Example workflow
A BTC/HYPE packet loop that remembers the context.
-
1
Watch BTC and HYPE
Poll the latest packet for pressure, crowding, fragile depth, confidence, and replay status.
-
2
Alert on deterioration
Send a webhook when the packet moves from routine churn to something worth review.
-
3
Replay the event
Join the same packet with notes or dashboards to review what changed.
Sample state
A tagged packet your systems can route and challenge.
Pressure, crowding, fragile depth, replay cursor, confidence, and evidence context stay together, so the packet remains useful after the alert.
Faster triage
Surface the pairs where the tagged state has actually changed.
Cleaner reviews
Reopen the packet with market-window context, replay state, desk notes, and review context attached.
Workflow-ready state
Route labeled state and confidence context instead of raw ticks or fragmented desk notes.
Same packet
Give the desk, dashboards, agents, and research notebooks one market-state packet they can all revisit.
Evidence
Evidence-backed packets, not black-box alerts.
What is included
Your strategy stays yours. Etna Alpha supplies labeled context.
- Data use
- The API returns tagged market-state packets, normalized public rows, replay handles, and data-use scope.
- Desk use
- Designed for monitoring, alerts, replay review, dashboards, agent workflows, and research review.
- Access
- API-plan access keeps support, usage limits, and data boundaries clear.
- Legal disclosure
- Market-state context only. Not financial advice.
Account activation