# EU Regulatory Change Records — EUR-Lex Legal Acts (`nexgensignal/eu-regulatory-change-records`) Actor

Per-record EU legal acts (regulations, directives, decisions) from the official EUR-Lex/CELLAR endpoint. Act type, dates, institution, and amends/repeals links. Keyless, no personal data.

- **URL**: https://apify.com/nexgensignal/eu-regulatory-change-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 regulatory change 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/platform/actors/running/actors-in-store#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

## EU Regulatory Change Records — EUR-Lex Legal Acts

**Official source. No API key. Pay per record.**

This actor turns the **EU's own legal database** — the Publications Office CELLAR repository behind EUR-Lex — into clean, per-act records. Each run queries the official CELLAR SPARQL endpoint and delivers one row per EU legal act: the CELEX number, the act type (regulation, directive, decision), the document and entry-into-force dates, the issuing institution, and — crucially — the acts it **amends** or **repeals**. That last part is what makes this a *regulatory change* feed rather than a document dump: it captures how the EU rulebook is being rewritten, act by act.

### What this is, in one paragraph

Every EU legal act is published through CELLAR, the Publications Office's semantic repository, and exposed through a public SPARQL endpoint. This actor queries that endpoint for regulations, directives, and decisions in a date window, newest first, and flattens each into a single analysis-ready row: what it is, when it was adopted and takes effect, who issued it, and which earlier acts it amends or repeals (by CELEX). Values are verbatim. You are billed only for records actually delivered.

### Who buys this and for what job

- **Regulatory-affairs and compliance teams** tracking changes to EU law in their domain — and, through the amends/repeals links, seeing exactly which existing rules each change touches.
- **Legal-tech and RegTech products** ingesting a structured EU legislative-change feed to power alerts and dashboards.
- **Law firms and consultancies** monitoring new EU regulations and directives by type and date for clients.
- **Analysts and data engineers** who want a keyless, one-call feed of EU legal acts already reduced to document-level fields with relationships.

### Licence — EU reuse policy, commercial use permitted

EU legal acts in CELLAR are reused under the **EU reuse policy (Commission Decision 2011/833/EU)**, which permits free reuse — including commercial — with acknowledgement of source. Every record carries the required attribution: *"© European Union, https://eur-lex.europa.eu — reuse authorised with acknowledgement of source (Decision 2011/833/EU)."* One honest boundary travels on every record: only the Official Journal edition is authentic, so for legal reliance verify against EUR-Lex. These are metadata records for regulatory tracking, not legal advice.

### Document grain — no person data

EU legal acts are issued by institutions (the Council, the Commission, the Parliament), not individuals, so this feed is document and organization grain by nature. The actor emits the act, its dates, its institutional authors, and its relationships — never a natural person. As a structural safeguard, the title field is still scrubbed of any email or phone pattern before emit, and a person-key guard runs on every record; a live sweep over real CELLAR acts emits zero contact data.

### Pricing

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| `regulatory_change_record` | $0.05 | $0.045 | $0.04 | $0.0335 |

Delivered before charged. Blocked runs and empty results cost nothing.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `types` | string list | Regulation, Directive, Decision | Which act types to pull. |
| `since` | string (YYYY-MM-DD) | 90 days ago | Keep only acts with a document date on or after this date. |
| `maxRecords` | integer | 500 | Ceiling on records delivered and billed. |

The actor queries the CELLAR SPARQL endpoint newest-first and paginates its result window.

### Output

One JSON object per act. Example (values verbatim):

```json
{
  "record_id": "32026R1844",
  "celex": "32026R1844",
  "act_type": "Regulation",
  "title": "Council Regulation (EU) 2026/1844 on market surveillance",
  "document_date": "2026-08-06",
  "entry_into_force_date": "2026-08-26",
  "end_of_validity_date": null,
  "authors": ["Council of the European Union", "European Parliament"],
  "amends_celex": ["32019R1020", "32020R0740"],
  "repeals_celex": [],
  "source": "EU Publications Office (CELLAR / EUR-Lex)",
  "source_url": "https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32026R1844",
  "licence": "EU legal acts ... Commission Decision 2011/833/EU ... free reuse ... with acknowledgement ...",
  "attribution": "© European Union, https://eur-lex.europa.eu — reuse authorised with acknowledgement of source (Decision 2011/833/EU).",
  "observed_at": "2026-08-19T00:00:00Z"
}
```

An unbilled `RUN_RECEIPT` records the robots check, the types and date window, acts seen and delivered, and whether charged equals delivered.

### Field reference

