# EPO Patent Search & Monitor – European Patents, No API Key (`mabun/epo-patent-search`) Actor

Search new European patent applications and EP grants by title keyword, applicant or CPC class, using the EPO's official Linked Open EP Data. No API key, no login, no scraping. Monitor mode returns only new publications for weekly competitor or technology watches. $2 per 1,000.

- **URL**: https://apify.com/mabun/epo-patent-search.md
- **Developed by:** [Maximilian van Elst](https://apify.com/mabun) (community)
- **Categories:** Business, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 patent publication returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## EPO Patent Search & Monitor – European Patents, No API Key

**Search new European patent applications and granted EP patents by title keyword, applicant name or CPC class, and get clean JSON, CSV or Excel records.** Data comes from the European Patent Office's official **Linked Open EP Data** service (CC BY 4.0). **No EPO API key, no login, no proxy** – and the Actor never touches a browser.

Turn on **monitor mode** to get only publications you have not seen before – a ready-made weekly patent watch for a competitor, a technology or a CPC class.

### What does EPO Patent Search do?

- Searches **EP publications (A and B documents)** of the European Patent Bulletin, published every Wednesday
- Filters by **title keywords** (English, German and French titles), **applicant names**, **CPC class prefixes** (e.g. `H01M`, `G06N`, `Y02E`), **publication date window** and **document kind** (applications or grants)
- Returns structured records with publication number and kind, all three titles, applicants and their country, CPC, application number, filing and grant date, priorities, PCT number, simple family ID, and links to Espacenet and the European Patent Register
- **Monitor mode (`onlyNew`)** remembers what you already received
- **Privacy by design:** never returns **inventors or representatives (patent attorneys)**; applicant names can be switched off too

### Who is it for?

- **R\&D, innovation and IP teams** watching competitors or technology fields
- **Patent attorneys and IP consultants** running watches for several clients
- **Technology scouts, analysts and investors** looking for who files what in Europe
- **AI agent builders** who need a structured, citable patent feed

### Use cases: European patent monitoring

- 🔭 **Competitor patent watch.** Run with `applicants: ["Bosch"]` every Thursday and get the competitor's new EP filings and grants in Slack or a Google Sheet.
- ⚡ **Technology radar.** Track CPC `Y02E` (clean energy) or the keywords "solid-state battery" and "Festkörperbatterie" every week.
- 📈 **Grant tracking.** Use `publicationKinds: "grants"` to see which patents were granted, e.g. ahead of opposition deadlines (check those in the EP Register).
- 🤖 **AI summaries.** Feed new publications into an LLM that writes a weekly briefing.

### How to search European patents in 4 steps

1. Click **Start**. The prefilled input (title keywords "hydrogen" / "Wasserstoff", last 60 days, max 20) runs in seconds.
2. Set your keywords, applicant names and/or CPC prefixes. **At least one filter is required.**
3. For a weekly watch, set `onlyNew: true` and a `monitorId`, then add a **schedule** (e.g. every Thursday).
4. Export as JSON, CSV or Excel, or connect an integration.

### Input example

```json
{
  "keywords": ["battery", "Batterie"],
  "applicants": [],
  "cpcCodes": ["H01M"],
  "publishedWithinDays": 30,
  "publicationKinds": "all",
  "titleLanguage": "de",
  "includeApplicants": true,
  "maxResults": 100,
  "onlyNew": true,
  "monitorId": "battery-watch"
}
```

Filters of different types are combined with **AND**. Values within one filter are combined with **OR**.

| Field | Meaning |
|---|---|
| `keywords` | Words in the title of the invention (EN/DE/FR). Case-insensitive substring match, so `batter` finds "battery", and `hydrogen` also finds "hydrogensilane". |
| `applicants` | Substring of an applicant name, e.g. `Siemens` (matches Siemens AG, Siemens Energy, Siemens Healthineers …). |
| `cpcCodes` | CPC prefixes, e.g. `H01M`, `G06N3/08`, `Y02E`. Matches inventive and additional CPC symbols. |
| `publishedWithinDays` | Window ending today (1–366). Ignored if `dateFrom` is set. |
| `dateFrom` / `dateTo` | Explicit publication date range (YYYY-MM-DD), max 366 days. |
| `publicationKinds` | `all`, `applications` (A1/A2/A3) or `grants` (B1/B2/B3). |
| `titleLanguage` | Language for the `title` field (`en`, `de`, `fr`). |
| `includeApplicants` | Set to `false` to omit applicant names. |
| `maxResults` | Hard cap on returned and charged records (1–1000). |
| `onlyNew` + `monitorId` | Monitor mode: skip publications returned by earlier runs of the same monitor. |

### Output: European patent data fields

Real record from a test run on 22 Oct 2026 (`applicants: ["Siemens"]`, grants, last 60 days):

```json
{
  "publicationNumber": "EP3754550B1",
  "kind": "B1",
  "publicationType": "granted patent",
  "publicationDate": "2026-10-14",
  "title": "VERFAHREN ZUR BEREITSTELLUNG EINES AGGREGATALGORITHMUS ZUR VERARBEITUNG VON MEDIZINISCHEN DATEN …",
  "titleEn": "METHOD FOR PROVIDING AN AGGREGATE ALGORITHM FOR PROCESSING MEDICAL DATA AND METHOD FOR PROCESSING MEDICAL DATA",
  "applicants": [{ "name": "Siemens Healthineers AG", "country": "DE" }],
  "applicantNames": "Siemens Healthineers AG",
  "cpcInventive": ["G06F 18/24133", "G06V 10/776"],
  "applicationNumber": "EP19181607.3",
  "filingDate": "2019-06-21",
  "grantDate": "2026-10-14",
  "simpleFamilyId": "67001600",
  "procedureLanguage": "en",
  "espacenetUrl": "https://worldwide.espacenet.com/patent/search?q=pn%3DEP3754550B1",
  "registerUrl": "https://register.epo.org/application?number=EP19181607",
  "linkedDataUrl": "https://data.epo.org/linked-data/data/publication/EP/3754550/B1/-",
  "source": "EPO Linked Open EP Data (CC BY 4.0)"
}
```

Application example (A1, keyword "hydrogen"): `EP4820361A1`, "METHOD FOR PREPARING ULTRA-PURE ORGANOALKOXYHYDROGENSILANES", applicant Wacker Chemie AG (DE), filed 2024-11-06, priority `WO2023EP084593`, PCT `WO2024EP081354`.

Each run also writes a `RUN-SUMMARY` record to the key-value store. It lists matches per Bulletin date, the dates missing in the source, and the attribution text.

### How much does the EPO patent search cost?

Pay-per-event pricing. You pay per returned publication; platform compute is included.

| Event | Price |
|---|---|
| Patent publication returned | **$0.002** per record ($2 per 1,000) |

**No start fee and no EPO API key.** Empty runs and publications skipped in monitor mode cost nothing.

- Prefilled test run (max 20): **≤ $0.04**
- Weekly competitor watch with ~20 new publications: **~$0.04 per week**
- One-off export of 1,000 records: **$2**

### Patent search API: Python, JavaScript, cURL

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("mabun/epo-patent-search").call(run_input={
    "cpcCodes": ["H01M"], "keywords": ["battery"], "publishedWithinDays": 30,
    "onlyNew": True, "monitorId": "battery-watch"
})
for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(p["publicationNumber"], p["titleEn"], p["applicantNames"])
```

**JavaScript**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('mabun/epo-patent-search').call({ applicants: ['Siemens'], publicationKinds: 'grants' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/mabun~epo-patent-search/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["hydrogen"],"publishedWithinDays":60,"maxResults":20}'
```

### Use with AI agents (MCP)

Add the Actor as a patent tool to Claude, ChatGPT or Cursor via the Apify MCP server:
`https://mcp.apify.com?tools=mabun/epo-patent-search`
Example prompt: *"Which companies filed European patents on solid-state batteries in the last 60 days? Group them by applicant."*

### Integrations

- **Schedules** and **webhooks** through the Apify platform
- **Make, Zapier, n8n, Google Sheets, Slack, Airtable** through Apify integrations

### FAQ

**Do I need an EPO OPS account or API key?** No. The Actor uses the EPO's public Linked Open EP Data service, so you only need an Apify account.

**Where does the data come from?** From the EPO's official [Linked Open EP Data](https://data.epo.org/linked-data/) SPARQL endpoint, published under **CC BY 4.0**. Each record carries the attribution `source` field. If you republish the data, keep the attribution: "Contains data from the European Patent Office, EPO Linked Open EP Data, licensed under CC BY 4.0."

**Does it scrape Espacenet or Google Patents?** No. It uses only the EPO's open data service. The Espacenet and Register links let you open the full document in your browser.

**Does it include DE (DPMA), US or WO documents?** No. It covers EP publications only. Priorities and PCT numbers are included as references.

**Why are inventors not included?** Inventors are natural persons, and the Actor minimizes personal data. Applicants are usually companies. You can still switch them off.

**How does monitor mode work?** Publication numbers are stored per `monitorId` in a named key-value store in your own account.

### Limitations

- **EP documents only**, searched by **title** (no full-text, abstract or claims search)
- **CPC for fresh applications:** EPO Linked Open Data often has no CPC yet for newly published A1 applications. CPC searches mostly find grants and older applications, so combine CPC with keywords for recent filings. IPC is often empty.
- **Update lag and gaps:** the linked-data set is refreshed weekly and can lag the Bulletin. The Actor logs a warning for missing Bulletin dates and lists them in `RUN-SUMMARY.datesMissingInSource`.
- **Fair use:** the EPO describes the public SPARQL endpoint as a service for occasional use, not a production backend. The Actor therefore requires at least one filter, limits a run to 366 days and 1,000 results, queries one Bulletin date at a time with pauses, and retries politely. Bulk downloads are not supported.
- Legal status, oppositions and fees are not included; check the European Patent Register for these.

### Related Actors by the same developer

- [EU Tenders Monitor Germany & Austria (TED)](https://apify.com/mabun/ted-tenders-dach) – public tenders, same monitor mode
- [RSS Feed Monitor](https://apify.com/mabun/rss-feed-monitor) – new items from any feed with keyword alerts
- [PDF to Text & RAG Chunks](https://apify.com/mabun/pdf-text-extractor-rag) – turn research papers and other PDFs into text for LLMs

### Support

Need another field or filter? Open an issue on the **Issues** tab.

# Actor input Schema

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

Any of these words must appear in the title of the invention (English, German or French title; case-insensitive substring match, so 'batter' matches 'battery'). Use EN and DE terms, e.g. hydrogen, Wasserstoff.

## `applicants` (type: `array`):

Any of these strings must appear in an applicant name (case-insensitive substring), e.g. Siemens, Bosch, Fraunhofer.

## `cpcCodes` (type: `array`):

Cooperative Patent Classification prefixes, e.g. H01M (batteries), G06N (AI), Y02E (clean energy), A61K 31/ . Prefix match on inventive and additional CPC symbols.

## `publishedWithinDays` (type: `integer`):

Time window ending today. Ignored if dateFrom is set. EP documents are published every Wednesday.

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

Optional start of the publication date range. Max range 366 days per run.

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

Optional end of the publication date range (default: today).

## `publicationKinds` (type: `string`):

Filter by document kind.

## `titleLanguage` (type: `string`):

Language used for the 'title' field. All three titles are also returned separately.

## `includeApplicants` (type: `boolean`):

Applicants are usually companies but can be natural persons. Turn off to omit applicant names. Inventors and representatives are never returned.

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

Maximum number of publications returned (and charged) per run.

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

Remember returned publications and skip them in later runs with the same monitor ID. Combine with a schedule for a weekly patent watch.

## `monitorId` (type: `string`):

Separate memory per watch, e.g. 'competitor-bosch'.

## Actor input object example

```json
{
  "keywords": [
    "hydrogen",
    "Wasserstoff"
  ],
  "applicants": [],
  "cpcCodes": [],
  "publishedWithinDays": 60,
  "publicationKinds": "all",
  "titleLanguage": "en",
  "includeApplicants": true,
  "maxResults": 20,
  "onlyNew": false,
  "monitorId": "default"
}
```

# Actor output Schema

## `patents` (type: `string`):

EP publications (number, kind, dates, titles EN/DE/FR, applicants, CPC/IPC, priorities, 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 = {
    "keywords": [
        "hydrogen",
        "Wasserstoff"
    ],
    "applicants": [],
    "cpcCodes": [],
    "publishedWithinDays": 60,
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("mabun/epo-patent-search").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 = {
    "keywords": [
        "hydrogen",
        "Wasserstoff",
    ],
    "applicants": [],
    "cpcCodes": [],
    "publishedWithinDays": 60,
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("mabun/epo-patent-search").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 '{
  "keywords": [
    "hydrogen",
    "Wasserstoff"
  ],
  "applicants": [],
  "cpcCodes": [],
  "publishedWithinDays": 60,
  "maxResults": 20
}' |
apify call mabun/epo-patent-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mabun/epo-patent-search"
        }
    }
}
```

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/Sb07V9VpzE6dfs0As/builds/zSB4ScAnX6iU78oJI/openapi.json