MyBookie occupies a unique position in the offshore sportsbook landscape. Known for aggressive promotions, extensive prop markets, and lines that sometimes deviate significantly from the market consensus, it’s a book that most automated strategies should monitor — even if it’s not the first one you integrate.

The deviation is what makes MyBookie interesting. When a book hangs a line 2-3 points off the market on a prop, that’s where arbitrage and middle opportunities live. But getting that data programmatically is harder than it is for BetOnline or Bovada, and the tradeoffs are real.

This guide covers what’s actually available, what makes MyBookie worth monitoring, and how to fold it into an automated multi-book pipeline.

API Access

The Short Version: There Is No API

Like most offshore sportsbooks, MyBookie does not offer:

  • No official REST or WebSocket API
  • No developer portal or API key registration
  • No documented endpoints
  • No partner or affiliate data programs

MyBookie’s website and mobile app use internal endpoints to render odds, but these are completely undocumented and intended only for their own frontend. This is the same situation you’ll find at Bovada and BetOnline — offshore books have no incentive to open their data to developers.

Third-Party Coverage

Third-party odds aggregators are the only practical route to MyBookie data, but coverage is noticeably thinner than what you get for the bigger offshore books.

The Odds API includes MyBookie under the bookmaker key mybookieag. Coverage spans major US sports (NFL, NBA, MLB, NHL) for core markets — moneylines, spreads, and totals. Prop coverage is limited or absent depending on the sport and season.

OpticOdds and OddsJam may include MyBookie data on higher-tier plans, but it’s not a guaranteed inclusion across all sports. Always verify coverage for your specific sport and market type before committing to a provider.

The gap matters. If you’re building an arb scanner and MyBookie data is missing for half your target sports, your scanner has a blind spot. Plan for incomplete coverage and supplement accordingly.

Internal Endpoint Exploration

If you open DevTools on MyBookie’s odds pages, you’ll see XHR requests returning structured JSON — event names, odds values, market types, timestamps. The data is parseable and gives you a sense of their internal data model.

This is useful for learning, not for production. MyBookie uses bot detection, endpoints change without warning, and scraping directly violates their terms of service. If you have an account you value, don’t risk it. Use the third-party route or manual monitoring instead.

Why MyBookie Matters for Automated Strategies

You’re not adding MyBookie to your pipeline for the API experience. You’re adding it because its odds behave differently from the rest of the market — and different means opportunity.

Lines That Deviate

MyBookie’s oddsmakers don’t always align with the sharp consensus. On any given slate, you’ll find lines that are 1-3 points off from where Pinnacle or Circa have them. These deviations aren’t random — MyBookie tends to shade lines toward public action and promotional angles, which creates predictable patterns.

When MyBookie hangs a spread at -6.5 and the rest of the market is at -4, that’s either a middle opportunity or an outright mispricing. Your pipeline’s job is to flag these automatically.

Extensive Prop Markets

MyBookie posts prop markets aggressively — player props, game props, and exotic markets that some books skip entirely. For prop-focused strategies, this breadth is valuable. The challenge is that third-party API coverage of MyBookie props is inconsistent, so you may need to supplement with manual checks.

Higher Vig (Know What You’re Paying)

MyBookie carries higher juice than BetOnline or Bovada on many markets. Standard sides that you’d see at -110/-110 elsewhere might show up as -115/-105 or worse on MyBookie. This vig eats into your edge on every bet.

For your pipeline, this means you need to compute implied probabilities with vig removed (the “no-vig” line) before comparing across books. Don’t compare raw American odds — you’ll overestimate the value.

Slower Line Movement

MyBookie is often slower to adjust lines in response to market moves. When sharp action hits Pinnacle and the number moves, it can take minutes — sometimes longer — for MyBookie to follow. This window is where automated strategies extract value.

The exploitation window is real but inconsistent. Some markets move quickly, others hang stale for hours. Your system needs to detect when a MyBookie line is stale relative to the consensus, not just when it’s different.

Integrating MyBookie Data

Here’s a practical approach to checking MyBookie availability and pulling their odds into a multi-book pipeline using The Odds API.

Checking MyBookie Availability

Not every sport or event will have MyBookie coverage. Start by verifying what’s available:

import requests

API_KEY = "your_api_key_here"

def check_mybookie_coverage(sport: str) -> dict:
    """Check if MyBookie has odds available for a given sport."""
    resp = requests.get(
        f"https://api.the-odds-api.com/v4/sports/{sport}/odds/",
        params={
            "apiKey": API_KEY,
            "regions": "us",
            "markets": "h2h,spreads,totals",
            "bookmakers": "mybookieag",
            "oddsFormat": "american",
        },
    )
    resp.raise_for_status()
    events = resp.json()

    covered = [e for e in events if any(
        b["key"] == "mybookieag" for b in e.get("bookmakers", [])
    )]
    return {
        "sport": sport,
        "total_events": len(events),
        "mybookie_events": len(covered),
        "coverage_pct": round(len(covered) / len(events) * 100, 1) if events else 0,
        "events": covered,
    }

