ChatGPT Plugin

0xArchive

Market data and webhooks

Brand: Unknown

Category: Pending
Primary Subcategory: Pending

Integration details

Description

Real-time and historical market data for Hyperliquid and Lighter. Research and build with tick-level order books, trades, funding, open interest, account positions, liquidation levels, and more. Set up market and wallet intelligence alerts through webhooks.

Integration type: Plugin
Verification status: Not applicable
Platform: ChatGPT
Category: Pending
Primary Subcategory: Pending
Secondary Subcategories: None listed
Brand: Unknown
Access: Account required
First tracked: 2026-11-03
Tool count: 176
Market: US

Agent DiscoverabilityChatGPT Plugin Discovery Score

ChatGPT organic discovery is live

Your score is coming

ChatGPT now suggests Plugins on its own when they match a user's request.Your Plugin Discovery Score measures how often yours appears, and it will show here as soon as it’s ready.

ChatGPT recommends Airtable when a user asks it to update a CRM. — ChatGPT surfaces Airtable because it matches the user's request.

Primary Subcategory

Competitive lineup

No Primary Subcategory assigned yetOnce 0xArchive has a Primary Subcategory, the Plugins and Connectors it competes with will appear here with their scores.

Tools

176 tools agents can invoke

Watch an address so its account.* events are detected and delivered to your account.* subscriptions. Re-adding an address you already watch is a no-op. Hyperliquid bridge system addresses (0x2000... token addresses and 0x2222...2222) are refused with an explanation: they are counterparties to every Core to EVM move of a token, not accounts; watch the account on your side of the bridge instead. Watching an address changes what is detected, not what is delivered: a subscription still has to name the event type, and an account.* rule with no addresses of its own covers every address you watch. Stop watching one with delete_webhook_watched_address. Plan allowance, as endpoints / subscriptions / watched wallets / deliveries per day: Build and the Build trial 1 / 8 / 2 / 5,000; Pro 4 / 40 / 15 / 50,000; Scale 12 / 200 / 50 / 500,000; Enterprise is negotiated. Free has no webhook delivery at all (0 / 0 / 0 / 0), so creating an endpoint, a subscription or a watched wallet is refused on Free, and a plan string the server does not recognise is treated the same way. Free does keep both previews: estimate_webhook_subscription and dry_run_webhook_subscription answer on every plan, so a rule can be designed and sized before there is anywhere to deliver it. get_webhook_limits reports what this account has used and has left.
add_webhook_watched_address
Register a public HTTPS URL to receive webhook events. Returns the endpoint and its signing secret exactly once; store the secret. Each delivery is a POSTed JSON body {id, type, schema_version, observed_at, late_ms, late, data} with an '0xa-signature' header of the form t=<unix seconds>,v1=<hex>, where v1 is HMAC-SHA256 over '<t>.<raw body>' with the secret. late is true when the occurrence was more than 10 minutes old when it was queued (the engine or a feed was catching up); late_ms is that age in milliseconds; both are absent on export.job.*, webhook.test and the per-symbol archive/ingest events. Plain http, loopback and private-network destinations are rejected, at create time and again on every dispatch. The secret is returned by this call and never again by any list or get, so store it before doing anything else; rotate_webhook_endpoint_secret is the only way to get another one, and it replaces this one. A new endpoint is active straight away but receives nothing until a subscription points at it (create_webhook_subscription); test_webhook_endpoint proves the receiver and its signature check before any real rule depends on it. Plan allowance, as endpoints / subscriptions / watched wallets / deliveries per day: Build and the Build trial 1 / 8 / 2 / 5,000; Pro 4 / 40 / 15 / 50,000; Scale 12 / 200 / 50 / 500,000; Enterprise is negotiated. Free has no webhook delivery at all (0 / 0 / 0 / 0), so creating an endpoint, a subscription or a watched wallet is refused on Free, and a plan string the server does not recognise is treated the same way. Free does keep both previews: estimate_webhook_subscription and dry_run_webhook_subscription answer on every plan, so a rule can be designed and sized before there is anywhere to deliver it. get_webhook_limits reports what this account has used and has left.
create_webhook_endpoint
Subscribe an endpoint to an event type with your own configuration; the subscription starts enabled. Scope with venue and symbols where the event declares those filters, and with addresses (a subset of your watched addresses) for account.* events. Add conditions over the metrics the event declares (all must hold) and params where it declares them; anything undeclared, off-menu or out of range is rejected with an error that names what is allowed. No conditions means every occurrence: account.fill with no conditions is every fill of a watched address. Read list_webhook_event_types first for the declaration, and use dry_run_webhook_subscription to see what the same configuration would have matched recently before creating it. Event types with live=false cannot be subscribed yet. Destructive through its effect: the subscription starts enabled, so matching events begin delivering to the endpoint's receiver at once, and a delivered event cannot be recalled; dry_run_webhook_subscription and estimate_webhook_subscription preview what it would send. Plan allowance, as endpoints / subscriptions / watched wallets / deliveries per day: Build and the Build trial 1 / 8 / 2 / 5,000; Pro 4 / 40 / 15 / 50,000; Scale 12 / 200 / 50 / 500,000; Enterprise is negotiated. Free has no webhook delivery at all (0 / 0 / 0 / 0), so creating an endpoint, a subscription or a watched wallet is refused on Free, and a plan string the server does not recognise is treated the same way. Free does keep both previews: estimate_webhook_subscription and dry_run_webhook_subscription answer on every plan, so a rule can be designed and sized before there is anywhere to deliver it. get_webhook_limits reports what this account has used and has left. Deliveries per day are counted per account across every endpoint, from the moment a delivery is queued, so retries of one event are not counted twice. When an account goes past its allowance the subscription that crossed it is paused and reports that it is paused, instead of events being dropped with nothing to show for it. A paused rule delivers nothing and buffers nothing: resuming it through the 0xArchive webhooks API (one rule, or every paused rule at once; https://docs.0xarchive.io/webhooks) puts it back into service, and the occurrences from the paused window are recovered by reading the REST archive for the same event type and filters over that window. Relative metrics: market.liquidation, account.liquidated, account.fill and market.liquidation_burst also declare notional_pct_volume_1h and notional_pct_volume_24h (the event's notional as a percent of the market's trailing 1 hour or 24 hour volume; null while that volume is under 10k USD) and notional_pct_oi (percent of the market's current open interest; null on spot), and account.fill adds notional_pct_wallet_volume_30d (percent of the wallet's own 30 day volume). Example: {"metric": "notional_pct_volume_1h", "op": ">=", "value": 2} is a liquidation of at least 2 % of the market's hourly volume; notional_pct_oi >= 1 is at least 1 % of open interest. market.liquidation_burst sizes its threshold with threshold_mode (usd, pct_oi or pct_volume_1h; default usd): threshold_usd in usd mode, threshold_pct (a percent, default 1) in the other two, e.g. params {"window_s": 300, "threshold_mode": "pct_oi", "threshold_pct": 0.5}. Call estimate_webhook_subscription before creating or changing a subscription to see how often the configuration would have fired per day.
create_webhook_subscription
Delete an endpoint permanently. Destructive and not reversible: delivery to that URL stops at once, every subscription pointing at it is deleted with it, its delivery history goes too, and its signing secret cannot be recovered. Confirm with the customer before calling it. To stop delivery without losing anything, switch the rules off instead with update_webhook_subscription enabled false, or delete only the one rule you no longer want with delete_webhook_subscription. Deleting frees an endpoint slot against the plan allowance. Returns the deleted endpoint id.
delete_webhook_endpoint
Delete a subscription permanently. Destructive and not reversible: the rule stops firing at once and its configuration is gone, so a rule that took tuning is worth reading back with list_webhook_subscriptions before it is deleted. To stop delivery for a while and keep the configuration, call update_webhook_subscription with enabled false and turn it on again later. The endpoint and every other rule on it are untouched, and deleting frees a subscription slot against the plan allowance. Returns the deleted subscription id.
delete_webhook_subscription
Stop watching an address. Destructive: account.* detection for that address stops at once, and any subscription whose configuration names it stops matching it, while the subscription itself stays in place and keeps its slot. Takes the watched-address id from list_webhook_watched_addresses, not the 0x address itself. Nothing is backfilled if the address is watched again later: events from the unwatched window were never detected, so read them from the REST archive instead. Frees a watched wallet slot against the plan allowance. Returns the deleted id.
delete_webhook_watched_address
Replay a subscription configuration over real recent data without creating anything: the engine runs the same scan and matcher it uses live over the last lookback_s seconds and returns the occurrences that would have been delivered, newest first. Use it to check thresholds, conditions and symbols before create_webhook_subscription or update_webhook_subscription. Takes the same configuration as create minus endpoint_id and is validated the same way. Available today for account.fill, account.transfer and market.liquidation; other event types are refused with the supported list, and account.* types need at least one watched address. At most 6 dry-runs per minute per account; a 503 means the engine is temporarily unavailable, retry shortly. Returns event_type, window {from, to} (from moves later when a capped scan did not reach the requested start), matched, truncated (more matched than returned, or a scan hit its cap) and occurrences [{observed_at_estimate, data}], where data is what a delivery's data field would contain. Use estimate_webhook_subscription for the per-day rate over up to 30 days. Relative metrics: market.liquidation, account.liquidated, account.fill and market.liquidation_burst also declare notional_pct_volume_1h and notional_pct_volume_24h (the event's notional as a percent of the market's trailing 1 hour or 24 hour volume; null while that volume is under 10k USD) and notional_pct_oi (percent of the market's current open interest; null on spot), and account.fill adds notional_pct_wallet_volume_30d (percent of the wallet's own 30 day volume). Example: {"metric": "notional_pct_volume_1h", "op": ">=", "value": 2} is a liquidation of at least 2 % of the market's hourly volume; notional_pct_oi >= 1 is at least 1 % of open interest. market.liquidation_burst sizes its threshold with threshold_mode (usd, pct_oi or pct_volume_1h; default usd): threshold_usd in usd mode, threshold_pct (a percent, default 1) in the other two, e.g. params {"window_s": 300, "threshold_mode": "pct_oi", "threshold_pct": 0.5}. Call estimate_webhook_subscription before creating or changing a subscription to see how often the configuration would have fired per day.
dry_run_webhook_subscription
Put an endpoint back into service after delivery to it stopped. The dispatcher disables an endpoint on its own after 10 consecutive failed deliveries spanning at least 6 hours; while it is disabled nothing is delivered to it and redeliver_webhook_delivery is refused, so an endpoint whose status is not active is the first thing to check when events go quiet. Use it once the receiver is actually fixed: read list_webhook_endpoints for status and consecutive_failures, fix the receiver, enable, then test_webhook_endpoint to prove it before the real rules resume. Enabling clears the failure counter, so a fresh failure run starts from zero. It does not replay anything: nothing was buffered while the endpoint was off, and that gap is recovered by reading the REST archive over the window. Subscriptions keep their own enabled flag, so a rule that was switched off stays off. Destructive in the MCP sense: enabling clears the failure counter and restarts delivery; repeating it changes nothing more. Returns the endpoint id and its new status.
enable_webhook_endpoint
Estimate how often a subscription configuration would have fired over the last lookback_days days, per day, without creating anything: the engine counts the occurrences this exact configuration (the same venue, symbols, addresses, params and conditions you would give create_webhook_subscription) would have delivered and adds a threshold ladder so you can pick a rate before subscribing. Returns event_type, window {from, to}, days, total, per_day [{date, count}] (oldest first; days with nothing are present with count 0), per_day_p50, per_day_max, primary_metric (the metric the ladder steps over, such as notional_usd; null when the event has none), ladder [{value, per_day}] (ten ascending values of primary_metric with the fires per day each would give if used as the threshold; read it as 'at value X this fires about per_day times a day'; empty when there is no ladder), distribution {n, p50, p90, p99, max} of primary_metric across the matched occurrences (null when there were none), sample (up to 5 [{observed_at_estimate, data}], data being what a delivery's data field would contain) and basis {mode, note}: exact means every occurrence in the window was counted, sampled means the counts are approximate, taken from a sample of the window, replayed means the detector was re-run over history, which is how windowed types such as market.liquidation_burst are counted; note carries any caveat. Supported today: account.fill, account.transfer, account.liquidated, market.liquidation, market.pga_payment, hip4.settlement, market.liquidation_burst, market.oi_delta, oracle.jump and market.funding_flip; other event types are refused with the supported list. account.* types count only your watched addresses. Validated exactly like create. Shares the budget of dry_run_webhook_subscription: at most 6 calls per minute per account across both; a 503 means the estimator is temporarily unavailable, retry shortly. Use dry_run_webhook_subscription to inspect individual recent occurrences and this tool to size the rate.
estimate_webhook_subscription
Get the position change log for one account over [start, end): one row per fill leg on the account, with side (B/A as in trades), price, size, start_position, end_position, entry_price_after, event_type (how the leg changed the position), cause, fee, fee_token, trade_id, order_id, opened_at and continuity (ok, inferred, first_seen or quarantined). hyperliquid and hip3 rows add direction, closed_pnl, crossed and seq (plus block_number and event_index where recorded); Lighter rows add realized_pnl, is_maker, position_size_before, position_size_after, fee_rate, fee_usdc and usdc_amount (fee_token USDC on lighter, USDG on rh-lighter). Coverage: hyperliquid from 2025-05-25, hip3 from 2025-10-13, lighter from 2025-01-17, rh-lighter from 2026-06-26. end is clamped to meta.built_through (meta.clamped_to when it was); rows with finalized false are newer than meta.finalized_through and can still change. Pass address (hyperliquid, hip3) or account_index (lighter, rh-lighter). start and end are required and must stay unchanged while paging. Numbers are decimal strings. Paging: limit defaults to 100 (max 1000). While nextCursor is present, call again with the same arguments plus cursor=nextCursor; the cursor is bound to the venue, account or market, filters and time bounds, so change nothing else. A page can be short or empty and still carry nextCursor; stop only when it is absent. A 409 snapshot_advanced error means the snapshot being paged was replaced: restart without a cursor. Metered like trades: 1,000 rows per credit.
get_account_position_changes
Get the open perp positions of one account: a Hyperliquid or HIP-3 wallet (address) or a Lighter mainnet or Lighter on Robinhood Chain account (account_index). Omit timestamp for the latest live snapshot (refreshed every 5 minutes on hyperliquid and hip3, every 2 minutes on Lighter venues; meta.stale is true, with a meta.notice, when the latest one is more than 12 minutes old). With timestamp, returns the state after every event strictly before that instant: an exact UTC hour with a committed snapshot serves that snapshot (meta.source snapshot); any other instant is reconstructed from the change log (meta.source reconstructed: size, entry_price and opened_at exact, mark fields at that instant, snapshot-only fields null) and clamped to meta.built_through (meta.clamped_to when it was). Returns data.positions, data.account (account totals on the first page of a snapshot read; hip3 needs dex or a dex-prefixed symbol and Lighter venues no symbol filter; null for reconstructions) and, when there are no positions, data.account_seen: flat, never_seen or outside_coverage. Coverage: hyperliquid from 2025-05-25, hip3 from 2025-10-13, lighter from 2025-01-17, rh-lighter from 2026-06-26; an earlier timestamp returns no positions with meta.notice and meta.coverageFrom. Each position has a signed size (negative when short) and side long or short; hyperliquid and hip3 rows fill the leverage value, margin, liquidation price (with liquidation_price_status) and funding, which are null on Lighter venues; Lighter rows add account_index, account_kind, margin_mode and finalized. Numbers are decimal strings. Quality: each row carries its own quality. hyperliquid and hip3 rows read complete, partial (a missing mark or entry leaves value or PnL null) or degraded. On lighter and rh-lighter, rows built from trades newer than the daily reconcile (meta.finalized_through) read preliminary with finalized false and turn complete once it runs; they can also read partial, incomplete, degraded or unreconciled (a market with no reconciled trades). meta.quality is the status of the snapshot served: normally complete on hyperliquid and hip3, while the latest lighter and rh-lighter snapshots can read degraded before that reconcile even when every returned row is complete or preliminary. Paging: limit defaults to 100 (max 1000). While nextCursor is present, call again with the same arguments plus cursor=nextCursor; the cursor is bound to the venue, account or market, filters and time bounds, so change nothing else. A page can be short or empty and still carry nextCursor; stop only when it is absent. A 409 snapshot_advanced error means the snapshot being paged was replaced: restart without a cursor. Metered like trades: 1,000 rows per credit.
get_account_positions
Get hourly position history for one account over [start, end): one row per open position per committed hour, each with snapshot_ts. Hourly history begins 2026-06-07 on hyperliquid and hip3, 2025-01-17 on lighter and 2026-06-26 on rh-lighter; an earlier window returns no rows, so for an earlier instant use get_account_positions with timestamp. Pass address (hyperliquid, hip3) or account_index (lighter, rh-lighter). start and end are required and must stay unchanged while paging. Optional symbol filter, and dex on hip3. meta.finalized_through marks how far the data is final. Rows carry the position fields of get_account_positions. Numbers are decimal strings. Quality: each row carries its own quality. hyperliquid and hip3 rows read complete, partial (a missing mark or entry leaves value or PnL null) or degraded. On lighter and rh-lighter, rows built from trades newer than the daily reconcile (meta.finalized_through) read preliminary with finalized false and turn complete once it runs; they can also read partial, incomplete, degraded or unreconciled (a market with no reconciled trades). meta.quality is the status of the snapshot served: normally complete on hyperliquid and hip3, while the latest lighter and rh-lighter snapshots can read degraded before that reconcile even when every returned row is complete or preliminary. Paging: limit defaults to 100 (max 1000). While nextCursor is present, call again with the same arguments plus cursor=nextCursor; the cursor is bound to the venue, account or market, filters and time bounds, so change nothing else. A page can be short or empty and still carry nextCursor; stop only when it is absent. A 409 snapshot_advanced error means the snapshot being paged was replaced: restart without a cursor. Metered like trades: 1,000 rows per credit.
get_account_positions_history
Get the account summary of one account at the latest live snapshot: a Hyperliquid or HIP-3 wallet (address) or a Lighter mainnet or Lighter on Robinhood Chain account (account_index). hyperliquid and hip3 rows carry the clearinghouse fields account_value, cross_account_value, collateral, total_margin_used, cross_maintenance_margin_used, withdrawable (null outside the periods it was captured), account_mode (standard, unified, portfolio, dex_abstraction or unknown) and snapshot_as_of, which can be null where they were not captured, plus the position totals total_position_value, total_unrealized_pnl, long_value, short_value and n_positions. hip3 keeps one account per dex: one row per dex, named by dex; pass dex to read one. Lighter venues return position aggregates only, not balances: account_index and the same position totals. A total is null when a position in it has no mark (the row's quality then reads partial), never a partial sum; quality is complete, partial or degraded. Numbers are decimal strings. An account with nothing recorded returns no rows on hyperliquid and hip3 and a row of zeros on Lighter venues. meta carries as_of, snapshot_ts, source, quality and stale (true, with a meta.notice, when the latest snapshot is more than 12 minutes old). For hourly summaries over a window use get_account_summary_history; for the positions themselves use get_account_positions. Billed at 1 credit per request.
get_account_summary
Get hourly account summaries of one account over [start, end): one row per committed hour, each with snapshot_ts, carrying the fields of get_account_summary. Hourly history begins 2026-06-07 18:00 UTC on hyperliquid and hip3, 2025-01-17 on lighter and 2026-06-26 on rh-lighter; an earlier window returns no rows. On Lighter venues an hour with no open position reads as zeros. Pass address (hyperliquid, hip3) or account_index (lighter, rh-lighter). start and end are required and must stay unchanged while paging; dex restricts hip3 to one dex. There is no symbol filter. meta.finalized_through marks how far the data is final. hyperliquid and hip3 rows carry the clearinghouse fields account_value, cross_account_value, collateral, total_margin_used, cross_maintenance_margin_used, withdrawable (null outside the periods it was captured), account_mode (standard, unified, portfolio, dex_abstraction or unknown) and snapshot_as_of, which can be null where they were not captured, plus the position totals total_position_value, total_unrealized_pnl, long_value, short_value and n_positions. hip3 keeps one account per dex: one row per dex, named by dex; pass dex to read one. Lighter venues return position aggregates only, not balances: account_index and the same position totals. A total is null when a position in it has no mark (the row's quality then reads partial), never a partial sum; quality is complete, partial or degraded. Numbers are decimal strings. Paging: limit defaults to 100 (max 1000). While nextCursor is present, call again with the same arguments plus cursor=nextCursor; the cursor is bound to the venue, account or market, filters and time bounds, so change nothing else. A page can be short or empty and still carry nextCursor; stop only when it is absent. A 409 snapshot_advanced error means the snapshot being paged was replaced: restart without a cursor. Billed at 1 credit per request.
get_account_summary_history
Hyperliquid perps market breadth history: minute-cadence snapshots of the percent of eligible perp instruments above their UTC-session VWAP, ascending with cursor pagination (default range: last 24h). Optional interval downsampling returns the LAST stored snapshot in each bucket (percentages are never averaged: denominators vary between snapshots). History begins 2026-08-31.
get_breadth_above_vwap
Hyperliquid perps market breadth: the latest snapshot of the percent of eligible perp instruments trading above their current UTC-session VWAP (session resets 00:00 UTC; VWAP from candle quote/base volume; comparison price is the last completed 1-minute candle close). Market-level, no symbol. value_pct is null when no instrument is eligible (never rendered as 0%). Includes auditable counts (candidates, eligible, above/at/below, exclusions), and coverage_ratio. Perps have no builder namespaces, so the namespaces maps are always empty objects. Minute-cadence; history begins 2026-08-31.
get_breadth_above_vwap_current
Get Hyperliquid OHLCV candle data for a coin. Intervals: 1m, 5m, 15m, 30m, 1h, 4h, 1d, 1w (default 1h). Returns open, high, low, close, volume. Archive from March 2025 (Build and above; Free covers the most recent rolling 30 days). Earlier candles derive from incomplete fill history and are not served.
get_candles
List what each venue serves: one row per venue and datatype with rest_routes, ws_channels, live and replay (WebSocket live streaming and historical replay), available_from (the first instant served, RFC 3339 UTC; null where the API states none), cadence, page_limit (most rows per page), intervals (accepted bucket widths) and notes. Each row adds mcp_tools, the tools on this server that read that datatype on that venue (empty for WebSocket-only data). Market tools are named get_<venue>_<datatype> with core Hyperliquid unprefixed (get_trades, get_hip3_trades, get_spot_trades, get_lighter_trades, get_rh_lighter_trades); account tools such as get_account_positions take a venue argument. Filter with venue and datatype. Venues: hyperliquid, hip3, hip4, spot, lighter, rh-lighter. Costs no credits.
get_capabilities
Get Hyperliquid cumulative volume delta (CVD) for a coin: taker buy and sell notional per time bucket, their difference and a running total. Each bucket carries timestamp (its open time, RFC 3339 UTC) and timestamp_ms (the same instant in Unix milliseconds), buy_volume and sell_volume (taker buy and taker sell notional), delta (buy_volume minus sell_volume) and cumulative_delta (a running total of delta). A bucket with no trades is omitted. Intervals: 1m, 5m, 15m, 30m, 1h (default), 4h, 1d, 1w. 1m to 30m buckets are summed from taker fills and always cover their full interval. 1h and longer roll up hourly totals; 4h, 1d and 1w buckets open on UTC epoch boundaries (so 1w buckets open on Thursdays), and the first and last buckets of a window can be partial. cumulative_delta restarts on every page: to join pages, rebuild it from delta (meta.notice says when a response is one page of several). Omit start for the newest buckets of the 24 hours before end, in one page with no cursor. For a fixed window pass start and end; while nextCursor is present, call again with cursor=nextCursor and the same coin, start, end and interval. A page can be short and still carry nextCursor, so stop only when it is absent. Up to 500 buckets per page by default (limit, max 1000). Values are JSON numbers. Metered at 1 credit per request.
get_cvd
Get data coverage across supported venue APIs. Returns earliest/latest timestamps, total records, symbol count, resolution, lag, and completeness per data type per venue scope.
get_data_coverage
List data quality incidents (outages, gaps, degradations). Filter by status, exchange, or time. Returns incident details including severity, affected data types, duration, root cause, and resolution.
get_data_incidents
Get current latency metrics for supported venue APIs. Returns WebSocket latency (current, 1h avg, 24h avg), REST API latency, and data freshness lag per data type (orderbook, fills, funding, OI).
get_data_latency
Get the current system status for supported venue APIs and data types. Returns overall health (operational/degraded/outage), per-scope status with latency, per-data-type completeness, and active incident count.
get_data_quality_status
Get SLA compliance report for a given month. Returns uptime, data completeness, API latency P99, each with target vs actual and met/missed status. Also shows incident count and total downtime.
get_data_sla
Get data coverage for a specific venue scope. Returns earliest/latest timestamps, total records, symbol count, resolution, and completeness per data type.
get_exchange_coverage
Get data freshness for a coin across all data types (orderbook, trades, funding, OI, liquidations). Shows when each data type was last updated and current lag.
get_freshness
Get the current Hyperliquid funding rate for a coin. Returns the latest funding rate, premium, and timestamp.
get_funding_current
Get Hyperliquid funding rate history for a coin over a time range. Returns timestamped funding rates and premiums. Archive from May 2023 (Build and above; Free covers the most recent rolling 30 days). Supports aggregation intervals (1m, 5m, 15m, 30m, 1h, 4h, 1d).
get_funding_history
HIP-3 market breadth history: minute-cadence snapshots of the percent of eligible HIP-3 instruments above their UTC-session VWAP, ascending with cursor pagination (default range: last 24h). Optional interval downsampling returns the LAST stored snapshot in each bucket (percentages are never averaged: denominators vary between snapshots). Each row carries value_pct (null when nothing was eligible), auditable counts, coverage_ratio, and per-namespace breakdowns. History begins 2026-08-28.
get_hip3_breadth_above_vwap
HIP-3 market breadth: the latest snapshot of the percent of eligible HIP-3 instruments trading above their current UTC-session VWAP (session resets 00:00 UTC; VWAP from candle quote/base volume; comparison price is the last completed 1-minute candle close). Market-level, no symbol. value_pct is null when no instrument is eligible (never rendered as 0%). Includes auditable counts (candidates, eligible, above/at/below, exclusions for zero session volume and stale prices >5 min), coverage_ratio, and per-builder-namespace breakdowns. Instruments outside their underlying market hours (e.g. cash:* US equities overnight) are excluded as stale, so coverage varies by time of day. Snapshots are minute-cadence; history begins 2026-08-28.
get_hip3_breadth_above_vwap_current
Get HIP-3 OHLCV candle data. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Intervals: 1m to 1w (default 1h). Returns open, high, low, close, volume.
get_hip3_candles
Get HIP-3 cumulative volume delta (CVD) for a builder-perp market: taker buy and sell notional per time bucket, their difference and a running total. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Each bucket carries timestamp (its open time, RFC 3339 UTC) and timestamp_ms (the same instant in Unix milliseconds), buy_volume and sell_volume (taker buy and taker sell notional), delta (buy_volume minus sell_volume) and cumulative_delta (a running total of delta). A bucket with no trades is omitted. Intervals: 1m, 5m, 15m, 30m, 1h (default), 4h, 1d, 1w. 1m to 30m buckets are summed from taker fills and always cover their full interval. 1h and longer roll up hourly totals; 4h, 1d and 1w buckets open on UTC epoch boundaries (so 1w buckets open on Thursdays), and the first and last buckets of a window can be partial. cumulative_delta restarts on every page: to join pages, rebuild it from delta (meta.notice says when a response is one page of several). Omit start for the newest buckets of the 24 hours before end, in one page with no cursor. For a fixed window pass start and end; while nextCursor is present, call again with cursor=nextCursor and the same coin, start, end and interval. A page can be short and still carry nextCursor, so stop only when it is absent. Up to 500 buckets per page by default (limit, max 1000). Values are JSON numbers. Metered at 1 credit per request.
get_hip3_cvd
Get data freshness for a HIP-3 coin across all data types (orderbook, trades, funding, OI). Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Shows when each data type was last updated and current lag.
get_hip3_freshness
Get HIP-3 funding rate history. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Returns timestamped funding rates over a time range. Supports cursor pagination and aggregation intervals (1m, 5m, 15m, 30m, 1h, 4h, 1d).
get_hip3_funding
Get the current HIP-3 funding rate for a coin. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Returns the latest funding rate and timestamp.
get_hip3_funding_current
Get details for a single HIP-3 instrument. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Returns mark price, open interest, mid price, and latest timestamp.
get_hip3_instrument
List all available HIP-3 builder perp instruments on Hyperliquid. HIP-3 symbols are CASE-SENSITIVE (e.g. 'km:US500', 'km:TSLA'). Use this to discover valid symbols before querying HIP-3 data. Optional query/limit/cursor support bounded current-catalog discovery; follow nextCursor when present. Membership may change between calls.
get_hip3_instruments
Get HIP-3 L2 tick-level orderbook diffs. Symbols are CASE-SENSITIVE. Returns price-level changes.
get_hip3_l2_diffs
Get HIP-3 L2 full-depth orderbook. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Returns aggregated price levels. Derived from L4 data.
get_hip3_l2_orderbook
Get HIP-3 L2 full-depth orderbook checkpoints. Symbols are CASE-SENSITIVE. Returns periodic aggregated snapshots.
get_hip3_l2_orderbook_history
Get HIP-3 L4 orderbook diffs. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Returns raw order-level changes over a time range. New-order diff records may include an optional insert_before field (an order ID, or null): for ALO orders granted queue priority, it names the resting order this one is inserted ahead of within its price level; null or absent means tail append (populated from 2026-07-21 onward).
get_hip3_l4_diffs
Get HIP-3 L4 orderbook reconstruction. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Returns full order-level orderbook at a specific timestamp. Each resting order carries its queue time as timestamp (RFC 3339 UTC, null when unknown) and timestampMs (Unix milliseconds, 0 when unknown).
get_hip3_l4_orderbook
Get HIP-3 L4 orderbook checkpoints. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Returns periodic full order-level orderbook snapshots.
get_hip3_l4_orderbook_history
Get HIP-3 projected forced-liquidation levels for a coin: where open positions are estimated to liquidate, computed from clearinghouse positions and margin state, bucketed around the snapshot mark price. Snapshots refresh about every 5 minutes (snapshot_ts, RFC 3339 UTC with snapshot_ts_ms in Unix milliseconds, identifies the one served); pass at= (epoch ms) for a point-in-time read. History begins 2026-07-27. NOT the pending trigger-order map (see get_hip3_trigger_levels). Symbols are CASE-SENSITIVE (e.g. 'xyz:TSLA').
get_hip3_liquidation_levels
Get historical HIP-3 liquidation-levels snapshots (about every 5 minutes, retained from 2026-07-27), ascending by snapshot_ts (RFC 3339 UTC, with snapshot_ts_ms in Unix milliseconds) with cursor pagination. summary=true lists snapshots without histograms. Symbols are CASE-SENSITIVE (e.g. 'xyz:TSLA').
get_hip3_liquidation_levels_history
Get aggregated HIP-3 liquidation volume for a coin in time-bucketed intervals. Returns total, long, and short USD volumes. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Archive from December 2025 (Build and above; Free covers the most recent rolling 30 days).
get_hip3_liquidation_volume
Get HIP-3 liquidation events for a coin over a time range. Returns liquidated/liquidator addresses, price, size, side, and PnL. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Archive from December 2025 (Build and above; Free covers the most recent rolling 30 days). Real-time HIP-3 liquidations are also available on the WebSocket `hip3_liquidations` channel; each event is a fill row with `is_liquidation: true`, same shape as the `hip3_trades` channel.
get_hip3_liquidations
Get the current HIP-3 open interest for a coin. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Returns OI, mark price, and oracle price.
get_hip3_open_interest
Get HIP-3 open interest history over a time range. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Returns timestamped OI snapshots.
get_hip3_open_interest_history
Get the instantaneous price discovery bounds of a HIP-3 market: lower_bound and upper_bound sit bound_fraction below and above reference_price, where reference_price is the deployer's external price when one is available and otherwise the mark price (reference_source: external or mark) and bound_fraction derives from the market's max_leverage. Returned with the block_number and the time of the inputs: timestamp (RFC 3339 UTC) and timestamp_ms (Unix milliseconds). These are the bounds at this instant only: the full ratcheted range can be wider when the deployer's reset configuration applies. Symbols are CASE-SENSITIVE (e.g. 'km:US500'). Values are JSON numbers. Metered at 1 credit per request.
get_hip3_oracle_discovery_bounds

FAQs

0xArchive ChatGPT Plugin FAQ

How the directory, categories and Discoverability Score work.

Read the methodology

How do I improve 0xArchive's ChatGPT Plugin discoverability?

The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.

Where is this profile measured?

This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.