# TipsportBettingData (`tomko5peter/tipsportbettingdata`) Actor

Download and process Tipsport Betting Data in seconds. This Apify actor fetches, parses, and delivers clean, structured betting data ready for analytics, monitoring, or automation. Fast, reliable, and built for serious data workflows.

- **URL**: https://apify.com/tomko5peter/tipsportbettingdata.md
- **Developed by:** [Peter Tomko](https://apify.com/tomko5peter) (community)
- **Categories:** Automation, Integrations
- **Stats:** 17 total users, 0 monthly users, 26.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Tipsport Odds & Markets Export (Apify Actor)

Export structured Tipsport.cz pre-match odds and betting markets as clean JSON.

This Actor is built for **market monitoring and odds evolution tracking**: you can run it repeatedly, store snapshots, and analyze how prices move across time, competitions, and market types.

### What you get

- **Two data modes**
  - **Match list snapshot** (broad coverage; lightweight)
  - **Extended match markets** (deep markets per selected match)
- **JSON you can use immediately**
  - Consistent keys
  - Explicit timestamps / close times
  - One object per match for extended mode (`records` + `betsData`)
- **Reliability controls**
  - Configurable `maxRetries`
  - Random backoff between retries (3–20s)

### What you can do with the data (examples)

- **Odds evolution**
  - Run every X minutes, append results to a dataset, and compute deltas (`odd_t - odd_t-1`).
- **Market discovery**
  - For a given match, enumerate all available markets and outcomes; detect when markets open/close.
- **Alerting**
  - Trigger alerts on price moves, unusually low/high odds, or when a market becomes inactive.
- **Segmentation**
  - Slice by sport, competition, event table, market box, outcome name, etc.
- **Backtesting / modeling**
  - Build features from odds time series per outcome and evaluate strategies.

### Output formats

#### 1) Match list snapshot (`downloadExtendedBets: false`)

You get a flat dataset with match rows (good for "what’s coming up soon" views and scheduling deeper crawls).

In Apify Console, the match rows are stored in the **named dataset** `small-match-dataset`.

The **default dataset** contains only a single summary item per run (`last_run`, `numberOfRecords`).

Example item:

```json
{
  "match_id": 7867838,
  "match_name": "Galatasaray - Liverpool (1.z)",
  "sport": "Fotbal - muži",
  "competition_short": "Liga mistrů",
  "match_url": "kurzy/zapas/fotbal-galatasaray-liverpool-1z/7867838",
  "downloaded_at": "2026-03-04T21:21:00.123456"
}
````

#### 2) Extended match markets (`downloadExtendedBets: true`)

For each input match URL you get **one JSON object** with:

- `records` = number of extracted betting outcomes
- `betsData` = array of all outcomes with match + market metadata

Example item:

```json
{
  "records": 3,
  "betsData": [
    {
      "match_id": 7867838,
      "match_name_full": "Galatasaray - Liverpool (1.z)",
      "sport": "Fotbal - muži",
      "competition": "Liga mistrů, Fotbal - muži",

      "event_table_id": 123,
      "event_table_name": "Zápas",
      "box_id": 456,
      "name_visible": true,

      "cell_id": 2537082717,
      "bet_name": "1",
      "odd": 3.86,
      "active": true,
      "winning": false,
      "event_id": 2204967031,
      "opp_number": 1,
      "bet_date_closed": "2026-03-10T18:45:00.000000Z"
    },
    {
      "match_id": 7867838,
      "event_table_name": "Zápas",
      "bet_name": "0",
      "odd": 3.40,
      "active": true
    },
    {
      "match_id": 7867838,
      "event_table_name": "Zápas",
      "bet_name": "2",
      "odd": 1.95,
      "active": true
    }
  ]
}
```

### Configuration (Actor input)

All inputs are plain JSON.

| Field | Type | Required | Default | Description |
|---|---:|:---:|---:|---|
| `startUrl` | string | Yes | - | Relative Tipsport path for listing matches (used in snapshot mode). |
| `downloadExtendedBets` | boolean | Yes | `false` | `false` = snapshot list, `true` = extended markets for `urlsList`. |
| `urlsList` | array\[string] | No | `[]` | Relative match paths to download extended markets for (max 20 items). |
| `maxRetries` | integer | No | `3` | Retries for Playwright/API flow (1–20). Random delay 3–20s between attempts. |

#### Time filter presets

Use these in `startUrl`:

- `form.period.till1h`
- `form.period.till3h`
- `form.period.till6h`
- `form.period.till12h`

Example `startUrl`:

```json
{
  "startUrl": "kurzy?timeFilter=form.period.till3h&withoutLive=true",
  "downloadExtendedBets": false
}
```

### Practical workflows

#### A) Build an odds time series (recommended)

1. Run snapshot mode every N minutes.
2. Select top matches you care about (or all).
3. Run extended mode for those matches.
4. Store snapshots and compute changes over time.

Key idea: treat each run as a **market snapshot**. Over time you get a dataset that enables:

- per-outcome odds charts
- volatility metrics
- alerting on sudden moves

#### B) Watchlist of matches (extended-only)

Provide `urlsList` (up to 20) and set `downloadExtendedBets` to `true`.

Tip: You can build `urlsList` by taking `match_url` values from the snapshot output dataset (`small-match-dataset`).

```json
{
  "downloadExtendedBets": true,
  "urlsList": [
    "kurzy/zapas/fotbal-galatasaray-liverpool-1z/7867838",
    "kurzy/zapas/fotbal-ferencvarosi-braga-1z/7867985"
  ],
  "maxRetries": 5
}
```

### Notes

- This Actor is designed for **pre-match markets** and structured export. Odds change frequently; scheduled runs unlock the real value.
- Respect applicable terms, policies, and local regulations for your intended usage.

# Actor input Schema

## `startUrl` (type: `string`):

Relative URL path for filtering betting data. Use time filters to focus on specific match periods. The default shows matches in the next 12 hours without live events.

## `downloadExtendedBets` (type: `boolean`):

If yes, the script will download only extended match data based on provided urls.

## `urlsList` (type: `array`):

Provided list of match urls will be used for scraping.

## `maxRetries` (type: `integer`):

Number of times to retry failed API requests (default: 3)

## Actor input object example

```json
{
  "startUrl": "kurzy?timeFilter=form.period.till12h&withoutLive=true",
  "downloadExtendedBets": false,
  "maxRetries": 3
}
```

# Actor output Schema

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

Summary of recent Actor Run

# 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("tomko5peter/tipsportbettingdata").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("tomko5peter/tipsportbettingdata").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 tomko5peter/tipsportbettingdata --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=tomko5peter/tipsportbettingdata",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TipsportBettingData",
        "description": "Download and process Tipsport Betting Data in seconds. This Apify actor fetches, parses, and delivers clean, structured betting data ready for analytics, monitoring, or automation. Fast, reliable, and built for serious data workflows.",
        "version": "0.0",
        "x-build-id": "SOqlXtdunFM6dRbYB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tomko5peter~tipsportbettingdata/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tomko5peter-tipsportbettingdata",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/tomko5peter~tipsportbettingdata/runs": {
            "post": {
                "operationId": "runs-sync-tomko5peter-tipsportbettingdata",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/tomko5peter~tipsportbettingdata/run-sync": {
            "post": {
                "operationId": "run-sync-tomko5peter-tipsportbettingdata",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrl",
                    "downloadExtendedBets"
                ],
                "properties": {
                    "startUrl": {
                        "title": "Start URL Path",
                        "type": "string",
                        "description": "Relative URL path for filtering betting data. Use time filters to focus on specific match periods. The default shows matches in the next 12 hours without live events.",
                        "default": "kurzy?timeFilter=form.period.till12h&withoutLive=true"
                    },
                    "downloadExtendedBets": {
                        "title": "Should the script download extended bets data?",
                        "type": "boolean",
                        "description": "If yes, the script will download only extended match data based on provided urls.",
                        "default": false
                    },
                    "urlsList": {
                        "title": "List of specific match URLs for scraping",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Provided list of match urls will be used for scraping.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRetries": {
                        "title": "Maximum number of retries for API calls",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of times to retry failed API requests (default: 3)",
                        "default": 3
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```