Myriad Markets API: Access Onchain Prediction Market Odds (Python)

Myriad Markets: Prediction Markets Without the Gatekeeper

Myriad Markets is the onchain prediction market you probably haven’t heard of yet. It’s live, it’s onchain, it trades binary “yes/no” markets across politics, crypto, sports and culture — and because it’s a decentralized exchange, there’s no KYC, no jurisdiction check, no “sorry, you can’t trade from your country.” From a market-data perspective, that’s exactly the kind of venue traders care about: unfiltered, uncensored, and priced by whoever shows up with capital.

So if you want to pull Myriad’s data and fold it into a trading model, what does that look like?

For read-only access — the 90% use case — you don’t want to maintain any of that. You want the price.

The “Third Option” for Myriad Markets Data

OddsPapi aggregates 350+ venues into one API. Myriad Markets is one of them. You send one request with ?bookmakers=myriad and get decimal-formatted prices for every outcome OddsPapi has indexed, no wallet, no share-price conversion, no metadata-service glue code.

What Myriad Actually Is

Myriad Markets is an onchain prediction market — binary outcomes, share prices that read as implied probability, settlement via smart contract. When a trader buys a “yes” share at 0.44, the market is collectively pricing the event at a 44% probability. The opposite side — the “no” share — trades at roughly 1 - yes_price, minus whatever bid/ask spread the market makers are running.

Unlike sportsbooks, Myriad has no house. There’s no vig extracted from both sides. The only cost of trading is the spread between yes and no prices plus any onchain fees. For modelers, this is useful: the mid-market on a Myriad binary is roughly the market’s true implied probability, not a vig-loaded sportsbook number you have to de-juice yourself.

Why This Data Matters

Take any sportsbook moneyline, strip the vig, and you get an implied probability. Take a Myriad market on the same event and you already have one. If they disagree by more than the sportsbook’s bid/ask spread, you have a potential edge — one side is mispriced relative to the other.

This is the core trade in the prediction-market-versus-sportsbook arbitrage playbook. You can’t run it without reliable, low-friction access to Myriad’s price data.

The JSON Shape

Myriad routes through the same /v4/odds endpoint as every other bookmaker. The outcome structure mirrors OddsPapi’s exchange-type shape (same as Polymarket, Limitless, Kalshi):

# Myriad exchange-style outcome
{
  "active": true,
  "betslip": "https://myriad.markets/market/0x...",
  "bookmakerOutcomeId": "0x...",     # onchain market identifier
  "changedAt": "2026-04-11T09:38:17+00:00",
  "limit": null,
  "price": 2.27,                      # decimal odds (yes side)
  "exchangeMeta": {
    "lay": 1.79,                      # no side in decimal
    "bookmakerLayOutcomeId": "0x..."
  }
}

Two rules to remember:

• price is the “yes” side in decimal. For implied probability, compute 1 / price. For the 2.27 above, that’s ~44%.
• exchangeMeta.lay is the “no” side in decimal. Yes + no shouldn’t add to exactly 1 in probability terms — the gap is the market’s spread, which is your cost to round-trip.

Coverage note: Myriad’s sports coverage is deep on headline events and thin on the long tail. Niche fixtures will often return no Myriad book — that’s normal for onchain markets. Political, crypto and culture markets tend to have the deepest liquidity, but those live outside OddsPapi’s sports-fixture schema.

Tutorial: Pull Myriad Markets Data in Python

Step 1: Auth

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.oddspapi.io/v4"

Step 2: Find a Headline Fixture

from datetime import datetime, timezone, timedelta

today = datetime.now(timezone.utc)
params = {
    "apiKey": API_KEY,
    "sportId": 11,  # NBA — highest onchain liquidity
    "from": today.strftime("%Y-%m-%d"),
    "to": (today + timedelta(days=2)).strftime("%Y-%m-%d"),
}
fixtures = requests.get(f"{BASE_URL}/fixtures", params=params).json()
candidates = [f for f in fixtures if f.get("hasOdds")]

