🧰 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.

This is a standby MCP server: it stays warm on Apify and answers tool calls from any MCP client (Claude Desktop, Cursor, an agent framework) at https://nexgenwatch--epo-publication-evidence-mcp.apify.actor/mcp. Billing is pay-per-event: $0.05 when the server starts, then $0.05 per tool call (mcp-tool-call). Source: data.epo.org.

No login, no source API key and no CAPTCHA solving are involved: the source is read logged-out.

📊 Sample Output

A standby server answers tool calls rather than writing a dataset, so the sample is the server's own live health answer (GET https://nexgenwatch--epo-publication-evidence-mcp.apify.actor/, HTTP 200, read on 2026-09-17) followed by its tool table:

{
  "server": "epo-publication-evidence",
  "billing_gate": true,
  "declared_events": [
    "apify-actor-start",
    "mcp-tool-call"
  ],
  "scope": "European patent publications from the EPO publication server -- the weekly Bulletin index back to 1978-12-20, and the INID-coded front page of any publication. EP publications only. There is no full-text search on this source, and national patents, legal status and register events are outside it.",
  "rate_limit_per_sec": 2.0,
  "rate_waits": 0,
  "fair_use": {
    "spent_bytes_last_7_days": 0,
    "ceiling_bytes": 1073741824,
    "remaining_bytes": 1073741824,
    "epo_published_allowance_bytes_per_7_days": 10737418240,
    "why_the_ceiling_is_lower": "a tenth of the EPO charter, because this IP is shared with the fleet's EPO watch cells"
  },
  "ready": true
}

Tool	Arguments	What it returns
list_publication_days	limit: int = 25	The EPO's weekly publication days, newest first. Use one as the day argument elsewhere. The archive runs back to 1978-12-20.
get_publications_for_day	`day: str, kind_codes: list	None = None, number_prefix: str
get_publication	`publication_id: str	None = None, publication_number: str
explain_limits	``	What this server can and cannot do, the fair-use budget it enforces, and the four measured facts about this source. Read this before acting on any answer.

✅ What you get

4 tools, each returning a JSON object built only from what the source answered, with a scope and note field stating what the source does and does not cover. A lookup the source answers with 'not found' is a sourced answer (charged); malformed input or a source failure returns a notice that is NOT charged; nothing is ever fabricated.

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.

⚙️ Sample inputs

1. Connect an MCP client (Claude Desktop / Cursor style config; your Apify API token goes in the header):

{
  "mcpServers": {
    "epo-publication-evidence-mcp": {
      "url": "https://nexgenwatch--epo-publication-evidence-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_APIFY_TOKEN>"
      }
    }
  }
}

2. One tool call over JSON-RPC (what the client sends to /mcp; each call is one mcp-tool-call event):

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "list_publication_days",
    "arguments": {
      "limit": 25
    }
  }
}

3. Health check from a shell (free — no tool call is charged):

$curl -H "Authorization: Bearer $APIFY_TOKEN" https://nexgenwatch--epo-publication-evidence-mcp.apify.actor/

🧾 JSON sample record

The live health record above is the server's own answer; a tool result carries the fields listed in the tool table plus scope and note.

🔧 How it works

Source. data.epo.org — endpoints: https://data.epo.org/publication-server/rest/v1.2. Public, logged-out reads only.

Standby. Apify keeps one server process warm; each MCP session is served by that process and idle servers are stopped by the platform. Nothing is cached between calls except what the source itself caches.

Charging. Every tool call charges one mcp-tool-call at $0.05 through Apify's pay-per-event billing before the answer is returned; the declared events are asserted against the live pricing at startup (billing_gate in the health answer).

What is not done. No login, no CAPTCHA bypass, no private data, no scraping of pages the source does not publish to any visitor.

💰 Pricing example

Event	Free	Bronze	Silver	Gold
Actor Start (apify-actor-start)	$0.05	$0.05	$0.05	$0.05
Tool call (mcp-tool-call)	$0.05	$0.05	$0.05	$0.05

• 10 tool calls in one session: $0.05 start + 10 × $0.05 = $0.55
• 100 tool calls in one session: $0.05 start + 100 × $0.05 = $5.05
• 1000 tool calls in one session: $0.05 start + 1000 × $0.05 = $50.05

A health check or a connection that makes no tool call charges only the $0.05 start fee. A sourced 'not found' answer is a completed tool call and is charged; a notice for malformed input or a source failure is not charged (settle() charges only chargeable outcomes).

⚖️ Legal & ToS

The server reads public data published by data.epo.org to any visitor, identifies itself, and does not access accounts or private data. Use the answers in line with the source's terms and your local law; the intended use is B2B research and agent tooling.

❓ FAQ

Q: Do I need a source API key?
A: No. data.epo.org is read logged-out. You need only your Apify API token to connect to the server.

Q: Which MCP clients work?
A: Any client that speaks the MCP HTTP transport: Claude Desktop, Cursor, Windsurf, LangChain/LlamaIndex MCP adapters and Apify's own MCP client. Point it at the /mcp URL above.

Q: What happens when the source has no answer?
A: A sourced 'not found' (for example a 404 for an unknown identifier) comes back as an answer with scope and note explaining what was checked (where the server carries those fields), and is charged as a completed call; malformed input or a source outage returns a notice that is not charged. Nothing is invented.

Q: How is a call billed?
A: One mcp-tool-call event per tool call at $0.05, plus $0.05 when the server starts. Idle time is not billed to you.

Q: Is it rate limited?
A: The server paces requests to the source (RATE_PER_SEC=2.0) and answers calls in the order they arrive.

Q: Can I call it without an MCP client?
A: Yes — the /mcp endpoint is plain JSON-RPC over HTTP (sample input 2), and GET / is a free health check.

🆘 Troubleshooting

• 401 / 403 from the server → the Authorization header is missing or the token is wrong → use Bearer <your Apify API token>.
• 400 Missing session ID → the client hit /mcp without initialising an MCP session → let the MCP client connect (it performs the handshake); raw JSON-RPC needs the session header the initialise call returns.
• Tool returns a notice instead of data → the input was malformed or empty, or the source failed → the call was not charged; check the note/reason field, fix the input and call again.
• First call is slow → the standby server was cold and Apify started it → later calls in the same session are fast.

🔗 Related Actors

• Companies House Control MCP Server — Answer questions about UK companies from the Companies House public register: company profile, filing history, and who the register says controls the…
• Cross-Border Sanctions Resolution MCP Server — Resolve a party name against the US OFAC SDN, EU consolidated and UK OFSI sanctions lists in one MCP call, with the match basis and each list's as-of…
• Crossref Citation MCP Server — An MCP server over the official Crossref REST API (api.crossref.org) — scholarly work
• Eurostat Labor Stats MCP Server — An MCP server over the official Eurostat dissemination API (ec.europa.eu/eurostat) — EU
• FDIC Bank Diligence MCP Server — Answer questions about US banks from the FDIC's public data: institution details, structural history, current status, closures and failures - for vet…
• Federal Award Counterparty MCP Server — Answer questions about US federal award recipients from USAspending.gov: who won awards from an agency, one organisation's award history, and who tha…
• 🏢 About NexGenData — NexGen Watch is NexGenData's fleet of 256 public monitoring and lookup actors built on official sources, pay-per-result. Browse the catalog at apify.com/nexgenwatch.

⭐ Found this useful?

If this server answered a question your agent could not, a quick review on the Apify Store helps other teams find it. Feature request or a source that changed? Open it from the Issues tab — every one is read.