# DAZN Sports Schedule & Events Scraper (`vittuhy/dazn-sports-schedule-events-scraper`) Actor

Scrape the complete DAZN TV schedule and get structured data for every event - past, live, and upcoming. Covers all sports and all 14 DAZN markets worldwide.

- **URL**: https://apify.com/vittuhy/dazn-sports-schedule-events-scraper.md
- **Developed by:** [Vít Tuhý](https://apify.com/vittuhy) (community)
- **Categories:** News, Other
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.

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

## 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

## DAZN Sports Schedule & Events Scraper

Scrape the complete DAZN TV schedule and get structured data for every event - past, live, and upcoming. Covers all sports and all 14 DAZN markets worldwide.

### What does DAZN Schedule Scraper do?

[DAZN](https://www.dazn.com) is the world's leading sports streaming platform, broadcasting live and on-demand content across football, boxing, MMA, NFL, motorsport, basketball, golf, and dozens more sports in 200+ countries.

This Actor extracts the full electronic program guide (EPG) from DAZN's schedule page and returns clean, structured JSON for every event. It works across all DAZN markets, so you get the exact catalog available in each country.

### Use cases

- **Sports data aggregation** - Collect DAZN programming data alongside other streaming platforms to build a unified sports TV guide.
- **Competitive monitoring** - Track which sports, leagues, and events DAZN broadcasts in each market. Monitor catalog changes over time.
- **Content scheduling** - Feed DAZN event data into editorial calendars, social media schedulers, or notification systems (e.g., alert fans when their team plays).
- **Market research** - Compare DAZN's content offering across countries. Identify which sports or leagues are exclusive to specific markets.
- **Betting and fantasy sports** - Use the schedule as a data source for upcoming matches, event times, and competition metadata.

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| Country | Select | Czech Republic | DAZN market to scrape. Content rights differ per country, so the schedule changes based on this selection. Available: Austria, Brazil, Canada, Switzerland, Czech Republic, Germany, Spain, France, United Kingdom, Italy, Japan, Poland, Portugal, United States. |
| Start date | Date | Today | First day of the date range to scrape. |
| End date | Date | Start + 7 days | Last day of the date range. |
| Days ahead | Integer | 7 | Alternative to End date. How many days to scrape from the start date. Ignored when End date is set. Maximum: 90. |
| Timezone offset | Integer | 120 | Timezone offset from UTC in minutes. Common values: CET = 60, CEST = 120, GMT = 0, EST = -300, PST = -480, JST = 540. Affects how event times are bucketed into days. |

### Output

The Actor produces a dataset with one row per event. Each row contains:

| Field | Type | Example | Description |
|-------|------|---------|-------------|
| `date` | String | `"2026-06-05"` | Event date (YYYY-MM-DD, UTC). |
| `time` | String | `"11:00"` | Event start time (HH:MM, UTC). |
| `title` | String | `"LIV Golf Andalucia - Day 2"` | Full event title as shown on DAZN. |
| `competition` | String | `"LIV Golf"` | Competition or league name (e.g., "NFL Game Pass", "Matchroom Boxing", "WRC"). |
| `sport` | String | `"Golf"` | Sport category. |
| `type` | String | `"UpComing"` | Event status: `UpComing` (scheduled), `CatchUp` (replay available), `Highlights`. |
| `description` | String | `"Watch the latest action..."` | Event description from DAZN. May be `null` for some events. |
| `contestants` | String | `"Colorado Avalanche vs Vegas Golden Knights"` | Competing teams or athletes, joined with "vs". Empty string if not applicable (e.g., golf, motorsport). |
| `start_utc` | String | `"2026-06-05T11:00:00Z"` | Full ISO 8601 start timestamp in UTC. |
| `end_utc` | String | `"2026-06-05T13:30:00Z"` | Full ISO 8601 end timestamp in UTC. `null` for upcoming events. |
| `age_rating` | String | `"16_orange"` | Content age rating. |
| `free` | Boolean | `false` | Whether the event is free to watch without a DAZN subscription. |
| `dazn_id` | String | `"Epg:1lhbgc..."` | DAZN's internal event identifier. |

#### Example output

```json
[
    {
        "date": "2026-06-05",
        "time": "11:00",
        "title": "LIV Golf Andalucia - Day 2",
        "competition": "LIV Golf",
        "sport": "Golf",
        "type": "UpComing",
        "description": "Day 2 of LIV Golf Andalucia from Real Club Valderrama.",
        "contestants": "",
        "start_utc": "2026-06-05T11:00:00Z",
        "end_utc": null,
        "age_rating": "0_green",
        "free": false,
        "dazn_id": "Epg:abc123def456"
    },
    {
        "date": "2026-06-05",
        "time": "14:45",
        "title": "Freestyle Friday #12",
        "competition": "Freestyle Friday Championship",
        "sport": "MMA",
        "type": "UpComing",
        "description": null,
        "contestants": "",
        "start_utc": "2026-06-05T14:45:00Z",
        "end_utc": null,
        "age_rating": "16_orange",
        "free": false,
        "dazn_id": "Epg:xyz789ghi012"
    },
    {
        "date": "2026-06-04",
        "time": "22:30",
        "title": "Ramirez vs. Richards",
        "competition": "Eye of The Tiger",
        "sport": "Boxing",
        "type": "UpComing",
        "description": "The undefeated Albert Ramirez (22-0) makes the first defense of his WBA 'interim' light heavyweight title.",
        "contestants": "",
        "start_utc": "2026-06-04T22:30:00Z",
        "end_utc": null,
        "age_rating": "16_orange",
        "free": false,
        "dazn_id": "Epg:1lhbgc1th2pac"
    }
]
````

### How to use

#### Run from Apify Console

1. Go to the Actor's page on Apify Store.
2. Click **Start**.
3. Select a country, pick a date range (or leave defaults for the next 7 days), and click **Run**.
4. When the run finishes, go to the **Dataset** tab to view, download, or export results in JSON, CSV, Excel, or other formats.

#### Schedule daily runs

Set up a [Schedule](https://docs.apify.com/platform/schedules) to run the Actor automatically - for example, every morning at 6 AM to get the day's upcoming events. Use the **Days ahead** input set to `1` to fetch only today's schedule.

#### Call via API

Start the Actor programmatically and retrieve results using the [Apify API](https://docs.apify.com/api/v2):

```bash
curl "https://api.apify.com/v2/acts/YOUR_USERNAME~dazn-schedule-scraper/runs?token=YOUR_API_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "country": "gb",
    "daysAhead": 14
  }'
```

#### Integrate with other tools

Export DAZN schedule data directly to Google Sheets, Slack, webhooks, or any destination using [Apify Integrations](https://docs.apify.com/platform/integrations). Common setups:

- **Google Sheets** - Automatically append new events to a spreadsheet each day.
- **Webhook** - POST event data to your backend whenever a run completes.
- **Zapier / Make / n8n** - Trigger downstream workflows based on new events.

### Supported DAZN markets

| Country | Code | Key sports |
|---------|------|------------|
| Austria | `at` | Football (Bundesliga), motorsport, boxing |
| Brazil | `br` | Football (Serie A), UFC, boxing |
| Canada | `ca` | NFL, boxing, MMA, football |
| Switzerland | `ch` | Football, motorsport, boxing |
| Czech Republic | `cz` | NFL Game Pass, boxing, MMA, motorsport, football |
| Germany | `de` | Football (Bundesliga, Champions League), NFL, boxing, tennis |
| Spain | `es` | Football (La Liga), boxing, MMA, motorsport |
| France | `fr` | Football (Ligue 1), boxing, MMA |
| United Kingdom | `gb` | Boxing, NFL, MMA, football, darts |
| Italy | `it` | Football (Serie A), boxing, MMA, motorsport |
| Japan | `jp` | Baseball, football, boxing, F1 |
| Poland | `pl` | Football, boxing, MMA |
| Portugal | `pt` | Football, boxing, MMA |
| United States | `us` | NFL, boxing, MMA, football |

Content catalogs differ significantly between markets due to regional broadcasting rights.

### Performance and cost

This Actor is lightweight and fast. It does not use a browser - it extracts data directly from DAZN's publicly available schedule, keeping compute usage minimal.

- **Speed**: A typical 7-day run finishes in under 10 seconds.
- **Compute**: Each run uses minimal compute units (fractions of a cent).
- **No proxy needed**: Runs without Apify Proxy, so there is no additional proxy cost.

### Limitations

- **Schedule depth**: DAZN typically publishes schedule data 3-4 weeks ahead. Requesting dates further out may return fewer or no events.
- **Content rights**: Event availability depends on the selected country. An event visible in Germany may not appear in the UK schedule.
- **UTC times**: All timestamps are in UTC. Use the timezone offset input to control how events are grouped into days, but the output `start_utc` and `end_utc` are always UTC.
- **No video content**: This Actor extracts schedule metadata only. It does not access, download, or stream any video content from DAZN.

### FAQ

**Can I scrape the schedule for a country not in the list?**
The Actor supports the 14 main DAZN markets. DAZN is available in 200+ countries, but the schedule structure may differ in unlisted regions. If you need a specific country, reach out and we can check.

**How often does the schedule update?**
DAZN updates its schedule continuously as new events are confirmed. For the most current data, run the Actor daily or more frequently.

**Can I filter by sport or competition?**
The Actor returns all events for the selected country and date range. Filter the output dataset by `sport` or `competition` after the run, either in the Console or via the API.

# Actor input Schema

## `country` (type: `string`):

DAZN market. Determines which events are available (content rights differ per country).

## `startDate` (type: `string`):

Start of the date range. Defaults to today.

## `endDate` (type: `string`):

End of the date range. Defaults to startDate + daysAhead.

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

How many days to fetch from startDate (used when endDate is not set).

## `timeZoneOffset` (type: `integer`):

Minutes from UTC. CET=60, CEST=120, EST=-300, etc.

## Actor input object example

```json
{
  "country": "cz",
  "daysAhead": 7,
  "timeZoneOffset": 120
}
```

# 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("vittuhy/dazn-sports-schedule-events-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("vittuhy/dazn-sports-schedule-events-scraper").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 vittuhy/dazn-sports-schedule-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=vittuhy/dazn-sports-schedule-events-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DAZN Sports Schedule & Events Scraper",
        "description": "Scrape the complete DAZN TV schedule and get structured data for every event - past, live, and upcoming. Covers all sports and all 14 DAZN markets worldwide.",
        "version": "0.0",
        "x-build-id": "MVR3rVgfQd2IaDweK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vittuhy~dazn-sports-schedule-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vittuhy-dazn-sports-schedule-events-scraper",
                "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/vittuhy~dazn-sports-schedule-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-vittuhy-dazn-sports-schedule-events-scraper",
                "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/vittuhy~dazn-sports-schedule-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-vittuhy-dazn-sports-schedule-events-scraper",
                "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",
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "at",
                            "br",
                            "ca",
                            "ch",
                            "cz",
                            "de",
                            "es",
                            "fr",
                            "gb",
                            "it",
                            "jp",
                            "pl",
                            "pt",
                            "us"
                        ],
                        "type": "string",
                        "description": "DAZN market. Determines which events are available (content rights differ per country).",
                        "default": "cz"
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Start of the date range. Defaults to today."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "End of the date range. Defaults to startDate + daysAhead."
                    },
                    "daysAhead": {
                        "title": "Days ahead",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "How many days to fetch from startDate (used when endDate is not set).",
                        "default": 7
                    },
                    "timeZoneOffset": {
                        "title": "Timezone offset (minutes)",
                        "type": "integer",
                        "description": "Minutes from UTC. CET=60, CEST=120, EST=-300, etc.",
                        "default": 120
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
