SportyBet API: Is There Official Access and What to Use Instead

No. SportyBet does not publish a public API, developer documentation, or API keys for third parties. As of October 2026, the bookmaker has no developer program.

What people search for as the “SportyBet internal API” is the set of requests the SportyBet website and mobile app use to load matches and odds. You can see them in your browser’s developer tools, but they are not a product for outside developers: there is no documentation, no contract, no support, and no guarantee they will work the same way tomorrow.

So the better question is not “how do I access the SportyBet API” but “what data do I actually need”. If you need SportyBet’s own odds, that is a job for odds aggregators. If you need fixtures, odds, live scores, and results for your own bot, tips site, or sportsbook, you need a sports data provider with an official API. Below we cover both cases and show what such an API returns for a match from Nigeria.

Why SportyBet has no public API

SportyBet is a bookmaker for players, not a data provider. It operates in several African countries, including Nigeria, Ghana, and Kenya, and each country has its own version of the site and its own betting line.

For a bookmaker, the line is a commercial asset. Open real-time access to its odds would mostly help people hunting for pricing errors and arbitrage between bookmakers. That is why most bookmakers, not only SportyBet, do not expose their odds through a public API. At best they offer affiliate programs that pay for bringing in players, not access to data.

What the “SportyBet internal API” actually is

When you open a match page, your browser asks SportyBet’s servers for JSON data: the list of events, markets, odds, and the state of live matches. These requests are what people call the “internal API”.

On GitHub you will find projects that call them directly:

booking code generators;
odds scrapers;
virtual football analyzers;
bots that pick bets by preset rules.

Technically, it works. But this kind of “API” lacks everything a revenue-generating product needs: an API key, documentation, terms of use, obligations towards you, and someone to contact when it breaks.

Why you should not build a product on the internal API

The format changes without notice

Internal requests exist for SportyBet’s own frontend. When the bookmaker updates its site, fields get renamed, the response structure changes, and endpoints move. Nobody will warn you — you will find out from users whose bot stopped showing matches.

Bot protection and blocking

Bookmakers protect their sites from automated traffic: they rate-limit requests, check the browser, and block suspicious IP addresses. The more users your product has, the more requests you send — and the more likely you are to get blocked at the busiest moment, such as during a big match.

Terms of use

Bookmaker terms usually prohibit automated data collection and the use of bots. If your automation runs through a player account, the account itself is at risk. Before collecting any data, read SportyBet’s terms for your country — taking that risk should be a conscious decision, not a default.

Every country is a separate integration

SportyBet’s line differs between Nigeria, Ghana, and Kenya. A multi-country product means several unofficial integrations, each of which can break in its own way.

No support and no guarantees

If odds disappear, teams get mixed up, or a live score freezes, there is no one to ask. In a commercial product that means downtime, complaints, and lost customers.

	SportyBet internal API	Odds aggregator	Sports data provider
Documentation and API key	No	Yes	Yes
SportyBet’s own odds	Yes	Yes	No, its own line
Stable format	Not guaranteed	Depends on the service	Documented
Support	No	Yes	Yes
Results and bet settlement	No	Usually no	Depends on the provider
Fit for your own product	Risky	For odds comparison	Yes

What you actually need: two different tasks

Task 1: you need SportyBet’s own odds

This is your case if you are building:

odds comparison across bookmakers;
arbitrage or value bet finders;
a booking code converter between bookmakers;
a tool that tracks how a specific bookmaker moves its line.

Here you need SportyBet’s actual odds, and no other source can replace them. Odds aggregators that collect lines from many bookmakers sell this kind of data. Before you buy, ask how the aggregator gets the data, how large the delay is, which SportyBet countries are covered, and what happens when the bookmaker changes its site.

SportAPI is not the right tool for this task: we provide our own sports betting line, not a copy of SportyBet’s. Booking codes also exist only inside SportyBet — any third-party tool works with them through the same internal requests and carries the same risks.

Task 2: you need sports data for your own product

This is your case if you are building:

a tips site or a Telegram channel with predictions;
a Telegram or WhatsApp bot with fixtures, odds, and results;
a live score app;
your own sportsbook or prediction contest;
match analytics.

Here SportyBet’s odds are not required. Your users need current matches, markets and odds, live scores, and results. You need a stable format, a contract, and support. This is exactly what an official sports data API is for.

What data a product “like SportyBet” needs

Break a bookmaker’s interface down into data and you get this list:

What the player sees	Data you need	Where to get it in SportAPI
Fixtures and competitions	Prematch line by sport, country, and tournament	`menu` and `events` methods
Live section	Live matches, score, period, odds	Same methods with the `live` type
Match page	All markets: 1X2, double chance, handicap, totals, and more	`event` method
Live statistics	Attacks, shots, corners, cards	`stat_list` field in live matches
Final results	Final score of finished matches	Results API
Bets and bet slips	Bet placement, payout calculation, refunds	Coupon API

The first three rows are usually enough to launch. The rest come as the product grows: results let you grade predictions automatically, and bet settlement matters once you accept bets yourself.

Example: a match from Nigeria in JSON

Here is a request for upcoming football matches in the Sports Odds API. The sport ID comes from the menu method; for football in this example it is 1:

GET https://YOUR_API_DOMAIN/v1/events/1/0/sub/50/line/en
Package: YOUR_API_KEY

Below is a shortened fragment of a real response from our documentation — a Nigeria Community Cup match:

