---
title: "HIP-4 Outcome Market Data API | 0xArchive"
description: "Hyperliquid HIP-4 outcome market data: the price is an implied probability in [0,1], not USD. How to read, analyze, and pull it from 0xArchive."
canonical_url: "https://0xarchive.io/blog/hip4-outcome-markets-data"
markdown_url: "https://0xarchive.io/blog/hip4-outcome-markets-data.md"
route: "/blog/hip4-outcome-markets-data"
robots: "index, follow"
generated_from: "prerendered_html"
---

# HIP-4 Outcome Market Data API | 0xArchive
Hyperliquid HIP-4 outcome market data: the price is an implied probability in [0,1], not USD. How to read, analyze, and pull it from 0xArchive.
**HIP-4 outcome markets are Hyperliquid's binary prediction markets, live since May 2026. Each market asks one yes-or-no question with a fixed expiry, and the order-book price is not a dollar figure. It is an implied probability between 0 and 1. A Yes side trading at `0.67` means the market is pricing the event at a 67% chance. At expiry the outcome settles to `1` or `0`. 0xArchive carries the full HIP-4 record back to launch: order books, trades, open interest, L4, and per-outcome settlements across more than 500 outcome series. The one-sentence takeaway: read the price as a probability, store the settlement, and you can measure whether the market was right.**

## Why the price is a probability

A HIP-4 outcome market is a binary contract. It poses a single question with a hard deadline. "BTC above 78,213 on May 3 at 06:00 UTC?" Every market has two sides: a Yes side and a No side. Each contract resolves to exactly one of two values when the question is answered. Yes pays `1` if the event happens and `0` if it does not. No is the mirror.

That settlement rule is what forces the price into a probability. If a Yes contract pays `1` on success and `0` on failure, a risk-neutral price for it is just the probability of success. Buy Yes at `0.67` and you pay 0.67 to win 1.00 if the event lands. The market is telling you it thinks the event is 67% likely. Buy at `0.05` and the market is pricing a long shot at 5%.

