# MelBet Accumulator Builder (`mrdoe/melbet-accumulator-builder`) Actor

Scans MelBet's own live odds across your chosen dates and sports, then builds a multi-leg accumulator from the shortest-priced selection on each match - combined odds, implied probability and a plain-language analysis included. Not a guaranteed win; see the built-in disclaimer.

- **URL**: https://apify.com/mrdoe/melbet-accumulator-builder.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 $198.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

![MelBet Accumulator Builder hero](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/melbet-accumulator-builder--hero.png)

## MelBet Accumulator Builder (Apify Actor)

### What does MelBet Accumulator Builder do?

MelBet Accumulator Builder scans [MelBet's](https://melbet.com/) own pre-match
odds across your chosen date range and sports, then assembles a multi-leg
accumulator out of the shortest-priced selection available on each match - the
outcome MelBet's own pricing treats as most likely. Tell it how many legs you
want and which dates to cover, and it returns one ready-to-read slip: the
picks, the combined odds, and a plain-language summary of why each pick was
selected.

Try it with the default input - 5 legs, today's football fixtures - and see a
full slip in under a minute. Run it on a schedule every morning via Apify's
Scheduler, or call it from your own app through the Apify API.

### Why use MelBet Accumulator Builder?

- **Cuts through the fixture list.** Instead of scrolling hundreds of matches
  and markets yourself, get straight to the shortest-priced pick per game.
- **Transparent picks, not a black box.** Every leg shows its market,
  selection, and the exact odds it was picked at, sourced straight from
  MelBet - nothing is invented.
- **Built for a routine.** Schedule it daily for a fresh slip each morning, or
  call it on demand before kickoff.

### How to use MelBet Accumulator Builder

![MelBet Accumulator Builder step-by-step: input, scan, output](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/melbet-accumulator-builder--how-it-works.png)

1. Click **Try for free** (or **Run** if you've already added it).
2. Set a **From date** / **To date**, or leave both empty for today only.
3. Set **Number of legs** - how many matches you want in the accumulator.
4. Optionally narrow by **Sports**, or cap **Max odds per leg**.
5. Click **Start** and open the **Output** tab once it finishes.

### Input

![MelBet Accumulator Builder input options](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/melbet-accumulator-builder--input.png)

| Field | Type | Default | Notes |
|---|---|---|---|
| `dateFrom` | date | today | Earliest kickoff date to consider. |
| `dateTo` | date | same as `dateFrom` | Latest kickoff date to consider. |
| `legs` | integer | `5` | Max matches in the slip (2-15) - fewer may be used if `targetOdds` is reached first. |
| `targetOdds` | number | `2.5` | Combined odds to land near (e.g. 2.5 -> roughly 2.4-2.7) - picks whichever leg count gets closest, not just the first that reaches it. Set to `0` to ignore and always use the max legs. |
| `sports` | array | `["football"]` | Sports to scan; `["all"]` covers every sport MelBet lists. |
| `maxOdds` | number | (none) | Optional ceiling on any single leg's price. |
| `stake` | number | (none) | Optional - adds a potential payout (stake x combined odds) to the output. |
| `proxyConfiguration` | object | Apify Residential proxy | A proxy in a country where MelBet operates is required. |

### Output

![MelBet Accumulator Builder dataset output](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/melbet-accumulator-builder--output.png)

One dataset row per run - the full slip:

```json
{
    "bookmaker": "MelBet",
    "dateFrom": "2026-10-01",
    "dateTo": "2026-10-01",
    "legCount": 5,
    "legs": [
        {
            "home": "Team A",
            "away": "Team B",
            "league": "England. Premier League",
            "kickoff": "2026-10-01T18:00:00.000Z",
            "market": "doubleChance",
            "selection": "homeOrDraw",
            "odds": 1.12
        }
    ],
    "combinedOdds": 4.21,
    "impliedProbabilityPercent": 23.75,
    "analysis": "...",
    "disclaimer": "These are the shortest-priced selections available..."
}
```

You can download the result in various formats such as JSON, HTML, CSV, or
Excel.

#### Data fields

![MelBet Accumulator Builder output field map](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/melbet-accumulator-builder--fields.png)

| Field | Description |
|---|---|
| `legs` | Each selected match: teams, league, kickoff time, market, selection, and odds. |
| `combinedOdds`, `impliedProbabilityPercent` | The accumulator's total price and its implied win probability. |
| `targetOdds`, `targetReached` | The target you set (or the 2.5 default) and whether the slip reached it. |
| `analysis` | A short, plain-language note per leg and on the overall slip. |
| `potentialPayout` | Only present if `stake` was set. |
| `disclaimer` | Always included - no selection, however short the odds, is guaranteed. |

### Pricing

Each run charges a small start fee plus one charge for the generated slip -
you pay for the result, not for how many fixtures were scanned to build it.

### Tips and disclaimers

This Actor surfaces MelBet's own shortest-priced selections and a plain-
language summary of them - it does not predict outcomes, and no odds, however
short, are a guaranteed win. Betting carries financial risk; use this as one
input among many, and bet only what you can afford to lose. For support or a
custom version of this Actor, use the Issues tab.

# Actor input Schema

## `dateFrom` (type: `string`):

Only consider fixtures kicking off on or after this date (YYYY-MM-DD). Defaults to today.

## `dateTo` (type: `string`):

Only consider fixtures kicking off on or before this date (YYYY-MM-DD). Defaults to the same as "From date".

## `legs` (type: `integer`):

The most matches the accumulator can use. Each leg is a different match - the slip never bets twice on the same game. Fewer may be used if "Target odds" is reached first.

## `targetOdds` (type: `number`):

The combined odds you want the slip to land near, e.g. 2.5 aims for roughly 2.4-2.7 depending on what is available - picks whichever number of legs (up to "Max number of legs") gets closest, not just the first count that reaches or passes it. Defaults to 2.5. Set to 0 to ignore this and always use the max number of legs instead.

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

Which sports to scan for candidate legs, e.g. \["football", "tennis"]. Use \["all"] to scan every sport MelBet lists (slower). Defaults to football only.

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

Only consider a selection as a leg if its price is at or below this. Leave empty to let the ranking alone decide - the shortest prices available are always picked first regardless.

## `stake` (type: `number`):

If set, the output includes a potential payout at the combined odds (stake x combined odds). For illustration only.

## `openRouterApiKey` (type: `string`):

Only needed to override the Actor's own configured key - leave empty to use the default.

## `proxyConfiguration` (type: `object`):

A proxy in a country where MelBet operates is required - Apify Residential proxy is recommended.

## Actor input object example

```json
{
  "legs": 5,
  "targetOdds": 2.5,
  "sports": [
    "football"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 '<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("mrdoe/melbet-accumulator-builder").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("mrdoe/melbet-accumulator-builder").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 mrdoe/melbet-accumulator-builder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrdoe/melbet-accumulator-builder"
        }
    }
}
```

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/tfR55Ids02qvZhyw9/builds/mO1moYVLzM1kTeVMT/openapi.json