Each record is a flat set of legislative-tracking fields. Identity: `record_id` / `celex` and `act_type`. Substance: `title` (the English title where CELLAR carries one). Timing: `document_date`, `entry_into_force_date`, and `end_of_validity_date`. Who issued it: `authors` — EU institutions, never a person. Change relationships: `amends_celex` and `repeals_celex`, each a list of CELEX numbers, so you can trace exactly which earlier acts a change affects. Provenance: `source`, `source_url` (a direct EUR-Lex link), `licence`, `attribution`, `disclaimer`, and `observed_at`.

### How a run works

A run first re-reads the source's robots policy from your runtime and confirms the SPARQL path is allowed (the Publications Office robots file carries `Allow: /` and does not disallow the `/webapi/rdf/sparql` endpoint). It then builds a single SPARQL query from your act types and date window, grouped so each act comes back as exactly one row — with its amends and repeals links concatenated per act rather than fanning out into duplicate rows. Acts are read newest-first, each flattened to one record and delivered **before** it is charged, so a blocked or empty run costs you nothing. The actor pages through the result window with `LIMIT`/`OFFSET`, de-duplicates by CELEX as a safety net, pauses briefly between pages, and stops as soon as your `maxRecords` ceiling is reached. The receipt's `charge_equals_delivered` flag confirms you were billed for exactly what you received.

### Cost guidance

One `regulatory_change_record` per delivered act: cost = acts delivered × your plan's per-record price. The CELLAR corpus holds well over a hundred thousand regulations alone, but this feed is scoped by date window, so a typical run — the last quarter of regulations, directives, and decisions — is a few hundred to a couple thousand acts. 1,000 acts is **$50** (Free) / **$33.50** (Gold).

### Honest limitations

- **Only the Official Journal edition is authentic.** For legal reliance, verify against EUR-Lex; this is the machine-readable metadata.
- **Document grain.** Full act text is not included — this is the act record plus its dates, authors, and amends/repeals links.
- **Titles are English where CELLAR carries an English expression;** some corrigenda and very recent items may lack one.
- **Point-in-time.** In-force status and validity dates change; re-run to refresh.

### Differentiation

Distinct from the sibling **federal-rulemaking-records** (US Federal Register): different jurisdiction (EU vs US), different source (CELLAR/EUR-Lex vs Federal Register), and a legislative-change grain with explicit amends/repeals links. It is also distinct from **eu-tender-bid-signals** (EU TED): tenders are procurement notices, not legal acts. The established EUR-Lex ecosystem — the incumbent legislative-tracking tools that regulatory teams already pay for — is the demand evidence this feed is built for; this actor is an independent, keyless, per-record source, not a copy of any of them.

### The NexGen Signal family

Part of the NexGen Signal family of official-source, pay-per-record products:

- [Federal Rulemaking Records — US Federal Register](https://apify.com/nexgensignal/federal-rulemaking-records)
- [World Bank Project Records — Development Pipeline](https://apify.com/nexgensignal/world-bank-project-records)
- [EU Tender Bid Signals — TED](https://apify.com/nexgensignal/eu-tender-bid-signals)
- [Grant Opportunity Records — US Grants.gov](https://apify.com/nexgensignal/grant-opportunity-records)
- [Organization Sanctions & LEI Risk](https://apify.com/nexgensignal/organization-sanctions-lei-risk)

*Source: EU Publications Office CELLAR repository (publications.europa.eu) via its public SPARQL endpoint. Reused under the EU reuse policy (Commission Decision 2011/833/EU) — free reuse with acknowledgement of source. Only the Official Journal edition is authentic. Reformatted to document-level records; values verbatim; no person data emitted.*

# Actor input Schema

## `types` (type: `array`):

Which EU legal act types to pull: Regulation, Directive, Decision.

## `since` (type: `string`):

Keep only acts with a document date on or after this date. Defaults to 90 days before the run.

## `maxRecords` (type: `integer`):

Maximum records delivered and billed. You are billed only for records delivered.

## Actor input object example

```json
{
  "types": [
    "Regulation",
    "Directive",
    "Decision"
  ],
  "maxRecords": 500
}
```

# Actor output Schema

## `results` (type: `string`):

The delivered EU legal act records.

# 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 = {
    "types": [
        "Regulation",
        "Directive",
        "Decision"
    ],
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/eu-regulatory-change-records").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 = {
    "types": [
        "Regulation",
        "Directive",
        "Decision",
    ],
    "maxRecords": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/eu-regulatory-change-records").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 '{
  "types": [
    "Regulation",
    "Directive",
    "Decision"
  ],
  "maxRecords": 500
}' |
apify call nexgensignal/eu-regulatory-change-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/eu-regulatory-change-records"
        }
    }
}

```

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/wLxh4V0tYO2hdLu72/builds/OlDaO9y4l89bvaprL/openapi.json