# Euronext Scraper - European Stock Exchange Data (`studio-amba/euronext-scraper`) Actor

Scrape stock prices, market data, and financial metrics from Euronext, Europe's largest stock exchange. Covers Amsterdam, Paris, Brussels, Lisbon, Dublin, Oslo, and Milan. Extract real-time quotes, volume, market cap, P/E ratios, and dividend yields. No login required.

- **URL**: https://apify.com/studio-amba/euronext-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Euronext Scraper

Scrape stock prices, market data, and financial metrics from Euronext -- Europe's largest stock exchange operating in Amsterdam, Paris, Brussels, Lisbon, Dublin, Oslo, and Milan.

### How to scrape Euronext data

Euronext is the leading pan-European stock exchange, listing thousands of equities, ETFs, bonds, and derivatives across 7 countries. This actor extracts structured market data from Euronext's live quotes platform without any login or cookies required.

1. Go to the actor's input page.
2. Enter a search query (e.g., "ASML", "TotalEnergies", "Shell", "Unilever") or provide a direct instrument URL.
3. Optionally select a specific exchange (Amsterdam, Paris, Brussels, Lisbon, Dublin, Oslo, or Milan).
4. Set the maximum number of results you want.
5. Click "Start" and wait for the run to finish.
6. Download your data in JSON, CSV, or Excel format.

The actor searches Euronext just like a regular user would, navigates to instrument detail pages, and extracts comprehensive market data including prices, volume, market cap, P/E ratios, and dividend yields.

### Features

- Search stocks and ETFs across all 7 Euronext exchanges
- Filter by specific exchange (Amsterdam, Paris, Brussels, Lisbon, Dublin, Oslo, Milan)
- Scrape individual instrument pages by URL
- Extracts 20+ data fields per instrument: price, change, volume, market cap, P/E, dividend yield, 52-week range, and more
- ISIN and MIC codes for professional data matching
- Automatic pagination for large result sets
- Multi-strategy DOM extraction for reliable data capture
- No cookies or login required
- Residential proxy support for reliable access

### Input options

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `searchQuery` | String | Stock ticker or company name to search | `"ASML"` |
| `exchange` | Select | Target exchange: `all`, `amsterdam`, `paris`, `brussels`, `lisbon`, `dublin`, `oslo`, `milan` | `"all"` |
| `instrumentUrl` | String | Optional: direct Euronext instrument page URL | -- |
| `maxResults` | Integer | Maximum number of instruments to return (1-5,000) | `50` |
| `proxyConfiguration` | Object | Proxy settings -- residential proxies recommended | NL residential |

#### Example input

