# Unibet Odds Scraper - Kambi Betting Odds & Data API (`parseforge/unibet-kambi-odds-scraper`) Actor

Scrape Unibet (Kambi) sportsbook odds for 34 sports: 1X2, totals, Asian lines, player props, live scores and outrights, with bookmaker margin and no-vig fair odds computed on every row.

- **URL**: https://apify.com/parseforge/unibet-kambi-odds-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.23 / 1,000 events

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Unibet Odds Scraper - Kambi Betting Odds & Data API

**Scrape Unibet sportsbook odds straight from the Kambi offering that prices it: 34 sports, every market on the board, and live betting odds with the score and match clock.** Each row carries decimal, fractional and American prices, implied probability, and the bookmaker margin already worked out. No login, no API key, no proxy. Export to CSV, JSON, Excel, or XML.

Kambi is the platform behind Unibet, and its offering endpoint is public: a plain GET returns the same prices the site shows. This reads that feed directly, filters it by league, kick-off, price, or margin, and returns every match in one fixed schema.

| Who uses it | What they scrape Unibet odds for |
|---|---|
| Odds comparison sites | A European book's full price list, refreshed on a schedule |
| Traders and modellers | No-vig fair odds and margin per market to benchmark closing lines |
| Affiliates and tipsters | Premier League odds, player props and bet builder prices for content |
| Data teams | A labelled market corpus across 34 sports for pricing models |
| Arbitrage and value hunters | The same fixture priced in 16 licensed jurisdictions at once |

### What it does

This Actor collects Unibet events by league, by whole sport, by event ID, or from the in-play feed, and returns each one as a flat row. Every event carries:

- 🧾 **Core fields:** teams, kick-off, sport, country, league, state, market count and the event's Unibet URL. 59 fields on the base row before any add-on.
- 💰 **Prices three ways:** every outcome as decimal, fractional and American odds, plus its implied probability.
- 📊 **Margin already computed:** the bookmaker margin and payout of every market returned, from the prices themselves.
- 🏟️ **Book flags:** in-play, bet builder, streamed, cash out, offered live, competition vs match.
- 🧩 **Optional blocks:** the full market board (up to ~430 markets on a big fixture), live score and clock, bet builder pre-packs, no-vig value analysis, and a cross-jurisdiction price comparison.

Results export to CSV, JSON, Excel, or XML, or stream from the API.

### What you can do with Unibet odds data

**📈 Track a book's line and how tight it prices.**

Pull a league on a schedule and read `mainMarketMarginPercent` next to the prices. Sort by margin to see where the book is sharpest and where it pads.

**🔍 Shop the same fixture across jurisdictions.**

Kambi prices each licensed market separately. Turn on the comparison and one Premier League fixture came back at 8.00 on the away side in Sweden and the Netherlands against 7.00 in Australia - a 14.3% spread on the same selection at the same book.

**🧠 Build a props and Asian-line dataset.**

Turn on the full market board and a single football fixture yields hundreds of markets: over/under, Asian handicaps and totals, correct score, HT/FT, corners, cards, and a couple of hundred player occurrence lines.

**⚡ Follow live betting odds with the score.**

Read the in-play feed and every row arrives with the running score, the match clock and period, and the live statistics the book publishes - corners, yellows, reds, set scores.

### Why choose this scraper

| | What you get |
|---|---|
| **Four inputs, one run** | Leagues, whole sports, event IDs and the in-play feed. Every source returns the same fields. |
| **34 sports, not just the US four** | Football, tennis, table tennis, ice hockey, cricket, darts, snooker, esports, trotting, politics and more. |
| **The whole board, not the headline** | Optional full market board: player props, Asian lines, corners, cards, correct score, HT/FT. |
| **Odds maths on the row** | Implied probability, margin, payout and no-vig fair odds, computed from the prices returned. |
| **Cross-jurisdiction comparison** | Re-price any event in up to six of 16 Kambi markets and get the best price, the spread and an arbitrage flag. |
| **Filters that cut noise** | Kick-off window, price band, favourite price, margin ceiling, market count, bet builder, streaming, cash out. |
| **15 languages, English kept** | Localise team and market names and still keep the English label on every row, so translated runs stay joinable. |
| **Four export formats** | CSV, JSON, Excel and XML, from the dashboard or the API. |

### How it compares

