# EPO Publication Evidence MCP Server (`nexgenwatch/epo-publication-evidence-mcp`) Actor

Retrieve official European patent publications by number or publication day from the EPO publication server, with the INID-coded front page parsed into fields, inside the source's stated fair-use limits.

- **URL**: https://apify.com/nexgenwatch/epo-publication-evidence-mcp.md
- **Developed by:** [NexGen Watch](https://apify.com/nexgenwatch) (community)
- **Categories:** Agents, Business
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 tool calls

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## EPO Publication Evidence MCP Server

Retrieve **official European patent publications** — by publication day, or by publication
number — from the EPO publication server, live, inside the source's stated fair-use limits.

Built for patent research.

### Fair use is enforced in code, not promised in a README

The EPO publishes a **10 GB per 7 days per IP** fair-use allowance and links it from its own
`robots.txt`. This server **counts every byte** over a rolling 7-day window and **refuses**
a read that would cross a self-imposed ceiling of **1 GB — a tenth of the charter** — kept
deliberately small because this IP is shared with our EPO watch products.

A refusal shows its arithmetic, **fetches nothing, and charges nothing.** Every answer
reports how much of the budget is spent and how much remains.

The arithmetic that makes this comfortable:

```
one publication day   ~506 KB in ONE request, covering every publication that week
one front page        ~13 KB
```

The kind code lives **inside** the publication id, so classifying a whole day of 6,241
publications costs no extra reads at all. This server never fetches a document it was not
asked for.

### Three things this server gets right that a naive read gets wrong

Measured live on 2026-07-30.

#### 1. A bare patent number does not resolve — it is an HTTP 500

```
/patents/EP4780196NWA1/document.html  ->  200, 13,292 B
/patents/EP4780196/document.html      ->  500
/patents/EP4780196A1/document.html    ->  500
/patents/4780196/document.html        ->  500
```

The middle token (`NW`, `W1`) is not derivable from the number — it is only discoverable
from a publication-day index. So if you hold a bare number, give it **together with the
publication day** and this server resolves the id for you. If more than one publication
carries that number on that day, you get the **candidates**, never a guess.

#### 2. The middle token is not always letters — and the obvious fix is worse

Corrections arrive as `EP4395092W1A8` — a **digit** in the middle token. On 2026-07-29,
**39 of 6,241** ids carried one, and they are exactly the A8/B8/B9 correction slice. A
parser written for `[A-Z]{2}` drops all 39 while appearing to work.

**But loosening it to `[A-Z0-9]{2}` is wrong in the more dangerous direction** — it makes
`EP4780196A1` match as *number 47801, token 96, kind A1*, accepting an id the source rejects
**and decomposing it into the wrong patent number**. Measured over **12,008 ids across two
weeks**, the token alphabet is `NW` (11,922), `W1` (85), `W2` (1) — always letter-first. The
pattern used here is `[A-Z][A-Z0-9]`, and any id that still fails to parse is **counted and
reported**, never silently skipped.

#### 3. There is no cheap metadata endpoint

`/bibliographic-data` and `/document.pdf` both return **HTTP 500**. Only `document.html`
serves — and it is parsed here into **INID-coded fields** (application number, filing date,
IPC and CPC classes, PCT numbers, designated states) rather than handed back as a blob.

### Tools

| tool | what it answers |
|---|---|
| `list_publication_days` | The EPO's weekly publication days, newest first — the archive runs back to 1978-12-20 (2,424 weeks) |
| `get_publications_for_day` | Every EP publication issued on one day, filterable by kind code or number prefix, with kind-code counts |
| `get_publication` | One publication's INID-coded front page — by full id, or by number plus the day it published |
| `explain_limits` | The fair-use budget, the three traps above, and the kind-code table. Read before acting. |

### Scope

**EP publications only**, from the EPO publication server. There is **no full-text search on
this source** — this is retrieval by day or by number, not a patent search engine. National
patents, legal status and register events are outside it.

`robots.txt` on the publication server is `User-agent: *` with an **empty `Disallow`** —
everything is permitted — followed by a pointer to the EPO terms of use and fair-use
charter. That charter is why the budget above exists. Every call is additionally paced
through one strict-pacing bucket at **2 requests/second**.

This server retrieves what the EPO published. It does **not** assess novelty, validity,
freedom to operate or infringement, and it is not legal advice.

### Pricing

| Event | Price |
|---|---|
| Server start (`apify-actor-start`) | $0.05, charged once per server run by the platform |
| Tool call (`mcp-tool-call`) | **$0.05 flat per completed tool call** |

No other events. Memory is pinned to 1024 MB so the start fee is charged **once** — on this
platform the start event bills once per gigabyte.

**Errors and notices are not charged.** A malformed publication id, a malformed publication
day, an unknown kind code, an EPO read failure — **and a fair-use refusal** — all return
without billing. If this server declines to spend more of a shared allowance, it fetched
nothing and it bills nothing.

**A sourced "nothing published under that number on that day" IS charged**, and so is a day
whose filter matches nothing — those are the answers to the questions asked.

If a tool call cannot be billed correctly, **the call fails** rather than serving free.

# Actor input Schema

## `note` (type: `string`):

This Actor runs as an MCP server in Standby mode. Connect an MCP client to the server URL with path /mcp; there is no batch input to fill in.

## Actor input object example

```json
{
  "note": "standby"
}
```

# Actor output Schema

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

No description

# 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 = {
    "note": "standby"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgenwatch/epo-publication-evidence-mcp").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 = { "note": "standby" }

# Run the Actor and wait for it to finish
run = client.actor("nexgenwatch/epo-publication-evidence-mcp").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 '{
  "note": "standby"
}' |
apify call nexgenwatch/epo-publication-evidence-mcp --silent --output-dataset

```

## MCP server setup

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

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/HprRQT52JhcF4287C/builds/Y8DcDi7oiHv9KAdbs/openapi.json