```json
{
    "searchQuery": "ASML",
    "exchange": "amsterdam",
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "NL"
    }
}
````

#### Scraping a specific instrument

You can scrape a specific instrument page directly by providing the `instrumentUrl`:

```json
{
    "instrumentUrl": "https://live.euronext.com/en/product/equities/NL0010273215-XAMS",
    "maxResults": 1
}
```

#### Scraping a full exchange listing

To scrape all equities listed on a specific exchange:

```json
{
    "searchQuery": "a",
    "exchange": "brussels",
    "maxResults": 500
}
```

### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `ticker` | String | Stock ticker symbol (e.g., ASML, TTE) |
| `companyName` | String | Full company name as listed |
| `isin` | String | International Securities Identification Number |
| `exchange` | String | Exchange name (e.g., Euronext Amsterdam) |
| `mic` | String | Market Identifier Code (XAMS, XPAR, XBRU, etc.) |
| `lastPrice` | Number | Last traded price |
| `currency` | String | Trading currency (EUR, NOK, GBP) |
| `changePercent` | Number | Price change percentage from previous close |
| `changeAbsolute` | Number | Absolute price change |
| `openPrice` | Number | Opening price for the trading day |
| `highPrice` | Number | Day high price |
| `lowPrice` | Number | Day low price |
| `volume` | Number | Number of shares traded |
| `turnover` | Number | Total trading turnover |
| `marketCap` | String | Market capitalization |
| `peRatio` | Number | Price-to-earnings ratio |
| `dividendYield` | Number | Dividend yield percentage |
| `high52w` | Number | 52-week high price |
| `low52w` | Number | 52-week low price |
| `previousClose` | Number | Previous close price |
| `marketStatus` | String | Market trading status |
| `lastTradedTime` | String | Timestamp of the last trade |
| `instrumentType` | String | Type of instrument (Stock, ETF) |
| `url` | String | Euronext instrument page URL |
| `scrapedAt` | String | ISO 8601 timestamp |

### Example output

```json
{
    "ticker": "ASML",
    "companyName": "ASML HOLDING",
    "isin": "NL0010273215",
    "exchange": "Euronext Amsterdam",
    "mic": "XAMS",
    "lastPrice": 725.40,
    "currency": "EUR",
    "changePercent": 1.25,
    "changeAbsolute": 8.95,
    "openPrice": 718.00,
    "highPrice": 728.50,
    "lowPrice": 716.20,
    "volume": 1234567,
    "marketCap": "285.6B EUR",
    "peRatio": 38.5,
    "dividendYield": 0.82,
    "high52w": 1021.00,
    "low52w": 594.60,
    "previousClose": 716.45,
    "instrumentType": "Stock",
    "url": "https://live.euronext.com/en/product/equities/NL0010273215-XAMS",
    "scrapedAt": "2026-06-09T14:30:00.000Z"
}
```

### Supported exchanges

| Exchange | MIC | Currency | Country |
|----------|-----|----------|---------|
| Euronext Amsterdam | XAMS | EUR | Netherlands |
| Euronext Paris | XPAR | EUR | France |
| Euronext Brussels | XBRU | EUR | Belgium |
| Euronext Lisbon | XLIS | EUR | Portugal |
| Euronext Dublin | XMSM | EUR | Ireland |
| Oslo Bors (Euronext Oslo) | XOSL | NOK | Norway |
| Borsa Italiana (Euronext Milan) | XMIL | EUR | Italy |

### Cost estimate

The actor uses PlaywrightCrawler (browser-based rendering) because Euronext loads market data dynamically.

- 1-10 instruments: approximately $0.05-0.10 in platform costs
- 50 instruments: approximately $0.20-0.50 in platform costs
- 500 instruments: approximately $1-3 in platform costs
- Residential proxy usage adds to the cost depending on data transfer

For most use cases, a single run costs under $1.

### Limitations

- Euronext may rate-limit aggressive scraping -- use residential proxies for best results.
- Market data reflects delayed quotes from live.euronext.com (typically 15 minutes delayed for free access).
- Some data fields (P/E ratio, dividend yield, market cap) may not be available for all instruments.
- The actor works with Euronext's public pages. Real-time data requires a paid Euronext data subscription.
- The HTML structure of live.euronext.com may change without notice, which could temporarily affect extraction.

### Tips for best results

- **Use ticker symbols** -- "ASML" is more precise than "ASML Holding"
- **Filter by exchange** -- selecting a specific exchange reduces noise from cross-listed instruments
- **Direct URLs for known instruments** -- use `instrumentUrl` when you know the exact ISIN and MIC
- **Match proxy country** -- use NL proxies for Amsterdam, FR for Paris, NO for Oslo, etc.
- **Start small** -- test with `maxResults: 5` before running large scrapes

### Use cases

- **Portfolio monitoring** -- track holdings across European exchanges
- **Market research** -- analyze equities listed on specific Euronext markets
- **Financial data enrichment** -- add ISIN, MIC, and market data to investment databases
- **Screening** -- find stocks matching specific criteria across pan-European listings
- **Cross-listing analysis** -- compare pricing of the same stock across multiple Euronext venues
- **Dividend tracking** -- monitor dividend yields across European blue-chip stocks

# Actor input Schema

## `searchQuery` (type: `string`):

Search term to find stocks or ETFs on Euronext (e.g., 'ASML', 'TotalEnergies', 'Shell'). If empty, defaults to 'ASML'.

## `exchange` (type: `string`):

Euronext exchange to search. Use 'all' to search across all 7 exchanges.

## `instrumentUrl` (type: `string`):

Optional: a Euronext instrument page URL to scrape directly. Example: https://live.euronext.com/en/product/equities/NL0010273215-XAMS

## `maxResults` (type: `integer`):

Maximum number of instruments to return.

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

Proxy settings. Residential proxies are recommended for reliable access to Euronext.

## Actor input object example

```json
{
  "searchQuery": "ASML",
  "exchange": "all",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NL"
  }
}
```

# 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 = {
    "searchQuery": "ASML",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "NL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/euronext-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 = {
    "searchQuery": "ASML",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "NL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/euronext-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 '{
  "searchQuery": "ASML",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NL"
  }
}' |
apify call studio-amba/euronext-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Euronext Scraper - European Stock Exchange Data",
        "description": "Scrape stock prices, market data, and financial metrics from Euronext, Europe's largest stock exchange. Covers Amsterdam, Paris, Brussels, Lisbon, Dublin, Oslo, and Milan. Extract real-time quotes, volume, market cap, P/E ratios, and dividend yields. No login required.",
        "version": "0.1",
        "x-build-id": "PVQoyUGGzSCliSr7V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~euronext-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-euronext-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/studio-amba~euronext-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-euronext-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/studio-amba~euronext-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-euronext-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find stocks or ETFs on Euronext (e.g., 'ASML', 'TotalEnergies', 'Shell'). If empty, defaults to 'ASML'."
                    },
                    "exchange": {
                        "title": "Exchange",
                        "enum": [
                            "all",
                            "amsterdam",
                            "paris",
                            "brussels",
                            "lisbon",
                            "dublin",
                            "oslo",
                            "milan"
                        ],
                        "type": "string",
                        "description": "Euronext exchange to search. Use 'all' to search across all 7 exchanges.",
                        "default": "all"
                    },
                    "instrumentUrl": {
                        "title": "Instrument URL",
                        "type": "string",
                        "description": "Optional: a Euronext instrument page URL to scrape directly. Example: https://live.euronext.com/en/product/equities/NL0010273215-XAMS"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of instruments to return.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are recommended for reliable access to Euronext."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