The sports-odds Actors on Apify aggregate US books - FanDuel, Bovada, Pinnacle, DraftKings - and return moneyline, spread and total. None of them read Kambi, and none return a European book's full board.

| Feature | ParseForge | scrapesage | scrapemint | seemuapps |
|---|---|---|---|---|
| Unibet / Kambi offering | Yes | No | No | No |
| Sports covered | 34 | US leagues + soccer | US leagues + soccer | US leagues + soccer |
| Markets per event | Up to ~430 | Moneyline, spread, total | Moneyline, spread, total | Moneyline, spread, total |
| Player props & Asian lines | Yes | No | No | No |
| Bet builder pre-packs | Yes | No | No | No |
| Outright / futures markets | Yes | No | No | No |
| No-vig fair odds & margin | Yes | Yes | No | No |
| Cross-jurisdiction price spread | Yes, 16 markets | No | No | No |
| Live score & match clock | Yes | No | No | Scores only |
| Multi-book comparison | Single book | Yes | No | No |

If you want several books side by side, use one of the aggregators. If you want everything one European book prices, this is the deeper feed.

### What a Unibet event looks like

Every event returns as one flat JSON row. Here is a real record, unedited apart from a trimmed `markets` array:

```json
{
  "eventId": 1028072803,
  "name": "Manchester United - Ipswich Town",
  "homeName": "Manchester United",
  "awayName": "Ipswich Town",
  "sport": "FOOTBALL",
  "sportTermKey": "football",
  "country": "England",
  "countryTermKey": "england",
  "league": "Premier League",
  "leagueId": 1000094985,
  "termPath": "football/england/premier_league",
  "start": "2026-08-30T15:30:00Z",
  "startsInHours": 118.78,
  "startDay": "Sunday",
  "state": "NOT_STARTED",
  "isLive": false,
  "eventType": "MATCH",
  "offeredLive": true,
  "hasBetBuilder": true,
  "isStreamed": false,
  "tags": ["OFFERED_LIVE", "BET_BUILDER", "MATCH"],
  "marketCount": 433,
  "marketsReturned": 2,
  "mainMarket": "Full Time",
  "mainMarketType": "Match",
  "homeOdds": 1.41,
  "drawOdds": 4.8,
  "awayOdds": 7.5,
  "homeOddsFractional": "2/5",
  "drawOddsFractional": "19/5",
  "awayOddsFractional": "13/2",
  "homeOddsAmerican": "-245",
  "drawOddsAmerican": "380",
  "awayOddsAmerican": "650",
  "homeImpliedProbability": 70.92,
  "drawImpliedProbability": 20.83,
  "awayImpliedProbability": 13.33,
  "mainMarketMarginPercent": 5.08,
  "mainMarketPayoutPercent": 95.17,
  "cashOutAvailable": true,
  "markets": [
    {
      "betOfferId": 2683313472,
      "criterion": "Full Time",
      "marketType": "Match",
      "isMain": true,
      "outcomeCount": 3,
      "bookmakerMarginPercent": 5.08,
      "payoutPercent": 95.17,
      "outcomes": [
        {
          "outcomeId": 4307642217,
          "label": "1",
          "type": "OT_ONE",
          "participant": "Manchester United",
          "line": null,
          "oddsDecimal": 1.41,
          "oddsFractional": "2/5",
          "oddsAmerican": "-245",
          "impliedProbability": 70.92,
          "status": "OPEN",
          "changedAt": "2026-08-24T13:14:45Z"
        }
      ]
    }
  ],
  "url": "https://www.unibet.co.uk/betting/odds/football/england/premier-league/manchester-united-ipswich-town/1028072803",
  "offering": "ub",
  "marketJurisdiction": "GB",
  "language": "en_GB",
  "scrapedAt": "2026-08-25T16:52:11.204Z"
}
```

`line` is filled on handicap and over/under outcomes and `null` on match markets. `drawOdds` is `null` in sports without a draw. `liveMarketCount` is `null` until an event goes in play.

#### What the optional blocks add

