# European Parliament Votes API – MEP Roll-Call Voting Records (`benelux-signals/european-parliament-votes`) Actor

Every roll-call vote of the European Parliament as clean JSON from the official EP Open Data API: results, political group breakdown and how each MEP voted. Filter by topic, MEP, group, country and date; only-new mode for alerts.

- **URL**: https://apify.com/benelux-signals/european-parliament-votes.md
- **Developed by:** [Benelux Signals](https://apify.com/benelux-signals) (community)
- **Categories:** News, AI, Open source
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 vote records

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?

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

## European Parliament Votes API – MEP Roll-Call Voting Records

Get **every roll-call vote of the European Parliament** as clean JSON, CSV or Excel: what was voted on, the result, the **breakdown per political group**, and **how each MEP voted**. Data comes straight from the official [European Parliament Open Data Portal](https://data.europarl.europa.eu/) (CC BY 4.0).

*Not affiliated with or endorsed by the European Parliament.* One row per vote with **file title, report and rapporteur, amendment number, outcome (adopted / rejected / lapsed), votes for / against / abstentions, margin, group breakdown, document link, procedure id and official minutes link**. Or switch to **MEP voting records**: one row per MEP per vote, with country, political group, position and whether they voted with their group.

### Why use this European Parliament votes scraper?

- **Official open data only** – the European Parliament's own Open Data API (the source behind the published roll-call minutes). No login, no proxies, no paid API keys. Respects the API's crawl delay.
- **Votes and voting records in one Actor** – monitor plenary outcomes or build an MEP voting record without stitching XML minutes together.
- **Political group breakdown built in** – EPP (PPE), S\&D, PfE, ECR, Renew, Greens/EFA (Verts/ALE), The Left, ESN and non-attached, plus optional per-country counts.
- **Track MEPs by name** – `"meps": ["Roberta Metsola"]` adds how each tracked MEP voted to every vote, accent-insensitive.
- **Topic filters** – whole-word keyword search on the file title, report, amendment label and document reference (always in English plus your output language), and a filter for main/final votes, amendments, adopted or rejected.
- **Only-new mode** for alerts after each Strasbourg or Brussels plenary session (Slack, e-mail, Google Sheets, Make, Zapier).
- **24 EU languages** for titles and labels.

### Use cases

- **Public affairs and lobbying teams**: a weekly digest of adopted texts and close votes on your files (e.g. "energy", "AI", "agricultur\*"), with how each group voted.
- **Journalists and fact-checkers**: how did the MEPs from my country vote on a resolution? Who broke with their group?
- **NGOs and campaigners**: build scorecards and voting records for MEPs on climate, digital, migration or trade.
- **Researchers and political scientists**: cohesion and coalition analysis per group and country, ready for pandas or R.
- **AI agents and MCP**: give an agent fresh, structured European Parliament voting data to answer "how did Parliament vote on…?" questions.

### Input examples

Latest roll-call votes (last 30 days, all files):

```json
{ "maxResults": 100 }
```

Only final votes on energy and climate files in the last 90 days, with per-country breakdown:

```json
{ "keywords": ["energy", "climate", "emission*"], "voteKinds": ["main"], "lastDays": 90, "includeCountryBreakdown": true }
```

How did all Dutch and Belgian MEPs vote on main votes in October 2026?

```json
{ "outputMode": "mepVotes", "countries": ["NL", "BE"], "voteKinds": ["main"], "dateFrom": "2026-10-01", "dateTo": "2026-10-31", "maxResults": 5000 }
```

Track specific MEPs and get an alert after each plenary session (schedule weekly):

```json
{ "meps": ["Roberta Metsola", "Jeroen Lenaers"], "voteKinds": ["main"], "onlyNew": true, "stateKey": "my-meps" }
```

### Output example (Votes mode)

```json
{
  "status": "ok",
  "voteId": "198405",
  "date": "2026-10-22",
  "votedAt": "2026-10-22T13:16:17+02:00",
  "itemTitle": "Erasmus+ programme 2028-2034 ***I",
  "itemLabel": "Report: Bogdan Andrzej Zdrojewski (A10-0257/2026) (Majority of votes cast required)",
  "voteLabel": "A10-0257/2026 – Bogdan Andrzej Zdrojewski – Commission proposal",
  "voteKind": "main",
  "outcome": "ADOPTED",
  "votesFor": 454, "votesAgainst": 34, "votesAbstention": 93, "margin": 420,
  "requestedBy": null,
  "documentRef": "A10-0257/2026",
  "documentUrl": "https://www.europarl.europa.eu/doceo/document/A-10-2026-0257_EN.html",
  "procedureId": "2025-0222",
  "groupBreakdown": { "PPE": { "for": 139, "against": 2, "abstain": 0 }, "S&D": { "for": 112, "against": 0, "abstain": 0 }, "PfE": { "for": 16, "against": 15, "abstain": 42 }, "Renew": { "for": 67, "against": 0, "abstain": 0 } },
  "minutesUrl": "https://www.europarl.europa.eu/doceo/document/PV-10-2026-10-22-RCV_EN.html",
  "sourceUrl": "https://data.europarl.europa.eu/eli/dl/event/MTG-PL-2026-10-22-DEC-198405"
}
```

In **MEP votes** mode each row adds `mepId`, `mepName`, `country`, `politicalGroup`, `position` (FOR / AGAINST / ABSTAIN / NO_VOTE_RECORDED), `intendedPosition` (published vote corrections), `groupMajority` and `votedWithGroup`. A run summary (sittings scanned, votes matched, filtered-out counts) is saved as `RUN_SUMMARY` in the key-value store.

### Pricing

Pay per event, no subscription:

| Event | Free plan | Bronze | Silver | Gold+ |
|---|---|---|---|---|
| Vote saved (`vote-record`, Votes mode) | $0.002 | $0.0018 | $0.0016 | $0.0015 |
| MEP vote row saved (`mep-vote`, MEP votes mode) | $0.0002 | $0.0002 | $0.0002 | $0.0002 |
| Actor start | $0.001 | $0.001 | $0.001 | $0.001 |

100 votes cost $0.201 on the free plan; 1,000 MEP vote rows cost $0.201. **Error rows, "no results" rows and rows skipped by only-new mode are free.** Use `maxResults` or the maximum cost per run to cap spending.

### FAQ

**Where does the data come from?** From the official European Parliament Open Data Portal API (`data.europarl.europa.eu`), licensed CC BY 4.0. Please credit "European Parliament" when you publish results.

**Which votes are included?** By default all **roll-call votes** (the votes where names are published). Votes by show of hands only have an outcome; add them with `includeHandVotes`. Use `voteKinds: ["main"]` for the decisive votes (text as a whole, Commission proposal, provisional agreement, resolution).

**How fast are new votes available?** Parliament usually publishes roll-call results on the day of the vote or the day after. Plenary sessions happen about 12 times a year (4 days each in Strasbourg, plus shorter Brussels sessions), so a weekly schedule with `onlyNew` is enough.

**Is the political group the one at the time of the vote?** The group and country come from the Parliament's current MEP directory. For the current 10th term (since July 2024) this is almost always the group at the time of the vote; MEPs who switched group are counted in their current group, and MEPs who left Parliament show as `Unknown`. Totals (`votesFor`, `votesAgainst`, `votesAbstention`) are always the official numbers.

**What does NO_VOTE_RECORDED mean?** The tracked MEP is not in the list of voters for that roll call (absent, did not vote, or not an MEP at that time). The President of Parliament normally does not vote.

**How far back can I go?** To July 2019 (9th term). One plenary day takes about 4–5 seconds to fetch (the API asks for a 2-second pause between requests), so the default 220-second time budget covers about 45 plenary days – roughly a year of sessions, newest first. Raise `maxRunSeconds` (and the run timeout) for longer periods; rows found before the budget runs out are always saved.

### Related actors by benelux-signals

- [EU & Dutch News Monitor](https://apify.com/benelux-signals/eu-news-rss-monitor) – keyword alerts across 80+ Dutch, Belgian and EU news and official RSS feeds (European Parliament, Commission, EDPB).
- [EU Tender Radar](https://apify.com/benelux-signals/eu-tender-radar) – TED + TenderNed public tenders with keyword/CPV filters and only-new alerts.
- [EU Funding & Grants Calls Finder](https://apify.com/benelux-signals/eu-funding-grants-calls) – open Horizon Europe, LIFE, Digital Europe and cascade funding calls.
- [PDF & Image to Text OCR](https://apify.com/benelux-signals/pdf-image-to-text-ocr) – turn reports and adopted texts (PDF) into text for RAG and AI agents.

# Actor input Schema

## `keywords` (type: `array`):

Only votes whose agenda item, report, amendment label or document reference mention one of these words (case- and accent-insensitive, whole words; end with \* for a prefix, e.g. "climat\*"). Always searched in English plus your output language. Leave empty for all votes.

## `keywordMatch` (type: `string`):

Whether a vote must mention any or all of the keywords.

## `excludeKeywords` (type: `array`):

Skip votes that mention any of these words.

## `lastDays` (type: `integer`):

Look back this many days when no start date is set. Parliament holds plenary sessions about 12 times a year (4 days each), so 30–45 days usually covers 1–2 sessions.

## `dateFrom` (type: `string`):

Start date (YYYY-MM-DD) or a relative period like "90 days". Overrides 'Last N days'. Data starts in July 2019 (9th term). Group/country breakdowns are most accurate for the current 10th term (since 16 July 2024).

## `dateTo` (type: `string`):

End date (YYYY-MM-DD) or relative period. Default: today.

## `voteKinds` (type: `array`):

Which kinds of votes to include. Choose only 'main' to get one decisive vote per file. Empty = all.

## `outcome` (type: `string`):

Filter by result.

## `meps` (type: `array`):

Optional MEP names (e.g. "Roberta Metsola") or numeric MEP ids from europarl.europa.eu/meps. In 'Votes' mode each vote gets a mepPositions list with how these MEPs voted; in 'MEP votes' mode you get one row per MEP per vote.

## `outputMode` (type: `string`):

'Votes' is best for monitoring and analysis; 'MEP votes' gives individual voting records (cheaper per row). Combine 'MEP votes' with MEPs, groups or countries to keep it small (~650 rows per vote otherwise).

## `groups` (type: `array`):

Only MEP rows for these political groups, e.g. PPE, S\&D, Renew, Verts/ALE, ECR, PfE, The Left, ESN, NI.

## `countries` (type: `array`):

Only MEP rows for these countries (ISO-2 codes, e.g. NL, BE, DE, FR).

## `includeGroupBreakdown` (type: `boolean`):

Add for/against/abstain counts per political group to each vote.

## `includeCountryBreakdown` (type: `boolean`):

Add for/against/abstain counts per member state to each vote.

## `includeVoterLists` (type: `boolean`):

Add the names of all MEPs who voted for, against and abstained to each vote (large rows).

## `includeHandVotes` (type: `boolean`):

Also include votes by show of hands / electronic votes without roll call. These only have an outcome (adopted/rejected), no counts or names.

## `language` (type: `string`):

Language for titles and labels (falls back to English).

## `onlyNew` (type: `boolean`):

Skip votes (or MEP vote rows) delivered in earlier runs with the same state key. Use with a schedule for alerts; skipped rows are free.

## `stateKey` (type: `string`):

Name for the only-new memory, so different schedules don't share it.

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

Maximum rows to save (newest first).

## `maxRunSeconds` (type: `integer`):

Stop scanning older sittings after this many seconds (the API asks for 2 s between requests; one sitting day takes ~4–8 s). 0 = no limit.

## Actor input object example

```json
{
  "keywords": [],
  "keywordMatch": "any",
  "excludeKeywords": [],
  "lastDays": 60,
  "voteKinds": [
    "main"
  ],
  "outcome": "any",
  "meps": [],
  "outputMode": "votes",
  "groups": [],
  "countries": [],
  "includeGroupBreakdown": true,
  "includeCountryBreakdown": false,
  "includeVoterLists": false,
  "includeHandVotes": false,
  "language": "en",
  "onlyNew": false,
  "stateKey": "default",
  "maxResults": 50,
  "maxRunSeconds": 220
}
```

# Actor output Schema

## `overview` (type: `string`):

Votes table view.

## `mepVotes` (type: `string`):

MEP votes view (MEP votes mode).

## `runSummary` (type: `string`):

JSON summary under RUN_SUMMARY.

# 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 = {
    "lastDays": 60,
    "voteKinds": [
        "main"
    ],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("benelux-signals/european-parliament-votes").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 = {
    "lastDays": 60,
    "voteKinds": ["main"],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("benelux-signals/european-parliament-votes").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 '{
  "lastDays": 60,
  "voteKinds": [
    "main"
  ],
  "maxResults": 50
}' |
apify call benelux-signals/european-parliament-votes --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,benelux-signals/european-parliament-votes"
        }
    }
}
```

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/fP3dQ1C1aN1J1TOGw/builds/5f1QuOJv69zyTx8SN/openapi.json
