# EU Dividends & Splits by ISIN ($1.00/1K) (`carabain-digital/eu-dividends`) Actor

Dividend history and splits per ISIN for European and UK shares: ex-date, pay date, declaration date, type, status and the declared amount and currency, merged from Yahoo Finance, Dividendmax and Borsa Italiana. Built for portfolio trackers.

- **URL**: https://apify.com/carabain-digital/eu-dividends.md
- **Developed by:** [Carabain Digital](https://apify.com/carabain-digital) (community)
- **Categories:** Developer tools, Automation
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 dividend or splits

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

#### What is EU Dividends & Splits by ISIN?

**EU Dividends & Splits by ISIN** gives you the **dividend history, upcoming dividends and stock splits of European and UK shares, looked up by ISIN**. For every payment you get the **ex-date, pay date, declaration date, type (quarterly, interim, final, special), status (paid, declared, forecast) and the amount in the currency the company declared it**, next to Yahoo's split-adjusted amount for total-return maths. The data is merged from three public sources (Yahoo Finance, Dividendmax and Borsa Italiana) into one clean, flat schema, so you don't have to stitch tickers, pence and special dividends together yourself. Built for **portfolio trackers, dividend calendars and income dashboards**. Prefilled example: ASML, Shell and Enel, ready in seconds. Costs **$1.00 per 1,000 events**.

- 🔑 **ISIN in, events out**: no ticker lookups, the primary listing is found for you
- 📅 **Ex-date and pay date**: the two dates a tracker needs, plus the declaration date
- 💱 **Declared amount and currency**: Shell's dividend in USD as declared, not converted pence
- ✂️ **Special dividends kept apart**: a regular and a special payment on the same day are two events, not one summed number
- 🔀 **Splits and reverse splits** with the ratio, so you can adjust share counts
- 🔮 **Upcoming dividends**: declared payments and (optional) forecast dates for the next 12 months
- 🌍 **All of Europe**: Amsterdam, Paris, Brussels, Lisbon, Dublin, Milan, Frankfurt/Xetra, London, Zurich, Oslo, Stockholm, Copenhagen, Helsinki, Madrid, Vienna, Warsaw
- 🔌 **Connect anywhere**: API, schedules, webhooks, Google Sheets, Make, Zapier, MCP / AI agents

#### What data can I get?

<table>
<tr><td>🆔 ISIN, ticker, company name, exchange, trading currency</td><td>📌 Event: dividend, split or reverse split</td></tr>
<tr><td>📅 Ex-date, pay date, declaration date</td><td>🏷️ Type (quarterly, interim, final, special, ...) and status (paid, declared, forecast)</td></tr>
<tr><td>💶 Dividend per share as declared, with ISO currency</td><td>📉 Yahoo's split-adjusted amount in the trading currency</td></tr>
<tr><td>🔀 Split ratio (3:1, 8:9)</td><td>🔗 Sources and source URLs per event</td></tr>
</table>

Record dates, withholding tax (gross/net), rights issues and spin-offs are not published in a structured, public form and are not included.

#### How do I get dividend data by ISIN?

1. [Create a free Apify account](https://console.apify.com/sign-up) and open this Actor.
2. Paste your **ISINs**, one per line (up to 1,000 per run).
3. Optionally set a **From date**, and switch **Include forecasts** on for expected dividends.
4. Click **Start**, then download the events from the **Output** tab as JSON, CSV, Excel, XML or HTML.

#### How much does it cost?

You pay per event that ends up in your dataset: **$1.00 per 1,000 events**, no subscription. A large European share has 30-120 events over its whole history, so the full history of 100 shares costs about $5; with a **From date** of last year it is a few cents. The monthly credit of Apify's Free plan ($5) covers around 5,000 events. Paid plans get volume discounts. Failed runs cost nothing, and you can cap spending with **Maximum cost per run** in the run options.

#### ⬇️ Input

| Field | Description |
|---|---|
| **ISINs** (`isins`) | ISINs of the shares, e.g. `NL0010273215` (ASML). Up to 1,000 per run |
| **From date** (`from_date`) | Only events with an ex-date on or after this day. Empty = full history |
| **Include splits** (`includeSplits`) | Splits and reverse splits as events (default on) |
| **Include forecasts** (`includeForecasts`) | Forecast dividends for the next 12 months: dates and type, no amount (default off) |
| **Max events** (`limit`) | Stop after this many events in total |
| **Proxy** (`proxyConfiguration`) | Apify datacenter proxy by default |

```json
{
    "isins": ["NL0010273215", "GB00BP6MXD84", "IT0003128367"],
    "from_date": "2024-01-01",
    "includeSplits": true,
    "includeForecasts": false
}
```

#### ⬆️ Output

One item per event per ISIN, newest last. View them as a table in the **Output** tab or export JSON, CSV, Excel, XML or HTML. Every item has the same keys; fields that do not apply are `null`.

```json
{
    "id": "GB00BP6MXD84:dividend:2026-08-13",
    "event": "dividend",
    "isin": "GB00BP6MXD84",
    "ticker": "SHEL.L",
    "name": "Shell plc",
    "exchange": "London",
    "listing_currency": "GBP",
    "status": "paid",
    "dividend_type": "quarterly",
    "declaration_date": "2025-10-30",
    "ex_date": "2026-08-13",
    "pay_date": "2026-09-21",
    "amount": 0.3906,
    "currency": "USD",
    "amount_is_declared": true,
    "adjusted_amount": 0.2892,
    "adjusted_currency": "GBP",
    "split_ratio": null,
    "split_from": null,
    "split_to": null,
    "sources": ["yahoo", "dividendmax"],
    "source_urls": [
        "https://finance.yahoo.com/quote/SHEL.L/history?filter=div",
        "https://www.dividendmax.com/united-kingdom/london-stock-exchange/oil-and-gas-producers/shell-plc/dividends"
    ],
    "scraped_at": "2026-11-06T10:23:23Z"
}
```

**`amount` and `currency`** are what the company declared, before later splits (`amount_is_declared: true`). When only Yahoo knows the event (mostly payments before about 2008), `amount` is Yahoo's split-adjusted amount and `amount_is_declared` is `false`. **`adjusted_amount`** is always Yahoo's split-adjusted amount in the trading currency: use it with today's share count, use `amount` with the share count at the time.

#### What can I do with this data?

- 📅 **Dividend calendar**: upcoming ex-dividend dates and pay dates for a watch list, refreshed by a daily schedule
- 📊 **Dividend portfolio tracker**: income per holding, received and expected, keyed by ISIN
- 📈 **Dividend growth screening**: payout cadence and yearly growth across European and UK shares
- ⭐ **Special dividend tracking**: special payments kept apart from regular ones
- 💹 **Total return**: combine `adjusted_amount` and split ratios with price history
- 🧾 **Bookkeeping and tax prep**: payments per year with pay dates and declared currency

#### ⚠️ Good to know

- **Coverage of the extra fields** (pay date, type, declared amount) is about 1,000 European and 1,550 UK shares: the large and mid caps. For smaller shares you get Yahoo's ex-date and adjusted amount only. In our test set every payment since 2024 had a pay date and a declared amount.
- **Declaration dates** for payments far ahead can be the date the yearly dividend policy was announced (Shell declares a year of quarterly payments at once).
- **Forecasts** are estimates of the dates only; the amounts are not public.
- **One listing per ISIN**: the primary listing on Yahoo Finance. Dividends are paid per share, so this does not change the amounts.
- ETFs work for the Yahoo part (distributions and ex-dates).

#### Other EU market data Actors

| Actor | What it does |
|---|---|
| [EU Short Positions Register](https://apify.com/carabain-digital/eu-short-positions) | Disclosed net short positions in European and UK shares from 9 regulators: holder, issuer, ISIN, net short %, date. |

#### Frequently asked questions

#### Can I use it with the Apify API?

Yes. Every run has a dataset you can read through the [Apify API](https://docs.apify.com/api/v2). Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("carabain-digital/eu-dividends").call(run_input={
    "isins": ["NL0010273215", "FR0000120271"],
    "from_date": "2025-01-01",
})
for event in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(event["isin"], event["ex_date"], event["pay_date"], event["amount"], event["currency"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('carabain-digital/eu-dividends').call({
    isins: ['NL0010273215', 'FR0000120271'],
    from_date: '2025-01-01',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'dividend events');
```

#### Can I call it as a real-time API?

Yes. This Actor also runs as a **Server Actor**: send an HTTP request and get the results back in the response, no run to start or dataset to fetch. Handy for the dividends and splits of a few ISINs inside your own app or spreadsheet. Pass the same fields as the normal input, in the query string (repeat a key for a list) or as a JSON body:

```bash
curl "https://carabain-digital--eu-dividends.apify.actor/?isins=NL0010273215&isins=US0378331005&limit=10" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>"
```

The response is a JSON array of the same items a normal run returns, billed the same way. Errors come back as `{"error": ..., "message": ...}` with status 400 (invalid input) or 502 (the site blocked the request). The first request after a pause takes a few seconds longer while the server starts. See the **Server** tab for details.

#### Can I use it through an MCP server or with AI agents?

Yes. Add it to an AI agent through the [Apify MCP server](https://mcp.apify.com) (`https://mcp.apify.com?tools=carabain-digital/eu-dividends`), or let the agent find it with `search-actors` and run it with `call-actor`. A run for a few ISINs finishes in seconds and the items are small and flat. Example prompt: *"Use EU Dividends & Splits by ISIN to list the dividends ASML and TotalEnergies paid in 2025 with their pay dates."*

#### How do I keep a dividend calendar up to date?

Create a **Task** with your ISINs and a **From date** of a month ago, switch on **Include forecasts**, and schedule it daily or weekly. Newly declared dividends show up with `status: "declared"`; when the pay date passes they become `paid`. The `id` stays the same, so you can upsert on it.

#### Why is `pay_date` empty for some events?

Yahoo Finance only publishes the ex-date. The pay date comes from Dividendmax or Borsa Italiana, which cover the large and mid caps and roughly the years since 2008.

#### Is it legal to use this data?

The Actor reads publicly visible pages and endpoints, without a login, and returns facts about listed companies (dates and amounts), no personal data. Check the terms of the sources for your use case, especially for commercial redistribution. More background: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

#### Not working? Feedback

Open an issue on the **Issues** tab of this Actor with the run link and the ISIN, and we will look at it. Feature ideas (more sources, record dates, other markets) are welcome there too.

#### Other scrapers by us

| Actor | Covers |
|---|---|
| [ImmoScout24 Scraper](https://apify.com/carabain-digital/immoscout24-listings) | German real estate listings |
| [StepStone Jobs Scraper](https://apify.com/carabain-digital/stepstone-jobs) | German job postings |

⭐ **Does it work well for you?** A review on the Store page helps others find this Actor and helps us keep it maintained.

# Actor input Schema

## `isins` (type: `array`):

ISINs of the shares, one per line. Example: `NL0010273215` (ASML), `GB00BP6MXD84` (Shell), `IT0003128367` (Enel). Up to 1,000 per run. The primary listing is looked up on Yahoo Finance; ISINs Yahoo does not know are skipped and logged.

## `from_date` (type: `string`):

Only events with an ex-date on or after this day, YYYY-MM-DD. Example: `2024-01-01`. Leave empty for the full history (Yahoo goes back to the 1990s for most large caps).

## `includeSplits` (type: `boolean`):

Also return stock splits and reverse splits (consolidations) as events, with the ratio.

## `includeForecasts` (type: `boolean`):

Also return Dividendmax's forecast dividends for the next 12 months: expected ex-date, pay date and type, without an amount (forecast amounts are not public).

## `limit` (type: `integer`):

Stop after this many events in total. Example: `500`. Leave empty for all events of all ISINs.

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

The sources are public. The default (Apify datacenter proxy) is the cheapest; switch to Residential only if runs get blocked.

## Actor input object example

```json
{
  "isins": [
    "NL0010273215",
    "GB00BP6MXD84",
    "IT0003128367"
  ],
  "includeSplits": true,
  "includeForecasts": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `events` (type: `string`):

All dividend and split events, one item per event per ISIN.

# 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 = {
    "isins": [
        "NL0010273215",
        "GB00BP6MXD84",
        "IT0003128367"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("carabain-digital/eu-dividends").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 = {
    "isins": [
        "NL0010273215",
        "GB00BP6MXD84",
        "IT0003128367",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("carabain-digital/eu-dividends").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 '{
  "isins": [
    "NL0010273215",
    "GB00BP6MXD84",
    "IT0003128367"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call carabain-digital/eu-dividends --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,carabain-digital/eu-dividends"
        }
    }
}
```

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/OR6MGazA8gCXVTyIg/builds/Mca3KFeJp3ziTizxR/openapi.json
