# Sports Betting Value Bet & Arbitrage Finder (`mrdoe/odds-value-bet-arbitrage-finder`) Actor Finds +EV value bets and arbitrage across bookmaker odds datasets. Compares soft-book prices to a sharp bookmaker's no-vig fair odds, with edge %, Kelly fraction and stake splits. Works with Pinnacle, FanDuel, DraftKings, MelBet, 22Bet and 1xBet data. - **URL**: https://apify.com/mrdoe/odds-value-bet-arbitrage-finder.md - **Developed by:** [MrDoe](https://apify.com/mrdoe) (community) - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $4.00 / 1,000 results 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? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. 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. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## 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. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ![Sports Betting Value Bet & Arbitrage Finder - Turn bookmaker odds into value bets and arbitrage, priced against a sharp bookmaker's no-vig fair odds.](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/odds-value-bet-arbitrage-finder--hero.png) ### What does Sports Betting Value Bet & Arbitrage Finder do? Sports Betting Value Bet & Arbitrage Finder takes odds datasets produced by bookmaker Actors (or fetches them live), matches the same game across bookmakers even when team names differ, and removes each sharp bookmaker's margin (proportional no-vig normalization) to get a fair probability, optionally combined across several sharp sources into a consensus. It returns two clearly separated kinds of result: value bets, where a bookmaker's price beats that fair price by at least a configurable edge, with expected value, Kelly stake sizing and the sharp source(s) used; and arbitrage, where the best prices across distinct bookmakers cover every outcome for a combined implied probability under 100%, with the exact stake split for a guaranteed profit. A market with incomplete outcomes, too few independent sharp sources, or odds too old or too far apart in time to trust is reported as unavailable rather than guessed at, and never mislabeled as the other type. ### Why use Sports Betting Value Bet & Arbitrage Finder? - Matches the same game across bookmakers despite different team names and abbreviations. - Uses proportional no-vig prices from a sharp bookmaker as the fair price. - Returns edge percent, Kelly fraction and the sharp book's margin for every value bet. - Arbitrage results include the stake for each leg from your bankroll. - Works with the Pinnacle, FanDuel, DraftKings, MelBet, 22Bet and 1xBet Actors, or try it first on a built-in sample. ### What makes this different Most value-bet tools are closed apps tied to their own odds feed. This Actor is a decision layer on top of odds datasets you already collect: bring any mix of bookmakers, choose which one is the sharp reference, and get value bets and arbitrage with the maths shown, including a fuzzy match of teams across books. ### How it works ![Sports Betting Value Bet & Arbitrage Finder workflow: your input, collection, output](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/odds-value-bet-arbitrage-finder--how-it-works.png) 1. **Your input** — run the bookmaker odds Actors you want and choose their datasets, or leave the field empty to try the sample. 2. **The Actor collects it** — the Actor matches games across books, removes the sharp book's margin and compares prices. 3. **Your output** — you get value bets and arbitrage opportunities as clean rows. ### What data can you extract? The dataset has 32 fields per row: | Field | Type | Description | |---|---|---| | `type` | string | value-bet or arbitrage. | | `event` | object | Home, away, sport, league and start time. | | `market` | string | moneyline or total. | | `line` | number | Total line, null for moneyline. | | `selection` | string | home, draw, away, over or under (value bets). | | `bookmaker` | string | Bookmaker offering the price (value bets). | | `bookmakerOdds` | number | Decimal odds offered. | | `sharpBookmaker` | string | Primary sharp bookmaker used (first of sharpSources). | | `sharpOdds` | number | The single sharp source's raw decimal odds; null when a multi-source consensus was used instead. | | `fairOdds` | number | No-vig fair decimal odds (1 / fairProbability). | | `fairProbability` | number | No-vig fair probability, from probabilitySource. | | `edgePercent` | number | Expected value as a percent of stake: (odds \* fairProbability - 1) \* 100. | | `expectedValue` | number | Expected value as a decimal fraction of stake (edgePercent / 100). | | `probabilitySource` | string | The sharp bookmaker name, or Consensus(...) listing several. | | `sharpSourceCount` | integer | How many independent sharp sources fed the fair probability. | | `sharpSources` | array | Names of the sharp sources actually used. | | `marketOverround` | number | The sharp side's own raw overround (sum of implied probabilities before normalizing; >1 is the bookmaker's margin). | | `bookmakerScrapedAt` | string | When the offered price was collected. | | `sharpScrapedAt` | string | When the sharp reference price was collected. | | `oddsAgeSeconds` | number | The offered price's own age at evaluation time; null when unknown. | | `snapshotDifferenceSeconds` | number | Time gap between the offered price and the sharp reference; null when unknown. | | `fullKellyFraction` | number | Full Kelly stake as a fraction of bankroll; 0 when expected value is non-positive. | | `kellyFraction` | number | Fractional Kelly (fullKellyFraction \* the configured multiplier), capped at the configured maximum. | | `arbitrageStatus` | string | exists, none or not-evaluated for this same event and market. | | `validationStatus` | string | qualified: only rows that passed every filter are ever returned. | | `validationWarnings` | array | Non-blocking notes about the sharp source(s) used (value bets only). | | `marginPercent` | number | Guaranteed profit margin (arbitrage). | | `bankroll` | number | Bankroll split across legs (arbitrage). | | `guaranteedProfit` | number | Guaranteed profit for the bankroll (arbitrage). | | `legs` | array | Selection, bookmaker, odds and stake per leg (arbitrage). | | `url` | string | Link to the offering bookmaker's match page. | | `demo` | boolean | True when the built-in sample was used. | ### How to use Sports Betting Value Bet & Arbitrage Finder ![Sports Betting Value Bet & Arbitrage Finder input form](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/odds-value-bet-arbitrage-finder--input.png) 1. Open the Actor and go to the **Input** tab. 2. Turn on **Fetch live odds now** to have this Actor run this repo's own Pinnacle, FanDuel, DraftKings, MelBet, 22Bet and 1xBet Actors itself and scan their fresh odds in one go (each is billed and timed as its own Actor run). Or pick one **Odds dataset** per bookmaker from an earlier run of those Actors (up to four, or more via the API's `datasetIds`). Set the **Sharp bookmaker** (default Pinnacle) and a **Minimum edge**, then press Start. With neither set, it runs on a small built-in sample slate. Set **Focus on one bookmaker** (for example "1xbet") to see only opportunities that involve that book, useful when you only hold an account there. 3. Optionally set filters and a **Max results** limit. 4. Click **Start**. A default run finishes in under a minute. 5. Open the **Output** tab, then download the dataset or connect it to your tools. ### Input Parameters | Parameter | Type | Required | Default | Description | |---|---|---|---|---| | `oddsDataset1` | string | No | — | Dataset produced by a bookmaker odds Actor run (Pinnacle, FanDuel, DraftKings, MelBet, 22Bet, 1xBet). Add one per bookmaker; the more books, the more opportunities. Leave all empty to try the Actor on a small built-in sample slate. | | `oddsDataset2` | string | No | — | Dataset produced by a bookmaker odds Actor run (Pinnacle, FanDuel, DraftKings, MelBet, 22Bet, 1xBet). Add one per bookmaker; the more books, the more opportunities. | | `oddsDataset3` | string | No | — | Dataset produced by a bookmaker odds Actor run (Pinnacle, FanDuel, DraftKings, MelBet, 22Bet, 1xBet). Add one per bookmaker; the more books, the more opportunities. | | `oddsDataset4` | string | No | — | Dataset produced by a bookmaker odds Actor run (Pinnacle, FanDuel, DraftKings, MelBet, 22Bet, 1xBet). Add one per bookmaker; the more books, the more opportunities. | | `fetchLiveOdds` | boolean | No | `false` | Runs this repo's own bookmaker Actors (Pinnacle, FanDuel, DraftKings, MelBet, 22Bet, 1xBet) right now and scans their fresh odds, in addition to any datasets above. Each is a separate Actor run on your account, billed and timed as its own run. | | `liveBookmakers` | array | No | `[]` | Which of pinnacle, fanduel, draftkings, melbet, 22bet, 1xbet to fetch. Leave empty for all six. | | `liveSports` | array | No | `[]` | Sports to pass to each bookmaker Actor. Leave empty for soccer. | | `liveMaxMatchesPerBook` | integer | No | `20` | Caps how many matches each bookmaker Actor fetches. | | `focusBookmaker` | string | No | `""` | Only return opportunities involving this bookmaker (e.g. "1xbet", "melbet", "pinnacle"). Leave empty to see every opportunity across all books. | | `sharpBookmaker` | string | No | `"Pinnacle"` | The bookmaker whose no-vig price is treated as the fair price. Its name must match the bookmaker field in the datasets. Used as the single default sharp source when Sharp bookmakers (consensus) below is left empty. | | `sharpBookmakers` | array | No | `[]` | Two or more bookmakers to combine into a consensus fair price (e.g. Pinnacle, Betfair). Each is normalized (margin removed) independently before combining. Leave empty to use only the single Sharp bookmaker above. | | `consensusMethod` | string | No | `"average"` | How multiple sharp sources are combined: a plain average, or weighted by Sharp source weights below. | | `sharpWeights` | object | No | `{}` | Only used when Consensus method is "weighted". An object of bookmaker name to weight, e.g. {"pinnacle": 2, "betfair": 1}. A source with no weight listed defaults to 1 (equal weight). | | `minimumSharpSources` | integer | No | `1` | A market is unavailable (no value bet published) unless at least this many distinct, valid, sufficiently fresh sharp sources agree on it. | | `mode` | string | No | `"both"` | Value bets against the sharp fair price, arbitrage across books, or both. | | `minEdgePercent` | number | No | `3` | Only report value bets with at least this expected value, as a percentage of stake (edgePercent = (odds \* fairProbability - 1) \* 100). A conservative starting point, not a guarantee of profitability. | | `minArbitrageMarginPercent` | number | No | `0` | Only report arbitrage with at least this guaranteed margin. | | `enableArbitrageDetection` | boolean | No | `true` | When off, arbitrage is never evaluated: every value-bet row's arbitrageStatus is "not-evaluated" and no arbitrage rows are produced, regardless of Mode. | | `bankroll` | number | No | `100` | Total amount split across the legs of each arbitrage. | | `maxStartDiffHours` | number | No | `3` | Two listings count as the same match when their start times are within this many hours. | | `maximumOddsAgeSeconds` | integer | No | `30` | Reject a price whose own scrapedAt timestamp is older than this, so a candidate or sharp price is only used while still fresh. Rows with no scrapedAt (age unknown) are not rejected on this basis alone, since that can't be verified either way. | | `maximumSnapshotDifferenceSeconds` | integer | No | `30` | Maximum gap between a candidate bookmaker's scrapedAt and the sharp reference's scrapedAt (or between arbitrage legs' scrapedAt) for them to be treated as simultaneous. | | `minimumValidOdds` | number | No | `1.01` | Prices below this are treated as invalid data and excluded. | | `maximumValidOdds` | number | No | `1000` | Prices above this are treated as invalid data and excluded. | | `fractionalKellyMultiplier` | number | No | `0.25` | kellyFraction = max(0, fullKellyFraction) \* this multiplier. Default is quarter Kelly (0.25), a common conservative choice; it does not compensate for a poor probability estimate. | | `maximumKellyFraction` | number | No | `0.05` | Caps the reported kellyFraction at this bankroll fraction (e.g. 0.05 = 5%), regardless of what the formula alone would suggest. | | `maxResults` | integer | No | `5` | Maximum value bets and maximum arbitrage returned. Default is 5 for a quick test; set 0 to return everything found. | ### Output Data ![Sports Betting Value Bet & Arbitrage Finder dataset table](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/odds-value-bet-arbitrage-finder--output.png) `type` is `value-bet` or `arbitrage`, never confused: a value-bet row's own `arbitrageStatus` (`exists`, `none` or `not-evaluated`) says separately whether real arbitrage also exists on that same market. For value bets, `edgePercent` is expected value as a percent of stake ((odds \* fairProbability - 1) \* 100), `fairProbability` and `fairOdds` come from `probabilitySource` (one sharp bookmaker's name, or `Consensus(...)` when several were combined), `sharpSourceCount`/`sharpSources` list what was actually used, `marketOverround` is the sharp side's own raw overround, and `fullKellyFraction`/`kellyFraction` are full and fractional (capped) Kelly bankroll fractions - zero, never negative, when expected value is non-positive. `oddsAgeSeconds` and `snapshotDifferenceSeconds` show how fresh the prices were (null when a scrapedAt timestamp wasn't available to check). For arbitrage, `marginPercent` is the guaranteed margin and each leg lists its own bookmaker, odds and stake. `demo` is `true` when the built-in sample was used. ![Sports Betting Value Bet & Arbitrage Finder field map of one record](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/odds-value-bet-arbitrage-finder--fields.png) A real dataset item: ```json { "type": "value-bet", "event": { "home": "Pittsburgh Pirates", "away": "San Francisco Giants", "sport": "Baseball", "league": "MLB", "startTime": "2030-01-01T19:00:00.000Z" }, "market": "moneyline", "line": null, "selection": "away", "bookmaker": "FanDuel", "bookmakerOdds": 2.7, "sharpBookmaker": "Pinnacle", "sharpOdds": 2.4, "fairOdds": 2.5, "fairProbability": 0.4, "edgePercent": 8, "expectedValue": 0.08, "probabilitySource": "Pinnacle", "sharpSourceCount": 1, "sharpSources": [ "Pinnacle" ], "marketOverround": 1.0417, "bookmakerScrapedAt": null, "sharpScrapedAt": null, "oddsAgeSeconds": null, "snapshotDifferenceSeconds": null, "fullKellyFraction": 0.0471, "kellyFraction": 0.0118, "arbitrageStatus": "exists", "validationStatus": "qualified", "validationWarnings": [], "url": null, "demo": true } ``` ### Usage Examples #### Fetch all six bookmakers live and scan for arbitrage ```json { "fetchLiveOdds": true, "mode": "arbitrage", "bankroll": 500, "maxResults": 0 } ``` #### Live fetch, cricket, three bookmakers only ```json { "fetchLiveOdds": true, "liveBookmakers": [ "melbet", "22bet", "1xbet" ], "liveSports": [ "cricket" ], "mode": "arbitrage", "maxResults": 0 } ``` #### Value bets against Pinnacle from earlier runs ```json { "mode": "value", "minEdgePercent": 2, "maxResults": 0, "oddsDataset1": "", "oddsDataset2": "" } ``` #### Try it on the sample slate ```json {} ``` ### Tips for Best Results - Default is 5 results for a fast test. Set the max to 0 to return everything available. ### Known Limitations - Results are only as fresh as the moment they were fetched; odds move within seconds, and by default a price older than 30 seconds, or more than 30 seconds apart from the price it's compared against, is rejected rather than used. - Only moneyline and total markets are compared, and only when both books list the same outcomes and line; a three-way sport's sharp reference missing its draw price is treated as unavailable, not silently priced as two-way. - Team matching is fuzzy; unusual name differences can leave a match unpaired. - Consensus combines however many configured sharp bookmakers actually have valid, fresh, complete data for a given market that run - it does not simulate sources that were not supplied. - Fetching live odds runs this repo's other Actors as separate paid sub-runs; a bookmaker that is slow, blocked or out of matches is skipped rather than failing the whole run. - This is odds analysis, not betting advice or an execution service: it does not place bets, and a computed edge or guaranteed profit assumes both prices are still available and both bets are accepted, which bookmakers do not guarantee. Bookmakers commonly limit stakes or close accounts they identify as arbitrage betting, and can void a price offered in error. ### Integrations Run it from the Apify API, on a schedule, or from a webhook. Send results straight to Google Sheets, Make, Zapier, Slack or your own database with Apify's built-in integrations. ### Export Formats Download the dataset as JSON, CSV, Excel, XML, HTML table or RSS from the **Output** tab or the API. ### Frequently Asked Questions #### Does this place bets for me? No. It only compares odds you already have (from datasets or a live fetch) and reports the math; placing and settling bets is entirely up to you, on your own bookmaker accounts. #### What is arbitrage betting? Backing every outcome of the same match at different bookmakers when their combined implied probability is under 100%, which locks in a profit regardless of the result, provided both prices are still available when you bet and both bets are accepted. #### How is the fair probability calculated? Proportional no-vig normalization: each outcome's implied probability (1/odds) is divided by the sum of all outcomes' implied probabilities, so they sum to exactly 1. With more than one sharp bookmaker configured, each is normalized this way independently first, then combined by a plain or weighted average. #### What happens if the sharp reference is missing an outcome, stale, or out of range? That market is marked unavailable and skipped - no value bet is published from invented or incomplete data. The run log and the SUMMARY key-value record show the count of markets skipped and why. #### What does "focus on one bookmaker" do? It still compares all six bookmakers' odds against each other (needed to find real arbitrage), but only returns rows where that specific bookmaker is one of the legs, or is the soft book in a value bet. #### Is arbitrage betting legal? In most places, yes; it's the bookmakers' individual terms that often restrict it, and they can limit stakes or close accounts they flag as arbing. Check the rules of each bookmaker and your local laws. #### Why does live fetch cost more than reading datasets? Each bookmaker Actor it calls is a full, separate Actor run, billed and timed like any other run; reading datasets from a run you already paid for does not repeat that cost. #### Why did a bookmaker return nothing during live fetch? That bookmaker's Actor run failed, was blocked, or had no matching fixtures for the sports/window given; the other bookmakers still return normally, and SUMMARY.liveFetchStatus in the key-value store shows the reason per bookmaker. #### Do I need an account or login? No. The Actor only needs the odds datasets you choose; it has no account or login. #### Am I charged for failed runs or empty results? You are only charged for results that are actually written to the dataset. #### Can I run it on a schedule? Yes. Create a Task with your input and add a schedule in Apify Console. With monitor mode on, each scheduled run returns only what changed since the previous one. ### Support Questions or a missing field? Open an issue from the **Issues** tab on this Actor's page and it will be looked at. ### Legal / Responsible Use You are responsible for how you use these results, including compliance with bookmaker terms and the gambling laws that apply to you. This Actor is analysis only and does not place bets. Gambling is age-restricted and can be addictive; if you or someone you know has a problem, seek support from a service such as BeGambleAware or 1-800-GAMBLER. # Actor input Schema ## `oddsDataset1` (type: `string`): Dataset produced by a bookmaker odds Actor run (Pinnacle, FanDuel, DraftKings, MelBet, 22Bet, 1xBet). Add one per bookmaker; the more books, the more opportunities. Leave all empty to try the Actor on a small built-in sample slate. ## `oddsDataset2` (type: `string`): Dataset produced by a bookmaker odds Actor run (Pinnacle, FanDuel, DraftKings, MelBet, 22Bet, 1xBet). Add one per bookmaker; the more books, the more opportunities. ## `oddsDataset3` (type: `string`): Dataset produced by a bookmaker odds Actor run (Pinnacle, FanDuel, DraftKings, MelBet, 22Bet, 1xBet). Add one per bookmaker; the more books, the more opportunities. ## `oddsDataset4` (type: `string`): Dataset produced by a bookmaker odds Actor run (Pinnacle, FanDuel, DraftKings, MelBet, 22Bet, 1xBet). Add one per bookmaker; the more books, the more opportunities. ## `fetchLiveOdds` (type: `boolean`): Runs this repo's own bookmaker Actors (Pinnacle, FanDuel, DraftKings, MelBet, 22Bet, 1xBet) right now and scans their fresh odds, in addition to any datasets above. Each is a separate Actor run on your account, billed and timed as its own run. ## `liveBookmakers` (type: `array`): Which of pinnacle, fanduel, draftkings, melbet, 22bet, 1xbet to fetch. Leave empty for all six. ## `liveSports` (type: `array`): Sports to pass to each bookmaker Actor. Leave empty for soccer. ## `liveMaxMatchesPerBook` (type: `integer`): Caps how many matches each bookmaker Actor fetches. ## `focusBookmaker` (type: `string`): Only return opportunities involving this bookmaker (e.g. "1xbet", "melbet", "pinnacle"). Leave empty to see every opportunity across all books. ## `sharpBookmaker` (type: `string`): The bookmaker whose no-vig price is treated as the fair price. Its name must match the bookmaker field in the datasets. Used as the single default sharp source when Sharp bookmakers (consensus) below is left empty. ## `sharpBookmakers` (type: `array`): Two or more bookmakers to combine into a consensus fair price (e.g. Pinnacle, Betfair). Each is normalized (margin removed) independently before combining. Leave empty to use only the single Sharp bookmaker above. ## `consensusMethod` (type: `string`): How multiple sharp sources are combined: a plain average, or weighted by Sharp source weights below. ## `sharpWeights` (type: `object`): Only used when Consensus method is "weighted". An object of bookmaker name to weight, e.g. {"pinnacle": 2, "betfair": 1}. A source with no weight listed defaults to 1 (equal weight). ## `minimumSharpSources` (type: `integer`): A market is unavailable (no value bet published) unless at least this many distinct, valid, sufficiently fresh sharp sources agree on it. ## `mode` (type: `string`): Value bets against the sharp fair price, arbitrage across books, or both. ## `minEdgePercent` (type: `number`): Only report value bets with at least this expected value, as a percentage of stake (edgePercent = (odds \* fairProbability - 1) \* 100). A conservative starting point, not a guarantee of profitability. ## `minArbitrageMarginPercent` (type: `number`): Only report arbitrage with at least this guaranteed margin. ## `enableArbitrageDetection` (type: `boolean`): When off, arbitrage is never evaluated: every value-bet row's arbitrageStatus is "not-evaluated" and no arbitrage rows are produced, regardless of Mode. ## `bankroll` (type: `number`): Total amount split across the legs of each arbitrage. ## `maxStartDiffHours` (type: `number`): Two listings count as the same match when their start times are within this many hours. ## `maximumOddsAgeSeconds` (type: `integer`): Reject a price whose own scrapedAt timestamp is older than this, so a candidate or sharp price is only used while still fresh. Rows with no scrapedAt (age unknown) are not rejected on this basis alone, since that can't be verified either way. ## `maximumSnapshotDifferenceSeconds` (type: `integer`): Maximum gap between a candidate bookmaker's scrapedAt and the sharp reference's scrapedAt (or between arbitrage legs' scrapedAt) for them to be treated as simultaneous. ## `minimumValidOdds` (type: `number`): Prices below this are treated as invalid data and excluded. ## `maximumValidOdds` (type: `number`): Prices above this are treated as invalid data and excluded. ## `fractionalKellyMultiplier` (type: `number`): kellyFraction = max(0, fullKellyFraction) \* this multiplier. Default is quarter Kelly (0.25), a common conservative choice; it does not compensate for a poor probability estimate. ## `maximumKellyFraction` (type: `number`): Caps the reported kellyFraction at this bankroll fraction (e.g. 0.05 = 5%), regardless of what the formula alone would suggest. ## `maxResults` (type: `integer`): Maximum value bets and maximum arbitrage returned. Default is 5 for a quick test; set 0 to return everything found. ## Actor input object example ```json { "fetchLiveOdds": false, "liveBookmakers": [], "liveSports": [], "liveMaxMatchesPerBook": 20, "focusBookmaker": "", "sharpBookmaker": "Pinnacle", "sharpBookmakers": [], "consensusMethod": "average", "sharpWeights": {}, "minimumSharpSources": 1, "mode": "both", "minEdgePercent": 3, "minArbitrageMarginPercent": 0, "enableArbitrageDetection": true, "bankroll": 100, "maxStartDiffHours": 3, "maximumOddsAgeSeconds": 30, "maximumSnapshotDifferenceSeconds": 30, "minimumValidOdds": 1.01, "maximumValidOdds": 1000, "fractionalKellyMultiplier": 0.25, "maximumKellyFraction": 0.05, "maxResults": 5 } ``` # Actor output Schema ## `results` (type: `string`): No description # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "sharpBookmaker": "Pinnacle", "maxResults": 5 }; // Run the Actor and wait for it to finish const run = await client.actor("mrdoe/odds-value-bet-arbitrage-finder").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "sharpBookmaker": "Pinnacle", "maxResults": 5, } # Run the Actor and wait for it to finish run = client.actor("mrdoe/odds-value-bet-arbitrage-finder").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 '{ "sharpBookmaker": "Pinnacle", "maxResults": 5 }' | apify call mrdoe/odds-value-bet-arbitrage-finder --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrdoe/odds-value-bet-arbitrage-finder" } } } ``` 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 ` 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/qoL6UzERKxtADO7u5/builds/9jSfhsHCvGUEkH1ub/openapi.json