| Block | Field | What lands on the row |
|---|---|---|
| Full market board | `allMarkets` | Every market the book prices on the event, same shape as `markets`. A Premier League fixture returned 433. Pre-match only in practice - see below. |
| Live score & clock | `liveData` | Score, scorer side, minute and second, period, whether the clock runs, and the book's live statistics - corners, yellows, reds, set scores. |
| Bet builder | `betBuilder` | The book's ready-made same-game multiples: combined price, leg count, leg outcome IDs, shortest and best price on the event. |
| Value analysis | `valueAnalysis` | Margin, payout, favourite and longshot, no-vig fair probability and fair price per outcome with the vig cost, how competitive the market is, the average and sharpest margin across the row's markets, and how many minutes ago the price last moved. |
| Market comparison | `marketComparison` | The event re-priced in the jurisdictions you list: price per market per outcome, best and worst, spread %, best-payout market, and an arbitrage flag with the combined best-price book %. |
| Participants | `participants` | Each team, player or runner with its Kambi ID, home flag, type and scratched flag. Free. |

### Configure the run

Drive the Actor from four source types, alone or together: league paths, whole sports, event IDs, and the in-play feed. Filters run as each event is read, so only matches reach your dataset and only matches are billed. The Input tab lists every parameter.

A league path is `sport/country/league`, and a Unibet URL works in its place:

```json
{ "leagues": ["football/england/premier_league"], "maxItems": 50 }
```

Grab the whole board on the few fixtures the book prices deepest:

```json
{ "leagues": ["football/spain/la_liga"], "includeAllMarkets": true, "includeBetBuilder": true, "minMarketCount": 200, "maxItems": 20 }
```

Follow live betting odds with the score attached:

```json
{ "liveOnly": true, "includeLiveData": true, "includeValueAnalysis": true, "maxItems": 100 }
```

Shop one league across jurisdictions and flag the spreads:

```json
{ "leagues": ["football/italy/serie_a"], "compareMarkets": true, "comparisonMarkets": ["SE", "NL", "AU", "RO"], "maxItems": 30 }
```

Sweep a whole sport and keep only the tightly priced fixtures kicking off this week:

```json
{ "sports": ["tennis"], "startsWithinHours": 168, "maxBookmakerMargin": 5, "excludeLive": true, "sortBy": "margin", "maxItems": 200 }
```

**A note on filtering.** The filters run on the complete event before the optional blocks are stripped, so `maxBookmakerMargin`, `maxFavouriteOdds` and `minMarketCount` all work without buying the value analysis or the full board.

### Pricing

Pay-per-event: **$0.007 per event row**, dropping to $0.00623 at higher volume, plus **$0.008 per listing page** read and a $0.054 run-start fee. A league listing returns around 20 events and a whole-sport listing returns hundreds, so the page fee lands well under a cent per event.

| Events collected | Listing pages | Approximate cost |
|---|---|---|
| 100 | 5 | $0.79 |
| 1,000 | 20 | $7.21 |
| 10,000 | 60 | $70.53 |

Every optional block is billed only for the events that actually receive it:

| Optional block | Price per event |
|---|---|
| Full market board | $0.006 |
| Bet builder pre-packs | $0.005 |
| Live score & clock | $0.004 |
| Value analysis (no-vig, margin) | $0.008 |
| Market comparison | $0.012 |
| Outright / futures row | $0.009 |
| Participants | Free |

Bet builder needs the same per-event request as the full board, so enabling it on its own also bills the board once. Outright rows are billed as **Outright market** instead of **Event**, because one of them carries a 20-to-30-way futures market rather than a single fixture.