Step 3: Query Myriad

fixture_id = candidates[0]["fixtureId"]

r = requests.get(
    f"{BASE_URL}/odds",
    params={
        "apiKey": API_KEY,
        "fixtureId": fixture_id,
        "bookmakers": "myriad",
    },
)
data = r.json()

myriad = data.get("bookmakerOdds", {}).get("myriad")
if not myriad:
    print("No Myriad market on this fixture — try a headline game.")
else:
    print(f"{len(myriad['markets'])} markets from Myriad")

Step 4: Parse Yes/No, Compute Implied Probability

market = myriad["markets"]["101"]  # Full Time Result / Moneyline

for outcome_id, outcome in market["outcomes"].items():
    p = outcome["players"]["0"]
    if not p["active"]:
        continue

    yes_decimal = p["price"]
    yes_prob = 1 / yes_decimal

    meta = p.get("exchangeMeta") or {}
    no_decimal = meta.get("lay") if isinstance(meta, dict) else None
    no_prob = 1 / no_decimal if no_decimal else None

    spread = (yes_prob + no_prob - 1) if no_prob else None
    print(f"outcome {outcome_id}: yes {yes_prob:.1%} | no {no_prob and f'{no_prob:.1%}'} | spread {spread and f'{spread:.2%}'}")

That spread number is the overround — how much the market is charging you to round-trip. On a healthy onchain binary it should be sub-2%. On a thin market it can be 10%+. Use it as a liquidity signal before trusting any individual line.

Step 5: Cross-Check Against Pinnacle

The real use case: grab Myriad and a sharp sportsbook in the same request, strip Pinnacle’s vig, compare implied probabilities.

r = requests.get(
    f"{BASE_URL}/odds",
    params={
        "apiKey": API_KEY,
        "fixtureId": fixture_id,
        "bookmakers": "myriad,pinnacle",
    },
)
books = r.json()["bookmakerOdds"]

def implied(x):
    return 1 / x if x else None

pinny = books.get("pinnacle", {}).get("markets", {}).get("101", {}).get("outcomes", {})
myr = books.get("myriad", {}).get("markets", {}).get("101", {}).get("outcomes", {})

for oid in ("101", "102", "103"):
    pin_price = pinny.get(oid, {}).get("players", {}).get("0", {}).get("price")
    myr_price = myr.get(oid, {}).get("players", {}).get("0", {}).get("price")
    print(f"outcome {oid}: pinnacle {implied(pin_price)} vs myriad {implied(myr_price)}")

You’ll still need to de-juice Pinnacle (divide each implied probability by their sum, which will exceed 1 thanks to the vig) before you have a fair comparison. Once you do, the gap between Pinnacle’s no-vig number and Myriad’s raw implied probability is your signal.

Why Devs Pick OddsPapi Over a Direct Myriad Integration

No onchain glue code — Reading Myriad directly means running an RPC client, parsing conditional token events, and maintaining a metadata cache. OddsPapi turns all of that into one HTTP GET.

Already decimal — Myriad’s native share price is converted to decimal odds at ingestion. Implied probability is a one-line calculation.

Cross-venue in one call — Myriad + Polymarket + Limitless + Kalshi + Pinnacle, side by side. That’s the entire “sportsbook vs prediction market” comparison stack in a single JSON response.

Free historical data — /v4/historical-odds?fixtureId=…&bookmakers=myriad gives you price history without querying event logs yourself.

Get Started

1. Sign up at oddspapi.io
2. Copy your API key
3. Pull Myriad in one curl

curl "https://api.oddspapi.io/v4/odds?apiKey=YOUR_KEY&fixtureId=id1100022762690473&bookmakers=myriad"

No wallet. No RPC. No share-price math. Just clean decimal odds from an onchain prediction market.