# Espacenet Patents Scraper: EPO OPS API for 130M+ Patents (`dltik/espacenet-patents-scraper`) Actor

Search 130M+ patents from the official EPO Espacenet (OPS API): bibliographic data, abstracts, applicants, inventors, IPC/CPC classifications, full family graph, legal status, citations. EP, WO, US, JP, CN, DE, FR, GB. For IP lawyers, R\&D, M\&A diligence. $15/1K.

- **URL**: https://apify.com/dltik/espacenet-patents-scraper.md
- **Developed by:** [Walid](https://apify.com/dltik) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00005 / actor start

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

## Espacenet Patents Scraper — EPO OPS API for 130M+ Patents

**Espacenet Patents Scraper** lets you **search and extract 130M+ patents** from the **official EPO Espacenet** database via the European Patent Office Open Patent Services (OPS) API. Bibliographic data, abstracts, applicants, inventors, IPC/CPC classifications, full family graph, priority claims, citations, and legal status — for EP, WO, US, JP, CN, DE, FR, GB and 90+ jurisdictions.

> **Built on the official EPO OPS v3.2 API.** Stable, authoritative, no Cloudflare scraping. Free OPS tier (4M req/month) supplied by the user.

> ⭐ **Found this useful?** Click the **Bookmark** button at the top of [this page](https://apify.com/dltik/espacenet-patents-scraper) — it helps the scraper stay visible on the Apify Store. Takes 1 click. No signup beyond your existing Apify account.

***

### What can Espacenet Patents Scraper do?

- 🔬 **Search 130M+ patents** — by CQL query (title, abstract, full-text)
- 🏢 **Filter by applicant / assignee** — find every patent owned by a company (Apple, Samsung, BASF, Anthropic)
- 👨‍🔬 **Filter by inventor** — track an inventor's portfolio across jurisdictions
- 🏷️ **Filter by IPC / CPC class** — taxonomy-driven search (G06N3/08 = neural networks, A61K = pharma)
- 🌍 **Patent family expansion** — every sibling publication in EP / WO / US / JP / CN / DE / FR / GB
- 📚 **Lookup by publication number** — batch resolve EP / WO / US / JP IDs to full biblio
- 📄 **Abstract + full-text (EP / WO)** — get the abstract automatically, full description on demand
- 🆔 **Espacenet URLs** — direct deep-links to every record on worldwide.espacenet.com
- ⚡ **Free OPS tier** — 4,000,000 requests/month per client\_id, registered at developers.epo.org

***

### What data can you extract from each patent?

| Field | Description |
|-------|-------------|
| `publication_number` | EPODOC publication number (e.g. `EP3000000A1`, `WO2020123456`) |
| `publication_date` | Publication date (YYYY-MM-DD) |
| `application_number` | Application reference (e.g. `EP20150123456`) |
| `application_date` | Application filing date |
| `title` | Invention title (English when available) |
| `abstract` | Patent abstract (English when available) |
| `applicants` | Companies / assignees who hold the patent |
| `inventors` | Named inventors |
| `ipc_classifications` | International Patent Classification codes (e.g. `H04L9/32`) |
| `cpc_classifications` | Cooperative Patent Classification codes (more granular than IPC) |
| `priority_claims` | Earliest priority documents + dates (priority chain) |
| `family_id` | DOCDB family ID — groups equivalent patents across jurisdictions |
| `family_members` | Sibling publications (EP + US + JP + CN…) when `includeFamilyGraph=true` |
| `country_code` | Publication country (2-letter ISO) |
| `kind_code` | Document kind (A1, A2, B1, B2…) |
| `espacenet_url` | Deep link to the record on worldwide.espacenet.com |
| `language` | Title / abstract language |
| `scraped_at` | UTC timestamp of extraction |

***

### How to use Espacenet Patents Scraper

1. **[Register a free EPO OPS account](https://developers.epo.org/user/register)** — takes 2 minutes, no credit card. You get 4,000,000 requests/month free.
2. **Create an app** in the EPO portal → copy your **Consumer Key** + **Consumer Secret**.
3. **Open [Espacenet Patents Scraper](https://apify.com/dltik/espacenet-patents-scraper)** on Apify Store.
4. **Paste your OPS keys** into `epoClientId` + `epoClientSecret` (or set them as actor env vars).
5. **Pick a mode**: `search` (CQL query), `lookup` (publication numbers), or `family` (family graph).
6. **Click Start** — patents appear within seconds. Download as JSON, CSV, or Excel.

***

### How much does it cost to scrape patents?

**$0.015 per patent record** ($15 per 1,000 patents) — mid-range B2B pricing for IP-lawyer-grade data.

| Run size | Patents | Apify cost | Time |
|----------|---------|------------|------|
| Quick test | 10 | ~$0.15 | ~15s |
| Standard | 100 | ~$1.50 | ~1min |
| Deep dive | 500 | ~$7.50 | ~5min |
| Massive | 2,000 | ~$30 | ~20min |

Plus a flat $0.00005 per actor start. The EPO OPS API itself is **free** at the 4M req/month tier — you supply the credentials.

***

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `mode` | string | ❌ | `search` | `search`, `lookup`, or `family` |
| `query` | string | ❌ | — | CQL query (e.g. `ti=widget AND in=Smith`) |
| `publicationNumbers` | array | ❌ | `[]` | EPODOC numbers for lookup / family modes |
| `applicant` | string | ❌ | — | Filter by company name |
| `inventor` | string | ❌ | — | Filter by inventor last name |
| `ipcClass` | string | ❌ | — | IPC code (e.g. `H04L`) |
| `cpcClass` | string | ❌ | — | CPC code (e.g. `G06N3/08`) |
| `publicationDateFrom` | string | ❌ | — | YYYYMMDD lower bound |
| `publicationDateTo` | string | ❌ | — | YYYYMMDD upper bound |
| `country` | string | ❌ | — | 2-letter publication country |
| `includeFamilyGraph` | boolean | ❌ | `false` | Fetch family members per result |
| `includeFullText` | boolean | ❌ | `false` | EP / WO full description text |
| `maxResults` | integer | ❌ | `25` | Max records (1–2000) |
| `epoClientId` | string | ✅\* | — | OPS consumer key |
| `epoClientSecret` | string | ✅\* | — | OPS consumer secret |
| `proxyConfig` | object | ❌ | none | Apify proxy (rarely needed) |

\*Either the input fields or the `EPO_CLIENT_ID` / `EPO_CLIENT_SECRET` env vars are required.

***

### Output example

```json
{
  "publication_number": "EP3000000A1",
  "publication_date": "2016-03-30",
  "application_number": "EP20140187456",
  "application_date": "2014-10-02",
  "title": "Method and apparatus for distributed authentication",
  "abstract": "A distributed authentication system uses cryptographic tokens to enable secure session management across heterogeneous networks…",
  "applicants": ["EXAMPLE TECH GMBH", "PARTNER CORP"],
  "inventors": ["MULLER Hans", "TANAKA Yuki"],
  "ipc_classifications": ["H04L9/32", "G06F21/31"],
  "cpc_classifications": ["H04L9/3263", "G06F21/335"],
  "priority_claims": [
    {"number": "EP20140187456", "date": "2014-10-02"}
  ],
  "family_id": "54321098",
  "family_members": [
    {"publication_number": "US2016099876A1", "country": "US", "date": "2016-04-07"},
    {"publication_number": "JP2016072123A",  "country": "JP", "date": "2016-05-09"},
    {"publication_number": "CN105450123A",   "country": "CN", "date": "2016-03-30"}
  ],
  "country_code": "EP",
  "kind_code": "A1",
  "espacenet_url": "https://worldwide.espacenet.com/patent/search/publication/EP3000000A1",
  "language": "en",
  "scraped_at": "2026-06-12T08:30:00Z"
}
```

***

### Use cases

- **IP-lawyer prior-art search** — find every relevant patent across EP / WO / US / JP for a freedom-to-operate study, with full family graph in one run.
- **M\&A diligence** — audit a target company's entire patent portfolio by `applicant`, including legal status and citation count.
- **Competitor R\&D monitoring** — track quarterly filings by `cpc=G06N3/08` (neural networks) plus `applicant=OpenAI` for a near-live feed of AI patent activity.
- **Pharma / biotech mining** — query `cpc=A61K` (medicinal preparations) and filter by date range to surface new drug-formulation patents.
- **Academic prior-art** — build a CSV of patents in your research field for systematic literature reviews, then enrich with abstracts and IPC tags.

***

### Use Espacenet Patents Scraper via API

**Python:**

```python
import requests

run = requests.post(
    "https://api.apify.com/v2/acts/dltik~espacenet-patents-scraper/runs",
    headers={"Authorization": "Bearer YOUR_APIFY_TOKEN"},
    json={
        "mode": "search",
        "query": "machine learning",
        "applicant": "Anthropic",
        "publicationDateFrom": "20230101",
        "maxResults": 100,
        "includeFamilyGraph": True,
        "epoClientId": "YOUR_EPO_CONSUMER_KEY",
        "epoClientSecret": "YOUR_EPO_CONSUMER_SECRET"
    }
).json()

print(f"Run started: {run['data']['id']}")
```

**curl:**

```bash
curl -X POST "https://api.apify.com/v2/acts/dltik~espacenet-patents-scraper/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "lookup",
    "publicationNumbers": ["EP3000000A1", "WO2020123456"],
    "epoClientId": "YOUR_EPO_CONSUMER_KEY",
    "epoClientSecret": "YOUR_EPO_CONSUMER_SECRET"
  }'
```

***

### FAQ

**Do I need a paid EPO OPS subscription?**
No. The EPO offers a free tier of **4,000,000 requests/month per client\_id** — more than enough for most workflows. Register at https://developers.epo.org/user/register and create an app to get your Consumer Key + Secret.

**Why do I need to supply my own OPS credentials?**
The OPS quota is per-client\_id. If we used a shared key, every user would compete for the same 4M monthly budget. With your own key, your runs are isolated and free up to 4M req/mo — and we never see your patent search history.

**What's the difference between IPC and CPC?**
**IPC** (International Patent Classification) is the WIPO standard — coarser, ~70K codes. **CPC** (Cooperative Patent Classification) is a joint EPO + USPTO extension — finer, ~250K codes, used by EP and US examiners. We return both when available.

**Why is `full_text` only for EP / WO patents?**
The EPO OPS API only exposes full description + claims text for EP (European Patent Office) and WO (PCT / WIPO) publications. For US / JP / CN / etc., you get biblio + abstract via OPS — for full text, you'd need USPTO PEDS or J-PlatPat (different actors).

**What's a patent family?**
A patent family is the set of publications worldwide that share the same priority claim — i.e. the same invention filed in multiple jurisdictions. Set `includeFamilyGraph=true` to get every sibling publication in one record, which is essential for global FTO and licensing.

**I'm hitting OPS 403 "Fair Use" errors.**
You've exhausted your monthly 4M-req quota on the free tier, or you're hitting the per-minute throttle (~30 req/min). Wait, or upgrade your OPS plan at developers.epo.org. The actor surfaces this as a warning record, not a crash.

**I need help or a custom solution.**
Open an issue on the [Issues tab](https://apify.com/dltik/espacenet-patents-scraper/issues) or contact us through Apify.

***

### Connect with Make, Zapier & n8n

This actor integrates with any automation platform via the Apify API.

#### Make (Integromat)

1. Add an **Apify module** in your Make scenario
2. Select **Run Actor** and choose this actor
3. Configure the input (paste your JSON)
4. Add a **Get Dataset Items** module to retrieve results
5. Connect to Google Sheets, Airtable, Slack, or any other app

#### Zapier

1. Use the **Apify integration** on Zapier
2. Set trigger: **Actor Run Finished**
3. Action: **Get Dataset Items**
4. Send results to your CRM, IP-management tool, or spreadsheet

#### n8n

1. Add an **HTTP Request** node to call the Apify API
2. POST to `https://api.apify.com/v2/acts/dltik~espacenet-patents-scraper/runs`
3. Wait for completion, then fetch dataset items
4. Route results to any n8n node

#### Webhooks

```python
run = client.actor("dltik/espacenet-patents-scraper").call(
    run_input={...},
    webhooks=[{
        "eventTypes": ["ACTOR.RUN.SUCCEEDED"],
        "requestUrl": "https://your-webhook-url.com"
    }]
)
```

***

⭐ **Found this Espacenet Patents Scraper useful? Bookmark it** — Apify ranks actors by bookmarks, so it's the strongest single signal for Store visibility. One click = directly helps this actor stay surfaced.

### Other scrapers by dltik

| Actor | What it does | Price |
|-------|--------------|-------|
| [EUR-Lex Scraper](https://apify.com/dltik/eur-lex-scraper) | Search EU laws, regulations, directives (CELEX) | $8/1K |
| [TED Europa Scraper](https://apify.com/dltik/ted-europa-scraper) | EU public-procurement tenders (TED) | $5/1K |
| [Pappers / Sirene Scraper](https://apify.com/dltik/pappers-sirene-scraper) | 26M French companies (SIREN/SIRET) | $5/1K |
| [BODACC FR Scraper](https://apify.com/dltik/bodacc-fr-scraper) | 4.5M French court announcements | $2/1K |
| [SEC Edgar MCP Server](https://apify.com/dltik/mcp-server-sec-edgar) | US public-company filings for AI agents | $10/1K |

# Actor input Schema

## `mode` (type: `string`):

search = CQL keyword/applicant/inventor search; lookup = fetch one or more specific publication numbers; family = expand patent family for a publication number.

## `query` (type: `string`):

OPS CQL query. Examples: 'ti=widget AND in=Smith' (title + inventor), 'pa=Apple' (applicant), 'cpc=H04L9/32' (CPC class), 'pn=EP3000000' (publication number). See https://worldwide.espacenet.com for CQL syntax.

## `publicationNumbers` (type: `array`):

List of patent publication numbers (EPODOC format). Examples: \['EP3000000A1', 'WO2020123456', 'US10000000B2']. Use with mode=lookup or mode=family.

## `applicant` (type: `string`):

Filter by applicant / assignee name (company). Combined with query if both provided. Example: 'Samsung', 'IBM', 'BASF'.

## `inventor` (type: `string`):

Filter by inventor last name or full name. Example: 'Musk', 'Tanaka'.

## `ipcClass` (type: `string`):

IPC classification code. Example: 'H04L' (digital data transmission), 'A61K' (medicinal preparations), 'G06N' (computing).

## `cpcClass` (type: `string`):

CPC (Cooperative Patent Classification) code. Example: 'H04L9/32' (authentication), 'G06N3/08' (neural networks).

## `publicationDateFrom` (type: `string`):

Lower bound of publication date in YYYYMMDD format (e.g. '20200101').

## `publicationDateTo` (type: `string`):

Upper bound of publication date in YYYYMMDD format (e.g. '20251231').

## `country` (type: `string`):

Filter by publication country (2-letter ISO). Example: 'EP', 'WO', 'US', 'JP', 'CN', 'DE', 'FR', 'GB'.

## `includeFamilyGraph` (type: `boolean`):

Fetch the full patent family graph (sibling publications in other jurisdictions) for each result. Adds 1 extra OPS request per record. Useful for global prior-art search.

## `includeFullText` (type: `boolean`):

Fetch the full description + claims text. Only available for EP and WO publications via OPS; for US/JP/CN, only abstract is returned.

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

Maximum number of patent records to return. OPS caps each search at 2,000 results; we paginate in batches of 100.

## `epoClientId` (type: `string`):

Your EPO OPS consumer key. Register free at https://developers.epo.org (4M req/month free tier). If empty, the actor will look for EPO\_CLIENT\_ID environment variable.

## `epoClientSecret` (type: `string`):

Your EPO OPS consumer secret (matches the consumer key). If empty, the actor will look for EPO\_CLIENT\_SECRET environment variable.

## `proxyConfig` (type: `object`):

Optional Apify proxy. The EPO OPS API is open to all IPs once authenticated — proxy rarely needed unless your client\_id is rate-limited.

## Actor input object example

```json
{
  "mode": "search",
  "publicationNumbers": [],
  "includeFamilyGraph": false,
  "includeFullText": false,
  "maxResults": 25,
  "proxyConfig": {
    "useApifyProxy": false
  }
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("dltik/espacenet-patents-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("dltik/espacenet-patents-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 '{}' |
apify call dltik/espacenet-patents-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/E2wtkEgT5cr3ACEUf/builds/zrNSeHAmub2soglOC/openapi.json