{
  "status": 1,
  "page": "/v1/events",
  "body": [
    {
      "tournament_id": 2726801,
      "tournament_name": "Nigeria. Community Cup",
      "events_list": [
        {
          "game_id": 758850796,
          "game_start": 1791295200,
          "country_name": "Nigeria",
          "opp_1_name": "Tonic",
          "opp_2_name": "Joy Cometh",
          "game_oc_counter": 55,
          "game_oc_list": [
            {
              "group_name": "1x2",
              "oc_list": [
                {"oc_name": "W1", "oc_rate": 2.22, "oc_block": false},
                {"oc_name": "X", "oc_rate": 3.72, "oc_block": false},
                {"oc_name": "W2", "oc_rate": 2.48, "oc_block": false}
              ]
            },
            {
              "group_name": "Total",
              "oc_list": [
                {"oc_name": "Over 2.5", "oc_rate": 1.53, "oc_block": false},
                {"oc_name": "Under 2.5", "oc_rate": 2.27, "oc_block": false}
              ]
            }
          ]
        }
      ]
    }
  ]
}

The match list contains a short set of markets. game_oc_counter: 55 means 55 markets are available for this match in total; the event method returns all of them. game_start is a Unix timestamp, and oc_block: true means an outcome is temporarily closed for betting.

The same request in Python:

import requests

API = "https://YOUR_API_DOMAIN/v1"
HEADERS = {"Package": "YOUR_API_KEY"}

url = f"{API}/events/1/0/sub/50/line/en"
response = requests.get(url, headers=HEADERS, timeout=10)
response.raise_for_status()

for tournament in response.json()["body"]:
    for match in tournament["events_list"]:
        odds = {}
        for group in match["game_oc_list"]:
            if group["group_name"] == "1x2":
                for outcome in group["oc_list"]:
                    odds[outcome["oc_name"]] = outcome["oc_rate"]
        teams = f'{match["opp_1_name"]} vs {match["opp_2_name"]}'
        print(tournament["tournament_name"], teams, odds)

All methods, parameters, and full response examples are in the Sport Line API documentation.

How to move from the internal API to an official one

If you already run a bot or a site on SportyBet data, switching is easier than it looks.

List the data you really use. Usually it is matches, teams, kick-off time, a few markets, and the result.
Create your own models. Let your code work with your own Match, Market, and Outcome objects instead of one source’s JSON. Then changing providers touches one module, not the whole project.
Map the fields. For example: match ID — game_id, teams — opp_1_name and opp_2_name, kick-off — game_start, odds — oc_rate, closed outcome — oc_block.
Cache on your server. Your server fetches data from the API and serves it to all users, instead of every browser calling the API separately. More on this in our article on how live data travels from a sports API to a website.
Test on real live matches. Especially in the evening, when the most matches are on.

The most common mistakes

A business built on scraping. The product works until the bookmaker updates its site. Then come urgent fixes and lost users.
Automation through a player account. The account can be blocked together with the funds on it.
“Free” does not mean “allowed in a commercial product”. We cover this in detail in whether you can use a free Sports API for business.
Promising “SportyBet odds” from another source. If you show another provider’s odds, say so — otherwise you undermine your audience’s trust.
Calling the API from every user’s browser. Without a cache you hit limits fast, and your API key ends up in the page’s public code.

How to test SportAPI for your project

SportAPI provides prematch and live sports data over a REST API in JSON: sports, countries, tournaments, matches, markets and odds, live scores, and statistics. Final scores come from a separate Sports Results API, and bet placement and settlement from the Coupon API. If you need a ready-made website rather than just data, there is a turnkey sportsbook platform.

What we do not have, honestly:

SportyBet’s odds or booking codes — we provide our own line;
WebSocket — REST only for now, WebSocket is in development;
a fixed list of tournaments: the API shows only tournaments that currently have matches, so the set depends on the calendar.

The 2-day trial includes all sports, prematch and live, in English. Paid plans start at $30 per month for one sport. During the trial, check:

whether menu includes tournaments from the countries you need;
how many markets come with matches from those tournaments;
how fast odds and scores update in live;
how your code handles closed outcomes and disappearing matches.

You can make your first request with the quick start guide.

FAQ

Does SportyBet have an official API for developers?

No. SportyBet does not publish a public API, documentation, or keys for third-party developers. Everything you find under the name “SportyBet API” is either the site’s internal requests or third-party services that collect data from it.

Is it legal to use the SportyBet internal API?

It depends on SportyBet’s terms of use in your country and on local law. Bookmaker terms usually prohibit automated data collection and bots. For a commercial product, a source with a contract and clear data rights is the safer choice.

Can I create or check SportyBet booking codes through an API?

There is no official way. Booking codes exist only inside SportyBet, so any third-party tool works with them through the site’s internal requests — with all the risks of blocking and format changes.

Can I build a site or bot like SportyBet with SportAPI?

Yes, if it is your own product: the line, live matches, markets, and odds come from the API, final scores from the Results API, and bets can be placed and settled through the Coupon API. The odds will be ours, not SportyBet’s. If you need a complete platform, it is available as a turnkey solution.

Does SportAPI cover African football?

The line includes football tournaments from Nigeria and South Africa, as well as the European leagues popular in Africa. The set depends on the calendar: a tournament appears in the API when it has matches. Check the exact list for your project with a trial key and the menu method.

What to choose

You need SportyBet’s own odds — look for an odds aggregator and check in advance where its data comes from and how large the delay is.
You need data for your own bot, site, or sportsbook — use an official sports data API with documentation, a contract, and support.
You already run on the internal API — introduce your own data models and move to an official source before the format breaks on its own.

Message the SportAPI manager on Telegram with the countries, tournaments, and data you need. We will issue a 2-day trial key so you can test the line on real matches before you pay.

SportyBet is a trademark of its owner. SportAPI is not affiliated with or a partner of SportyBet; the name and logo are used only to identify the topic of this article.