![On a perp the price is dollars; on HIP-4 the price is an implied probability from 0 to 1](https://api.0xarchive.io/cms-assets/2026/06/bd9de6e9-9ce3-42a1-a97c-8291d865fd87.webp)

The two sides are linked. Yes and No should price close to complementary, so Yes plus No sits near `1.00`. When the pair drifts away from 1.00, that gap is a tradable signal, not noise. We come back to it below.

Here is the trap that quietly breaks analysis. HIP-4 reuses the same field names as every perp and spot market: `mark_price`, `mid_price`. On a perp, those are USD. On an outcome market, they are probabilities in `[0, 1]`. If your pipeline treats a HIP-4 `mark_price` of `0.6674` as "$0.67" and runs it through dollar-denominated PnL, returns, or volatility math, every number downstream is wrong, and nothing errors out. The values are small, positive, and plausible. The bug is silent. The fix is one rule: branch on market type before you touch the price. HIP-4 prices are probabilities. Treat them as such, then convert to odds, log-odds, or expected value, never to dollars.

## What HIP-4 data 0xArchive carries

HIP-4 is a Hyperliquid-scoped market family. It is not a separate venue and not a third venue API. It sits under the Hyperliquid namespace alongside core perps, Spot, and HIP-3, at routes beginning `/v1/hyperliquid/hip4/`. Coverage runs from May 2026, when HIP-4 went live. Do not map HIP-4 to 2023. That date belongs to Hyperliquid core perps, not to outcome markets.

Because these are settle-to-binary instruments, there is no funding and there are no liquidations on HIP-4 by design. A fully collateralized binary has no funding rate to pay and no liquidation to trigger. What HIP-4 does have is the full order and settlement record.

| Data type | Route family | Coverage start | What it gives you |
| --- | --- | --- | --- |
| Outcome discovery | `/v1/hyperliquid/hip4/outcomes` | May 2026 | Every outcome series, its question, target, expiry, and both sides |
| Order books | `/v1/hyperliquid/hip4/orderbook/{coin}` | May 2026 | L2 depth per side, with probability-priced levels |
| L4 order books | `/v1/hyperliquid/hip4/orderbook/{coin}/l4` | May 2026 | Order-level depth: every resting order on a side |
| Trades | `/v1/hyperliquid/hip4/trades/{coin}` | May 2026 | Executed fills at the implied-probability price |
| Open interest | `/v1/hyperliquid/hip4/open-interest/{coin}` | May 2026 | Contracts outstanding per side over time |
| Resolution state | `is_settled` + `status` on `/outcomes` | May 2026 | Which outcomes have settled and how; live resolution fires on the `outcome_settled` WebSocket event |

The settlement record is the part that makes outcome data worth studying. A trade tape on its own tells you what people paid. The settlement tells you whether they were right. Pair the price history with the resolved outcome and you can score the market against reality. Without the settlement, you have prices with no answer key. 0xArchive stores both, for more than 500 outcome series.

One detail on identifiers, because it bites everyone once. An outcome has an integer `outcome_id`. Each side has its own tradable `coin`, encoded as `10 * outcome_id + side`. Outcome 0 Yes is coin `0`, outcome 0 No is coin `1`, outcome 1 Yes is coin `10`, outcome 1 No is coin `11`. The bare numeric form is canonical. The older `#0` and `%230` forms still work in routes, so you will see both in the wild.

## What you can do with it

Outcome data is a different shape from perp data, so the questions are different too. Four lines of work cover most of it.

### Probability calibration

Calibration asks the core question of any forecaster: when the market says 70%, does the event happen about 70% of the time? You answer it by bucketing. Take the market-implied probability at some reference point, say the price one hour before expiry, group every outcome into probability bins (0.0 to 0.1, 0.1 to 0.2, and so on), then compare each bin's average price to the share of those outcomes that actually settled to `1`. Plot the realized frequency against the implied probability. A perfectly calibrated market sits on the 45-degree line. A market that runs above the line was underconfident. Below the line, overconfident. The Brier score, the mean squared error between price and the `0/1` outcome, gives you a single number for the same idea.

### Settlement and resolution studies

With the settlement record you can study the endgame. How fast does price converge to `1` or `0` as expiry approaches? How much does it move in the final hour? Do certain question types (a BTC price threshold versus a macro print) resolve more cleanly than others? These are settlement studies, and they need exactly two things: the full price path and the resolved value. You have both.

### Mispricing and two-sided arbitrage

Because Yes and No should sum to near `1.00`, the pair is a built-in consistency check. When best-ask Yes plus best-ask No drops below 1.00, both sides are cheap relative to the certain payout, and the gap is a spread to capture. When the sum runs above 1.00, the book is rich. Pull the L2 or L4 book for both coins of an outcome, sum the top of book, and you have a clean mispricing series across every market and every timestamp in the archive.

### Backtests and event modeling

The recurring daily BTC-threshold markets are a ready-made backtest set. You can build a strategy that reads the implied probability, compares it to your own model's probability for the same event, and takes the side where your edge is largest. Then you score it against the real settlements. Because the markets repeat daily, you get a dense, like-for-like sample instead of a handful of one-off events.

### A short worked example

Say you pull every settled BTC daily outcome and, for each one, record the Yes mid-price 60 minutes before expiry and whether it settled to `1`. You bin by implied probability and count:

| Implied probability (Yes, T-60m) | Outcomes in bin | Settled to 1 | Realized frequency |
| --- | --- | --- | --- |
| 0.10 to 0.20 | 40 | 5 | 0.125 |
| 0.40 to 0.60 | 55 | 30 | 0.545 |
| 0.80 to 0.90 | 38 | 33 | 0.868 |

Read it straight off. The middle bin is close to calibrated: an average implied probability near 0.50 against a realized 0.545. The tails look slightly underconfident, with realized frequencies sitting just outside the implied band. (The counts here are illustrative; run it on the live archive to get the real curve.) The point is the method. Implied probability in, settled outcome out, and the market grades itself.

## How to pull it

Discover outcomes first. You need the `outcome_id` and the per-side `coin` before you can ask for a book or a trade tape. Every route authenticates with an `X-API-Key` header.

List outcomes, filtering to settled ones for a calibration study:

```
curl "https://api.0xarchive.io/v1/hyperliquid/hip4/outcomes?is_settled=true&limit=100" \
  -H "X-API-Key: $OXARCHIVE_API_KEY"
```

A record looks like this. Note `target_price`, `expiry`, `is_settled`, and the two `side_specs` with their `coin` values:

```
{
  "outcome_id": 0,
  "class": "priceBinary",
  "underlying": "BTC",
  "target_price": 78213,
  "expiry": "2026-05-03T06:00:00Z",
  "is_settled": true,
  "status": "settled",
  "side_specs": [
    { "side": 0, "name": "Yes", "coin": "#0",  "slug": "btc-above-78213-yes-may-03-0600" },
    { "side": 1, "name": "No",  "coin": "#1",  "slug": "btc-above-78213-no-may-03-0600" }
  ]
}
```

Then read the implied probability for a side from its 24-hour summary. The price fields are probabilities, not dollars:

```
curl "https://api.0xarchive.io/v1/hyperliquid/hip4/summary/0" \
  -H "X-API-Key: $OXARCHIVE_API_KEY"

# legacy side form, still accepted:
curl "https://api.0xarchive.io/v1/hyperliquid/hip4/summary/%230" \
  -H "X-API-Key: $OXARCHIVE_API_KEY"
```

The response carries the probability-priced fields:

```
{ "coin": "#0", "mark_price": "0.6674", "mid_price": "0.6674", "open_interest": "873237" }
```

In Python, the calibration loop is short. Discover settled outcomes, read each Yes side near expiry, compare to the settled value:

```
import os, requests

BASE = "https://api.0xarchive.io/v1/hyperliquid/hip4"
H = {"X-API-Key": os.environ["OXARCHIVE_API_KEY"]}

# 1. discover settled outcomes
outcomes = requests.get(
    f"{BASE}/outcomes",
    params={"is_settled": "true", "limit": 100},
    headers=H,
).json()["data"]

# 2. for each Yes side, coin = 10 * outcome_id + 0
for o in outcomes:
    coin = 10 * o["outcome_id"]            # Yes side
    summary = requests.get(f"{BASE}/summary/{coin}", headers=H).json()["data"]
    p_yes = float(summary["mark_price"])   # implied probability in [0, 1], NOT usd
    print(o["display_title"], "implied:", p_yes)

# 3. read is_settled + status from /outcomes for the realized 0/1, then build the calibration curve
```

The rule to keep in the code, in a comment if nowhere else: `mark_price` here is a probability. Convert to odds with `p / (1 - p)` or to log-odds, never to dollars.

## HIP-4 vs cross-platform prediction-market data

Most prediction-market datasets cover Polymarket and Kalshi and resolve through an off-chain oracle, often hours after the event. HIP-4 settles on Hyperliquid itself, so the same API gives you the order book, every trade, the [L4 order-level depth](https://0xarchive.io/blog/hyperliquid-order-book-data-api), and the resolved outcome, all native to one venue. If your question is about Hyperliquid outcome markets, this is the only place to get the full order-level history with native settlement.

## FAQ

### Is HIP-4 a separate venue from Hyperliquid?

No. HIP-4 is a Hyperliquid market family, alongside core perps, Spot, and HIP-3. Its routes live under `/v1/hyperliquid/hip4/`. There are two venue APIs at 0xArchive: Hyperliquid and Lighter. HIP-4 is part of Hyperliquid.

### Why is the price between 0 and 1 instead of in dollars?

Because the contract settles to `1` or `0`. A price between those bounds is the market's implied probability of the event. The `mark_price` and `mid_price` fields are probabilities in `[0, 1]`, not USD. Same field names as a perp, different meaning.

### How far back does HIP-4 data go?

To May 2026, when HIP-4 launched. Order books, trades, open interest, L4, and per-outcome settlements all start there. HIP-4 history does not extend to 2023; that range applies to Hyperliquid core perps.

### Is there funding or liquidation data on HIP-4?

No, by design. HIP-4 outcomes are fully collateralized binary contracts, so there is no funding rate and no liquidation engine. If you need funding or liquidations, those live on the perp routes, not on HIP-4.

### How do I find the right Yes and No coin for a market?

Call `/outcomes` first. Each outcome has an integer `outcome_id`, and each side has a `coin` equal to `10 * outcome_id + side`. Outcome 0 Yes is `0`, outcome 0 No is `1`, outcome 1 Yes is `10`. The bare numeric form is canonical; `#0` and `%230` still work.

### How do I tell whether a market was right?

Join the price history to the settlement record. Settlements give you the resolved value per outcome. Compare the implied probability over the market's life to the `0/1` result to score calibration, accuracy, or a strategy.

### What can I build with the settlement record specifically?

Calibration curves, Brier scores, convergence-to-settlement studies, and backtests that grade a model against real resolutions. The settlement is the answer key. Prices alone cannot tell you who was right.

## Next step

Read the [HIP-4 outcome market data guide](https://docs.0xarchive.io/hyperliquid-hip4-data-api) for the full coverage map, or go straight to the [HIP-4 REST reference](https://docs.0xarchive.io/rest-api/hip4) for every route and field. When you are ready to run a calibration study across the archive, the full HIP-4 record is on every plan. See [pricing](https://0xarchive.io/pricing?utm_source=blog&utm_medium=referral&utm_campaign=blog_hip4) for limits.