# Value Bet Finder: Soft Books vs Sharp Price (`precious_bathmat/value-bet-finder`) Actor

Finds bets where DraftKings, Bovada, Unibet or LeoVegas pay more than the fair price, worked out by stripping the margin from Pinnacle's odds. Every bet shows its edge, the fair price behind it, and how much Pinnacle will accept. No API key.

- **URL**: https://apify.com/precious\_bathmat/value-bet-finder.md
- **Developed by:** [Mariam Ahmed](https://apify.com/precious_bathmat) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 value bets

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Value Bet Finder: Soft Books vs Sharp Price

Finds the bets where **DraftKings, Bovada, Unibet or LeoVegas pay more than the bet is worth**, measured against a fair price worked out from Pinnacle's odds.

No API key, no login, no proxy.

### What does this do?

A bookmaker's odds are not a probability. Two sides of a coin priced at 1.91 and 1.91 imply 52.4% each — 104.8% in total. That extra 4.8% is the bookmaker's margin.

Strip it out and you get the **no-vig fair price**: the market's honest estimate. Do it with Pinnacle's odds, which run on thin margins and high limits, and you have a benchmark. Every soft bookmaker paying more than that benchmark is offering a bet worth more than it costs.

```mermaid
flowchart LR
    A[Pinnacle odds] --> B[Remove the margin]
    B --> C[Fair price]
    D[DraftKings · Bovada<br/>Unibet · LeoVegas] --> E{Pays more<br/>than fair?}
    C --> E
    E --> F[Value bet, with its edge]
```

### How is this different from arbitrage?

Arbitrage means backing every outcome across books for a guaranteed profit. It is real but rare, and it vanishes in minutes. **Value betting is the everyday version**: no guarantee on any single bet, but a positive expected return every time you take a price above fair. This Actor looks for those. If you want the arbitrage view instead, that is a different tool.

### What data do you get?

| Field | What it is |
|---|---|
| `edgePercent` | Expected return on a unit stake. +5 means the price pays 5% more than it is worth |
| `bet`, `game`, `league`, `startTime` | What to back, in which game, and when it starts |
| `bookmaker`, `bookmakerOdds`, `bookmakerOddsAmerican` | Who is offering it and at what price |
| `fairOdds`, `fairProbabilityPercent` | The no-vig price and the probability behind it |
| `sharpOdds`, `sharpMarginPercent` | Pinnacle's raw price and the margin removed |
| `pinnacleLimit`, `limitConfidence` | What Pinnacle will accept on this line, and what that says about its confidence |
| `longShotCaveat`, `warning` | Where the method is least reliable, and where an edge looks too good |

### Example: one run, September 2026

Thirty college football games, ten value bets:

| Edge | Bookmaker | Bet | Price | Fair | Notes |
|---|---|---|---|---|---|
| **+30.7%** | LeoVegas | Northwestern | +1200 | 9.95 | long shot, flagged suspicious |
| +10.7% | LeoVegas | South Alabama | +900 | 9.03 | long shot |
| **+3.2%** | Unibet | Akron | +450 | 5.33 | clean |
| **+2.8%** | Unibet | Oklahoma | +450 | 5.35 | clean, Pinnacle limit 2,000 |

The Akron and Oklahoma rows are the useful ones: modest, believable edges on lines Pinnacle is happy to take real money on. The +30.7% at the top is flagged twice over, because an edge that size almost always means the two books are not offering quite the same bet.

### What it refuses to do

- **It does not promise a winner.** The edge is an expected return over many bets, not a prediction about one. Any single bet can lose and still have been the right price.
- **It says out loud that the fair price rests on an assumption.** Pinnacle is treated as efficient. That is the standard assumption in value betting and it is stated on every row, not buried.
- **It flags where its own method is weakest.** Removing a margin proportionally flatters long shots, because bookmakers load more margin onto that side. Any bet with a fair probability under 15% carries a caveat saying the edge is probably overstated — and in the run above, the biggest edges were exactly those.
- **It warns when an edge is too good to be true.** Anything at or above 20% is marked suspicious: in practice it means a stale price or a different line, not free money.
- **It will not compare two different bets.** A spread of -3 is not a spread of -3.5. Prices are only ever compared on the same market, same line, same outcome.
- **It never scores Pinnacle against itself**, and it stops with a clear message if Pinnacle returns nothing, because without the benchmark there is no fair price and nothing honest to say.

### One thing worth knowing about the build

The bookmakers fingerprint the TLS handshake. Built on Node 24.21, this Actor got **HTTP 403 from Pinnacle and 410 from Kambi on every league** while identical code on Node 24.20 got 200. The base image is therefore pinned, and the failure mode is worth knowing: the Actor still runs and simply finds nothing. If it ever returns no sharp prices at all, suspect the runtime before the code.

### Popular value bet searches

Ready-made runs you can open and start, or copy as a starting point:

- [Value Bets Today](https://apify.com/precious_bathmat/value-bet-finder/examples/value-bets-today)
- [College Football Value Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/college-football-value-bets)
- [NFL Value Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/nfl-value-bets)
- [MLS Value Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/mls-value-bets)
- [Soccer Value Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/soccer-value-bets)
- [American Football Value Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/american-football-value-bets)
- [Moneyline Value Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/moneyline-value-bets)
- [Unibet Value Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/unibet-value-bets)
- [LeoVegas Value Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/leovegas-value-bets)
- [DraftKings Value Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/draftkings-value-bets)
- [High Edge Value Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/high-edge-value-bets)
- [High Limit Value Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/high-limit-value-bets)
- [Positive EV Bets](https://apify.com/precious_bathmat/value-bet-finder/examples/positive-ev-bets)
- [No-Vig Fair Odds](https://apify.com/precious_bathmat/value-bet-finder/examples/no-vig-fair-odds)

### Pricing

**$0.01 per value bet found.** A run that finds ten bets costs **$0.10**. A run that finds nothing costs nothing, because nothing is charged for an empty result.

### Input

| Setting | What it does |
|---|---|
| **Leagues** | Thirteen competitions across football, basketball, baseball, hockey and soccer |
| **Bookmakers to check** | Which soft books to price against Pinnacle |
| **Markets** | Moneyline, spread, total |
| **Minimum edge** | 1 to 2% is a realistic working threshold |
| **Minimum Pinnacle limit** | Raise it to keep only the lines Pinnacle takes serious money on |
| **Days ahead** | How far forward to look |
| **Maximum bets** | How many to return, biggest edge first |

### Integrations

Runs on a schedule and connects to Google Sheets, Slack, Zapier, Make or your own code through the Apify API. Value appears and disappears as books move, so a run every few hours finds far more than one run a day.

# Actor input Schema

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

Which competitions to check. Pinnacle is always read as the benchmark; the books below are compared against it.

## `bookmakers` (type: `array`):

The books priced against Pinnacle's fair price. Pinnacle itself is the benchmark and is always read.

## `markets` (type: `array`):

Moneyline is the straight winner, spread is the handicap, total is over or under.

## `minEdgePercent` (type: `integer`):

Only show bets paying at least this much above the fair price. 1 to 2 is a realistic working threshold; anything above 20 is usually a mismatch rather than a gift.

## `minPinnacleLimit` (type: `integer`):

Pinnacle raises its maximum stake on lines it trusts, so a higher limit means a more reliable fair price. 0 keeps everything.

## `daysAhead` (type: `integer`):

How far forward to look for games.

## `maxBets` (type: `integer`):

How many to return, biggest edge first. Each costs $0.01.

## Actor input object example

```json
{
  "leagues": [
    "nfl",
    "nba",
    "epl"
  ],
  "bookmakers": [
    "draftkings",
    "bovada",
    "unibet",
    "leovegas"
  ],
  "markets": [
    "moneyline",
    "spread",
    "total"
  ],
  "minEdgePercent": 1,
  "minPinnacleLimit": 0,
  "daysAhead": 3,
  "maxBets": 100
}
```

# Actor output Schema

## `bets` (type: `string`):

Every price beating the fair price, biggest edge first.

## `summary` (type: `string`):

What was read and what was found.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("precious_bathmat/value-bet-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("precious_bathmat/value-bet-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 '{}' |
apify call precious_bathmat/value-bet-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,precious_bathmat/value-bet-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 <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/QiLvzlM9rrZ066Sxl/builds/OHvRzGoRWi23jcLVN/openapi.json