sports = [
    "americanfootball_nfl",
    "basketball_nba",
    "baseball_mlb",
    "icehockey_nhl",
]

for sport in sports:
    result = check_mybookie_coverage(sport)
    print(f"{result['sport']}: {result['mybookie_events']}/{result['total_events']} "
          f"events ({result['coverage_pct']}%)")

Run this before building your pipeline to understand where MyBookie data is dense and where it’s sparse. If coverage drops below 50% for a sport, you’re better off treating MyBookie as supplementary rather than primary for that market.

Handling Sparse Data

When MyBookie data is missing for an event, your pipeline should fall through to the next book. A simple pattern:

BOOK_PRIORITY = ["mybookieag", "betonlineag", "bovada"]

def get_best_available_odds(event: dict, target_market: str = "h2h") -> dict | None:
    """Return odds from the highest-priority book that has data."""
    book_map = {b["key"]: b for b in event.get("bookmakers", [])}
    for book_key in BOOK_PRIORITY:
        if book_key not in book_map:
            continue
        for market in book_map[book_key].get("markets", []):
            if market["key"] == target_market:
                return {
                    "book": book_key,
                    "outcomes": {
                        o["name"]: o["price"] for o in market["outcomes"]
                    },
                }
    return None

For markets where MyBookie data is consistently absent via the API, consider a manual monitoring schedule — checking their site directly at key times (line release, 1 hour pre-game) and logging the numbers into your pipeline’s database. It’s not automated, but it captures the deviations that make MyBookie valuable.

MyBookie vs. Other Offshore Books

Here’s how MyBookie stacks up against the two most common offshore books in automated pipelines:

FactorMyBookieBetOnlineBovada
Official APINoneNoneNone
Third-party API coverageLimitedGoodGood
The Odds API keymybookieagbetonlineagbovada
Typical moneyline vig5-7%4-5%4-5%
Prop market breadthExtensiveModerateModerate
Line movement speedSlowModerateModerate
Arb opportunity frequencyHigher (due to deviations)ModerateModerate
Account limits/restrictionsAggressiveModerateAggressive

When to Prioritize MyBookie

MyBookie earns its spot in your pipeline when you’re hunting for deviations — not when you need reliable, high-coverage data feeds. Prioritize it when:

  • You’re scanning props. MyBookie’s prop breadth creates opportunities that don’t exist at books with thinner prop menus.
  • You’re running a multi-book arb scanner. More books in the comparison means more arb surfaces. MyBookie’s off-market lines are where many of those arbs live.
  • You can tolerate API data gaps. If your strategy degrades gracefully when data is missing, MyBookie is a net positive addition.

Account Longevity

MyBookie has a reputation for limiting winning accounts. If your automated strategy consistently takes +EV positions against their lines, expect reduced limits or account restrictions over time. This is standard across offshore books, but MyBookie tends to be more aggressive about it than BetOnline.

Factor this into your ROI calculations. An edge that gets you limited after 3 months has a different value than one you can exploit for years.

Automation Feasibility

Terms of Service

MyBookie’s terms prohibit automated access, scraping, and bot-driven interaction with their platform. This is standard language for offshore sportsbooks and functionally identical to what you’ll find at BetOnline and Bovada.

The practical implication: don’t automate bet placement on MyBookie. There’s no API for it, and attempting to automate the web interface puts your account at risk with zero recourse if it’s closed.

What You Can Automate

The safe automation layer is read-only monitoring through third-party providers:

  • Odds polling via The Odds API — entirely off-platform, no interaction with MyBookie’s systems
  • Deviation alerts — flag when MyBookie’s line diverges from consensus by a configurable threshold
  • Historical data collection — store timestamped snapshots for backtesting
  • Multi-book comparison — include MyBookie in cross-book arb and middle scans

This gives you the intelligence layer without touching MyBookie’s infrastructure. You monitor their odds, analyze the deviations, and make manual execution decisions based on automated alerts.

Moving Beyond Read-Only

If you decide to act on the signals your pipeline generates, the execution step is manual: log into MyBookie, navigate to the market, and place the bet yourself. Some developers build notification systems (Slack alerts, Telegram bots, email) that fire when a qualifying opportunity appears, minimizing the time between detection and action.

This is the same pattern that works for Bovada and most offshore books. Automated monitoring, manual execution.

What’s Next

You’ve mapped out how MyBookie fits into the automated offshore data landscape. From here: