# EuroMillions Results Scraper (`automation-lab/euromillions-results-scraper`) Actor

Extract EuroMillions draw history with dates, five winning numbers, two Lucky Stars, jackpots, and source links. Filter by date or process exact result URLs.

- **URL**: https://apify.com/automation-lab/euromillions-results-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.88 / 1,000 item extracteds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## EuroMillions Results Scraper

Extract structured **EuroMillions results** from euro-millions.com for one draw,
a date range, or the complete draw history since 2004.

Each dataset row contains the draw date, five main numbers, two Lucky Stars,
the advertised jackpot, and a source link. Use scheduled runs to refresh a
spreadsheet, dashboard, database, or combination-analysis workflow after a draw.

### What does EuroMillions Results Scraper do?

The Actor reads public yearly history and draw-detail pages and turns them into
consistent JSON records.

It supports:

- newest-first results within a date range;
- complete historical extraction from the first draw onward;
- one or more explicit result or yearly-history URLs;
- a strict item limit for small tests and integrations;
- structured Dataset exports in JSON, CSV, Excel, XML, and RSS.

The Actor uses lightweight HTTP requests rather than a browser. No login or
proxy configuration is required. Cloud runs try Apify's managed datacenter
proxy and use a GB residential fallback when that route is unavailable.

### Who is this EuroMillions results dataset for?

This Actor is useful for:

- analysts studying historical number and Lucky Star frequencies;
- spreadsheet users refreshing a draw-history workbook;
- journalists maintaining lottery-results tables;
- developers powering dashboards and internal data products;
- data engineers loading draw records into a warehouse;
- operators scheduling a post-draw refresh and comparing new rows.

It reports source data. It does not predict winning numbers, check tickets, or
provide gambling advice.

### Why use this Actor?

Yearly pages use visual HTML that changes shape across integrations. This Actor
normalizes each draw into stable typed fields and keeps source URLs for audit.

Compared with manually copying results, it provides:

- repeatable date filtering;
- machine-readable arrays of winning numbers;
- numeric jackpot values suitable for calculations;
- deduplication by draw date;
- direct exports and Apify API integrations;
- bounded retries for temporary source errors.

### What data can I extract?

| Field | Type | Meaning |
| --- | --- | --- |
| `drawDate` | string | Draw date in `YYYY-MM-DD` format |
| `drawDay` | string | Weekday reported for the draw |
| `mainNumbers` | number\[] | Five winning main numbers |
| `luckyStars` | number\[] | Two winning Lucky Stars |
| `jackpotAmount` | number or null | Integer jackpot amount in the currency identified by `jackpotCurrency` |
| `jackpotCurrency` | string or null | `EUR` or `GBP`, matching the source display |
| `jackpotDisplay` | string or null | Source-formatted jackpot text |
| `sourceUrl` | string | Public draw detail page |
| `scrapedAt` | string | Extraction timestamp |

`jackpotAmount` and `jackpotDisplay` can be null when the source omits a jackpot.
Winning numbers are required for a row to be saved.

### How to get EuroMillions results

1. Open the Actor in Apify Console.
2. Set **From date** and **To date** for the period you need.
3. Leave **Specific result or history URLs** empty for automatic yearly discovery.
4. Set **Maximum draws** high enough for the requested range.
5. Click **Start**.
6. Open the Dataset when the run finishes.
7. Export the rows or connect the Dataset API to your workflow.

For a quick smoke test, use one year and `maxItems: 10`.

### Input parameters

#### `fromDate`

Earliest draw date to include in `YYYY-MM-DD` format.
The default is `2004-02-13`, the first EuroMillions draw.

#### `toDate`

Latest draw date to include in `YYYY-MM-DD` format.
When omitted, the Actor uses the current date.

#### `startUrls`

Optional list of euro-millions.com URLs.
Supported forms are:

- `https://www.euro-millions.com/results/DD-MM-YYYY`
- `https://www.euro-millions.com/results-history-YYYY`

Date filters apply to explicit URLs too.
Other hosts and paths fail closed with a clear input error.

#### `proxyMode`

Cloud routing mode. `auto` tries the lower-cost datacenter route and falls back
to GB residential when needed. `residential` starts with the measured GB
residential route and is recommended for large complete-history exports.
Local runs use direct HTTP.

#### `maxItems`

Maximum number of draws to save, from 1 to 2,000.
Results are processed newest first.
The default of 2,000 covers the supported complete history at release time.

### Example inputs

Latest ten results from 2025:

```json
{
  "fromDate": "2025-01-01",
  "toDate": "2025-12-31",
  "maxItems": 10
}
```

One exact draw:

```json
{
  "startUrls": [
    { "url": "https://www.euro-millions.com/results/30-12-2025" }
  ],
  "fromDate": "2025-12-30",
  "toDate": "2025-12-30",
  "maxItems": 1
}
```

Complete history through 2025:

```json
{
  "fromDate": "2004-02-13",
  "toDate": "2025-12-31",
  "maxItems": 2000,
  "proxyMode": "residential"
}
```

### Output example

A real output row has this shape:

```json
{
  "drawDate": "2025-12-30",
  "drawDay": "Tuesday",
  "mainNumbers": [11, 26, 29, 34, 44],
  "luckyStars": [1, 10],
  "jackpotAmount": 17000000,
  "jackpotCurrency": "EUR",
  "jackpotDisplay": "€17,000,000",
  "sourceUrl": "https://www.euro-millions.com/results/30-12-2025",
  "scrapedAt": "2026-01-15T12:00:00.000Z"
}
```

The primary output is always the default Apify Dataset.

### How much does it cost to extract EuroMillions draw results?

Pay-per-event pricing includes a **$0.005 start fee** and a tiered charge for
each saved draw. The BRONZE per-draw price is **$0.0048**; higher usage tiers
receive progressively lower per-draw prices.

Approximate BRONZE examples:

| Saved draws | Example total |
| ---: | ---: |
| 1 | $0.0098 |
| 100 | $0.485 |
| 1,000 | $4.805 |

Only validated records pushed to the Dataset incur the item event.
The Apify pricing panel shows the tier applicable to your account.

### Schedule a refresh after each draw

EuroMillions draws normally occur during the week, so a scheduled Actor Task can
keep a downstream dataset current.

A practical workflow is:

1. save the date-range input as an Apify Task;
2. schedule it after expected draw publication;
3. retrieve the newest Dataset items;
4. compare `drawDate` against your stored records;
5. append unseen records to a sheet or database.

The Actor itself does not send alerts or persist a cross-run change log.
Use Apify webhooks, Make, Zapier, or your application for notifications.

### Export to spreadsheets and data pipelines

From the Dataset page, choose CSV or Excel for spreadsheet analysis.
Arrays remain available in JSON for code-based workflows.

Typical downstream jobs include:

- number-frequency and pair-frequency tables;
- jackpot trend analysis;
- missing-combination exploration;
- scheduled warehouse ingestion;
- dashboard refreshes;
- source verification by draw date.

Never interpret historical frequencies as a guarantee of future outcomes.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~euromillions-results-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"fromDate":"2025-01-01","toDate":"2025-12-31","maxItems":10}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/euromillions-results-scraper').call({
  fromDate: '2025-01-01',
  toDate: '2025-12-31',
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/euromillions-results-scraper").call(run_input={
    "fromDate": "2025-01-01",
    "toDate": "2025-12-31",
    "maxItems": 10,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/euromillions-results-scraper"
```

#### Claude Desktop

Add this server object to your Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/euromillions-results-scraper"
    }
  }
}
```

#### Cursor

Open **Settings → Tools & MCP → Add custom MCP** and use the same `apify`
server URL shown above.

#### VS Code

Add the same HTTP server URL to your workspace MCP configuration, then enable
the `automation-lab/euromillions-results-scraper` tool.

Example prompts:

- “Get the ten newest EuroMillions results from 2025.”
- “Extract the 30 December 2025 draw as structured JSON.”
- “Build a EuroMillions history dataset from 2004 through 2025.”

Review generated inputs before running large jobs.

### Limits and source behavior

- The Actor supports public pages on `euro-millions.com` only.
- Automatic history discovery requests one page per included calendar year.
- The maximum output is 2,000 draws per run.
- Results are returned newest first.
- Date values use calendar dates, not timestamps or local draw times.
- Jackpot currency follows the source display (`EUR` or `GBP`); residential geography can affect the displayed currency.
- Prize-tier breakdowns, raffle codes, and ticket checking are not extracted.
- A source redesign can require a parser update.
- Cloud runs probe a datacenter proxy once, then use a GB residential fallback if needed; local runs use direct HTTP.
- Temporary non-200 responses are retried twice, then fail the run.

A no-result date range succeeds with an empty Dataset.
Malformed dates and unsupported URLs fail rather than returning misleading data.

### Responsible use and legality

The Actor accesses publicly visible draw-result pages.
Use the output in accordance with applicable law, the source terms, and Apify's
policies. Do not overload the source or represent the data as official advice.

Lottery participation can involve financial and age restrictions.
This product is a data extraction tool and does not encourage wagering,
predict outcomes, or guarantee accuracy beyond the cited public source.
Verify critical uses against official lottery publications.

### Troubleshooting

#### Why is my Dataset empty?

Check that `fromDate` is not after `toDate` and that the selected range contains
a draw. When using `startUrls`, confirm the URL's draw date is inside the same
filters.

#### Why did an explicit URL fail?

Only result-detail and yearly-history paths on euro-millions.com are accepted.
Remove query-only pages, translated domains, and unrelated lottery URLs.

#### Why did the run stop with a source HTTP error?

The source may be temporarily unavailable or rate limiting requests.
Wait and retry once. If the error persists, inspect the run log and source page.
No proxy setting is needed or exposed by this Actor.

#### Why is a jackpot null?

Some source rows may omit the jackpot. The numbers and source URL remain useful,
while null prevents an unsupported value from being invented.

### FAQ

#### Does it include every EuroMillions draw since 2004?

The default range begins with the first draw and the 2,000-item limit is sized
to cover the complete supported history at release. A future history above that
limit must be split into date ranges.

#### Can I get today's result?

Yes, after euro-millions.com publishes it. Omit `toDate` or include today's date,
and use a small `maxItems` value for a quick refresh.

#### Can I find combinations that never appeared?

The Actor supplies the complete historical winning combinations. Calculate the
set difference in a spreadsheet, notebook, or database. It does not generate all
possible combinations itself.

#### Does it extract prize breakdowns?

No. It extracts draw date, winning numbers, Lucky Stars, and the advertised
jackpot. Prize tiers and winner counts are outside the current output contract.

#### Can I schedule it?

Yes. Save the input as an Apify Task, add a schedule, and connect a webhook or
integration to consume each run's Dataset.

### Related Automation Lab Actors

This Actor is currently a standalone EuroMillions history product.
For generic transformations, browse the
[Automation Lab Store profile](https://apify.com/automation-lab).

Only Automation Lab Actors are listed here; third-party lottery Actors are not
presented as related products.

### Support

If a valid source page no longer parses, include the failing URL, input, and run
ID in an Apify issue. Do not include API tokens or private downstream data.

# Actor input Schema

## `fromDate` (type: `string`):

Earliest draw date to include, in YYYY-MM-DD format. Defaults to the first EuroMillions draw.

## `toDate` (type: `string`):

Latest draw date to include, in YYYY-MM-DD format. Leave empty to use today's date.

## `startUrls` (type: `array`):

Optional euro-millions.com URLs in /results/DD-MM-YYYY or /results-history-YYYY format. Date filters still apply.

## `proxyMode` (type: `string`):

Auto tries the lower-cost datacenter route before GB residential fallback. Residential starts with the more stable GB residential route for large history exports.

## `maxItems` (type: `integer`):

Maximum number of draw records to save. Results are processed newest first.

## Actor input object example

```json
{
  "fromDate": "2025-01-01",
  "startUrls": [],
  "proxyMode": "auto",
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing draw dates, numbers, Lucky Stars, jackpots, and source links.

# 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 = {
    "fromDate": "2025-01-01",
    "startUrls": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/euromillions-results-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 = {
    "fromDate": "2025-01-01",
    "startUrls": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/euromillions-results-scraper").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 '{
  "fromDate": "2025-01-01",
  "startUrls": [],
  "maxItems": 10
}' |
apify call automation-lab/euromillions-results-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/euromillions-results-scraper"
        }
    }
}

```

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/WriNUB7zxnq9JEtae/builds/cVjzp4sWDQPNuNfH0/openapi.json