We sit above the per-row aggregators on price and say so plainly. What the difference buys is depth on one book instead of a headline across several: the full board with props and Asian lines, bet builder prices, outrights, the live clock, and the cross-jurisdiction spread. New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 events as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 events per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Unibet Odds Scraper](https://apify.com/parseforge/unibet-kambi-odds-scraper?fpr=vmoqkp).
3. Enter `leagues`, `sports`, `eventIds`, or tick `liveOnly`, pick a `market` and `language`, add any filters, and click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Unibet's price list through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/unibet-kambi-odds-scraper"
```

Then prompt it in plain language:

- *"Pull the Premier League fixtures from Unibet this weekend and rank them by bookmaker margin."*
- *"Which in-play football matches on Unibet are level after 60 minutes, and what are the current odds?"*
- *"Compare Serie A prices between the Swedish and Australian Unibet markets and show me the biggest spreads."*

Copy this into ChatGPT, Claude, or Cursor to start:

```
Use the Apify Actor "parseforge/unibet-kambi-odds-scraper" to collect Unibet (Kambi) sportsbook odds. Input: { "leagues": ["<sport/country/league>"], "sports": ["<sport>"], "liveOnly": <true|false>, "market": "<GB|SE|NL|...>", "maxItems": <n> }. It returns teams, kick-off, league, state, decimal/fractional/American odds per outcome, implied probability, bookmaker margin and payout, plus optional full market board, live score, bet builder packs, no-vig value analysis and cross-jurisdiction comparison. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**Why am I getting no results?**

The league path is probably wrong. It is a Kambi term path, not a display name: `football/england/premier_league`, not `English Premier League`. Pasting the Unibet URL of the competition works too. A path with no fixtures inside the book's listing window returns nothing.

**Why fewer events than I asked for?**

A league listing holds only what the book currently displays - around 20 fixtures for the Premier League, not the whole season - and your filters remove more. Add more leagues, point at the whole sport, or loosen the price and margin filters.

**Why is `liveData` empty?**

Only events currently in play carry it. On a pre-match fixture the field is `null`, and nothing is billed for it.

**Why is `allMarkets` empty on an in-play event?**

Once a fixture goes live, Kambi moves its board onto a push channel and the REST endpoint this Actor reads returns nothing for some of them. Measured on three in-play football matches: one returned 74 markets, two returned none. Nothing is billed when the board comes back empty. Use the full board on pre-match fixtures, and the in-play feed for the live score and the main live prices.

**What exactly does `liveOnly` return?**

The book's live feed also lists fixtures it has merely opened for in-play betting but that have not kicked off - four out of 91 at the time of writing. `liveOnly` keeps the ones actually in play. Set `eventStates` explicitly if you want the whole feed. Sports without a running clock, such as tennis and table tennis, report set scores instead of a minute.

**Why do prices differ between two runs of the same fixture?**

Because the book moved, or because you changed `market`. Kambi prices each licensed jurisdiction separately; `changedAt` on each outcome tells you when that price was last set.

**Why is the run slow?**

The full market board is one request per event and the biggest fixtures return hundreds of markets. Lower `maxItems`, set `maxMarketsPerEvent`, or narrow with `marketCriteria`. Measured: 200 events with their full boards took about 70 seconds.

**A field stopped filling.**

Kambi changed its public response shape. Email us with your run ID so we can update the parser.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Unibet account or an API key? | No. It reads Kambi's public offering endpoint, so there is no login, token or affiliate key to manage. |
| Does it need a proxy? | No. The feed answers plain anonymous requests, which is why the run cost is so low. |
| Which brands does it cover? | The Kambi offering that prices Unibet. Kambi's other brand offerings are IP-restricted at the CDN and are not reachable from Apify. |
| How many markets does an event have? | As many as the book prices. A Premier League fixture returned 433, a lower-league table tennis match returned one. `marketCount` tells you before you buy the board. |
| Can I get player props? | Yes, in the full market board, on pre-match fixtures. Football fixtures carry a couple of hundred player occurrence lines - goalscorer, assists, shots, cards. |
| Does the full board work on live events? | Not reliably. Kambi serves the in-play board over a push channel the REST feed does not mirror. You are not billed when it comes back empty. |
| What are the no-vig fair odds? | The market's implied probabilities normalised back to 100%, then inverted. It is the standard vig-free benchmark, computed from the prices on the row, not an official Unibet number. |
| Does the arbitrage flag mean free money? | No. It only says that the best prices across the Kambi jurisdictions you compared imply a book under 100%. Those markets are separate licensed products and are usually not accessible to one account. |
| Can I scrape outrights and futures? | Yes, tick Include outright markets. Those rows are billed as Outright market. |
| How many events per run? | Free plan: 10. Paid: up to 1,000,000, bounded by what the book's listings and your filters return. |
| Is this an official Unibet or Kambi product? | No. It is unofficial and reads only publicly available data. |

### Related actors

- [The Odds API Sports Scraper](https://apify.com/parseforge/the-odds-api-sports-scraper?fpr=vmoqkp): multi-bookmaker odds through The Odds API.
- [FanDuel Sportsbook Odds Scraper](https://apify.com/parseforge/fanduel-scraper?fpr=vmoqkp): moneyline, spread and totals from FanDuel.
- [ESPN Sports Data Scraper](https://apify.com/parseforge/espn-sports-scraper?fpr=vmoqkp): scores, schedules and team data across leagues.
- [TheSportsDB Scraper](https://apify.com/parseforge/thesportsdb-scraper?fpr=vmoqkp): teams, players, fixtures and results reference data.
- [Sports Stats Mega Pack Scraper](https://apify.com/parseforge/sports-stats-mega-pack-scraper?fpr=vmoqkp): bulk statistics across multiple sports sources.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Kambi Group plc, Unibet, or Kindred Group. It collects only publicly available odds data. You are responsible for using the data in compliance with the site's terms and applicable laws. Gambling data carries legal restrictions that vary by jurisdiction - check yours before you use it, and do not use this Actor where sports betting data collection is restricted. 18+. If gambling stops being fun, visit [BeGambleAware](https://www.begambleaware.org).

# Actor input Schema

## `leagues` (type: `array`):

Kambi term paths or Unibet URLs to collect. A path is sport/country/league; drop segments to widen it.

Examples:

- football/england/premier\_league
- football/spain
- https://www.unibet.co.uk/betting/odds/football/italy/serie-a
- tennis/atp

## `sports` (type: `array`):

Collect every upcoming event of a sport across all countries. Heavier than a league path: football returns around 270 events per request.

## `eventIds` (type: `array`):

Individual Kambi event IDs, or Unibet event URLs that end in one. Each is fetched with its complete market board.

Example: 1028072730

## `liveOnly` (type: `boolean`):

Read the live feed instead of the scheduled listings: every event currently in play, with its score and match clock.

## `includeOutrights` (type: `boolean`):

Also collect the competition-level markets of each league you asked for - winner, top scorer, season finishing position. These rows are billed as Outright market, not as Event.

## `offering` (type: `string`):

Which Kambi offering to price against. `ub` is the Unibet book; `kambi` is the platform-wide offering and carries a slightly wider tree.

## `market` (type: `string`):

The licensed market whose price list to read. Measured on one Premier League fixture: NL quoted 6.00 on the home side where AU quoted 5.40.

## `language` (type: `string`):

Localises team names, market names and outcome labels. Every row also carries the English label, so a translated run stays joinable.

## `listMarketCategory` (type: `string`):

The base row always carries the main market. This picks the second one the listing returns. Leave empty for the book's default pairing (Full Time plus Total Goals).

## `maxItems` (type: `integer`):

Total rows to write across every source in this run. Free Apify plans return a 10-row preview.

## `maxEventsPerLeague` (type: `integer`):

Cap the events taken from each league or sport so one busy competition cannot use up the whole run. Leave empty to let Maximum rows decide.

## `maxMarketsPerEvent` (type: `integer`):

Cap the markets kept on each row. The main market is always kept first. A big football fixture carries close to 400 markets, so this is worth setting when you turn on the full board.

## `searchTerms` (type: `array`):

Keep only events whose name, teams, players, league or country contain at least one of these terms. Case-insensitive.

Example: Arsenal

## `excludeTerms` (type: `array`):

Drop events whose name, teams, players, league or country contain any of these terms. Case-insensitive.

Example: Esports

## `countries` (type: `array`):

Keep only events whose country node matches. Use Kambi term keys such as england, spain, czech\_republic. Useful when you point the Actor at a whole sport.

## `eventStates` (type: `array`):

Keep only events in these states. Leave empty for both.

## `excludeLive` (type: `boolean`):

Drop events that have already started. Pre-match prices only.

## `startsAfter` (type: `string`):

Keep only events kicking off at or after this moment. ISO date or date-time, UTC.

Example: 2026-09-01T00:00:00Z

## `startsBefore` (type: `string`):

Keep only events kicking off at or before this moment. ISO date or date-time, UTC.

## `startsWithinHours` (type: `integer`):

Keep only events starting within this many hours from now. Ignored when Starts before is set.

## `minMarketCount` (type: `integer`):

Keep only events the book prices deeply. A Premier League fixture carries around 380 markets; an obscure fixture carries one.

## `maxMarketCount` (type: `integer`):

Keep only events at or below this market count.

## `minOdds` (type: `number`):

Keep only events where at least one returned outcome is priced at or above this decimal price.

Example: 2.5

## `maxOdds` (type: `number`):

Keep only events where at least one returned outcome is priced at or below this decimal price.

Example: 1.8

## `minFavouriteOdds` (type: `number`):

Keep only events whose shortest price is at or above this. Filters out the walkovers.

Example: 1.5

## `maxFavouriteOdds` (type: `number`):

Keep only events whose shortest price is at or below this. Filters out the coin flips.

Example: 2.2

## `maxBookmakerMargin` (type: `number`):

Keep only events whose main market is priced tighter than this percentage. The margin is computed from the odds returned, so this works without buying the value analysis.

Example: 5.5

## `requireBetBuilder` (type: `boolean`):

Keep only events tagged BET\_BUILDER by the book.

## `requireStreaming` (type: `boolean`):

Keep only events tagged as streamed on web or mobile.

## `requireCashOut` (type: `boolean`):

Keep only events whose main market has cash out enabled.

## `requireOfferedLive` (type: `boolean`):

Keep only events the book will also price once they start.

## `marketCriteria` (type: `array`):

Keep only markets whose name contains one of these terms, on both the base row and the full board. Case-insensitive.

Examples:

- Total Goals
- Asian Handicap
- Anytime Goalscorer

## `betOfferTypes` (type: `array`):

Keep only markets of these Kambi bet-offer types. Case-insensitive substring match.

Examples:

- Match
- Over/Under
- Player Occurrence Line
- Correct Score

## `sortBy` (type: `string`):

Ordering applied before the row cap, so it decides which events survive Maximum rows.

## `sortOrder` (type: `string`):

Ascending or descending.

## `includeAllMarkets` (type: `boolean`):

Fetch every market the book prices on each event and add them as `allMarkets` - up to about 430 per football fixture, including player props, Asian lines, corners and cards. One extra request per event. Pre-match only in practice: once a fixture goes live Kambi moves its board onto a push channel and this endpoint can return nothing, in which case you are not billed. Billed as Full market board.

## `includeLiveData` (type: `boolean`):

Add `liveData` with the running score, match clock, period, and the live statistics the book publishes - corners, yellow and red cards, set scores. Only in-play events carry it. Billed as Live data.

## `includeBetBuilder` (type: `boolean`):

Add `betBuilder` with the book's ready-made same-game multiples, their combined price and their legs. Uses the same per-event request as the full market board, so ticking this alone also bills Full market board. Billed as Bet builder.

## `includeValueAnalysis` (type: `boolean`):

Add `valueAnalysis`: bookmaker margin, payout, vig-free fair probability and fair price per outcome, favourite and longshot, how competitive the market is, and how many minutes ago the price last moved. Computed from the odds on the row. Billed as Value analysis.

## `compareMarkets` (type: `boolean`):

Re-price each event in the other Kambi markets you list below and add `marketComparison` with the best price per outcome, the spread, and an arbitrage flag when the best prices together imply a book under 100%. Billed as Market comparison.

## `comparisonMarkets` (type: `array`):

Which markets to re-price in. Up to six, and the one you are already scraping is skipped. Defaults to Sweden, Netherlands and Australia, the three that diverged most in testing.

## `includeParticipants` (type: `boolean`):

Add `participants` with each team, player or runner, its Kambi ID, home flag and scratched flag. Free - it rides on the request the row already made.

## Actor input object example

```json
{
  "leagues": [
    "football/england/premier_league"
  ],
  "liveOnly": false,
  "includeOutrights": false,
  "offering": "ub",
  "market": "GB",
  "language": "en_GB",
  "listMarketCategory": "",
  "maxItems": 50,
  "excludeLive": false,
  "requireBetBuilder": false,
  "requireStreaming": false,
  "requireCashOut": false,
  "requireOfferedLive": false,
  "sortBy": "start",
  "sortOrder": "asc",
  "includeAllMarkets": false,
  "includeLiveData": false,
  "includeBetBuilder": false,
  "includeValueAnalysis": false,
  "compareMarkets": false,
  "includeParticipants": false
}
```

# Actor output Schema

## `results` (type: `string`):

Every collected event with its markets, outcomes, prices, computed margin and the optional blocks you enabled

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "leagues": [
        "football/england/premier_league"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/unibet-kambi-odds-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "leagues": ["football/england/premier_league"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/unibet-kambi-odds-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "leagues": [
    "football/england/premier_league"
  ],
  "maxItems": 50
}' |
apify call parseforge/unibet-kambi-odds-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/unibet-kambi-odds-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/B5V2b9ALV5ieB1dJ0/builds/DGAjDtwerzQVrk8IY/openapi.json