# WIPO PATENTSCOPE Patents Scraper (`automation-lab/wipo-patentscope-patent-search-records`) Actor

Search international WIPO patent publications and export normalized identifiers, bibliographic fields, classifications, abstracts, dates, and PATENTSCOPE links.

- **URL**: https://apify.com/automation-lab/wipo-patentscope-patent-search-records.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $40.88 / 1,000 item extracteds

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

## WIPO PATENTSCOPE Patents Scraper

Search **WIPO PATENTSCOPE patents** by technology, publication number, applicant, inventor, or publication date and export normalized international (WO) patent records. The Actor is built for prior-art review, patent-landscape research, and repeatable portfolio monitoring.

### What you get

Each dataset row includes:

- WO publication and PCT application identifiers
- title and abstract
- applicants and inventors
- IPC/CPC classification codes
- priority, filing, and publication dates
- a canonical WIPO PATENTSCOPE detail link

The Actor searches WIPO PATENTSCOPE directly, using a bounded JSF session and official PATENTSCOPE result/detail pages constrained to international WO publications. No WIPO account or third-party patent index is used.

### Input

| Field | Type | Description |
|---|---|---|
| `query` | string | Required keywords, title, or WO publication number |
| `applicant` | string | Optional applicant/assignee filter |
| `inventor` | string | Optional inventor filter |
| `publishedFrom` | date | Optional lower publication-date bound (`YYYY-MM-DD`) |
| `publishedTo` | date | Optional upper publication-date bound (`YYYY-MM-DD`) |
| `language` | string | Preferred title/abstract language; default `en` |
| `maxItems` | integer | Maximum records, from 1 to 1,000 |

Example prior-art search:

```json
{
  "query": "solid state battery",
  "language": "en",
  "maxItems": 25
}
```

Applicant-focused landscape:

```json
{
  "query": "hydrogen fuel cell",
  "applicant": "Toyota",
  "maxItems": 50
}
```

### Output example

```json
{
  "publicationNumber": "WO2026123589",
  "applicationNumber": "PCT/CN2025/095448",
  "title": "METHOD FOR MEASURING RELATIVE DENSITY OF SOLID-STATE BATTERY...",
  "applicants": ["CONTEMPORARY AMPEREX TECHNOLOGY CO., LIMITED"],
  "inventors": ["SUN, Longli", "CHENG, Yun"],
  "classifications": ["G01N 3/42", "Y02E 60/10"],
  "priorityDate": "2024-12-10",
  "filingDate": "2025-05-16",
  "publicationDate": "2026-06-18",
  "abstract": "A method for measuring the relative density of a solid-state battery...",
  "language": "en",
  "patentscopeUrl": "https://patentscope.wipo.int/search/en/detail.jsf?docId=WO2026123589",
  "sourceDetailUrl": "https://patentscope.wipo.int/search/en/detail.jsf?docId=WO2026123589"
}
```

### How much does it cost to search WIPO patent publications?

Pricing is pay per event: a small **$0.005 run start** plus a per-record charge. At the Bronze rate of **$0.068132 per patent**, 10 records cost about **$0.686**, 25 records about **$1.708**, and 100 records about **$6.818**. The price shown in Apify Console is authoritative.

You are charged only for validated records saved to the dataset. Empty searches do not incur item charges.

### Getting started

1. Enter a concrete technology phrase or WO publication number in `query`.
2. Add an applicant, inventor, or date bound only when you need a narrower set.
3. Start with 10–25 records and inspect the Overview table.
4. Export the validated dataset or connect it to a downstream workflow.

### Who is it for?

Patent researchers use broad queries to establish terminology. IP teams narrow results by applicant for portfolio reviews. R\&D teams schedule date-bounded searches to identify newly published international applications. These are discovery workflows, not substitutes for professional legal searches.

### Prior-art research workflow

Run a one-time technology search, inspect titles and abstracts, then open the PATENTSCOPE links for relevant publications. Export JSON, CSV, Excel, or XML when you need a review corpus.

### Patent landscape workflow

Combine a technology query with an applicant filter to build a focused landscape. Classification arrays make it practical to group the resulting records by technical domain downstream.

### Portfolio monitoring workflow

Bound searches by publication date, schedule the Actor weekly, and compare dataset snapshots downstream. The Actor returns source snapshots; it does not maintain alert state or compare runs itself.

### Data delivery integrations

Feed normalized records into Google Sheets, Make, Zapier, n8n, a database, or an AI research pipeline. Use `publicationNumber` as the stable deduplication key.

### API and JavaScript

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/wipo-patentscope-patent-search-records').call({
  query: 'carbon capture',
  publishedFrom: '2025-01-01',
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Use the synchronous dataset endpoint when you need results directly:

```text
POST https://api.apify.com/v2/acts/automation-lab~wipo-patentscope-patent-search-records/run-sync-get-dataset-items?token=YOUR_TOKEN
```

### cURL API example

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~wipo-patentscope-patent-search-records/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"solid state battery","maxItems":10}'
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/wipo-patentscope-patent-search-records").call(
    run_input={"query": "solid state battery", "maxItems": 10}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

### Use with AI agents and MCP

Connect the Actor through [Apify MCP](https://docs.apify.com/platform/integrations/mcp) and ask an agent to search a technology, summarize likely prior art, or group publications by applicant. Patent records are research inputs, not legal opinions.

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/wipo-patentscope-patent-search-records"
```

**Claude Desktop, Cursor, and VS Code setup:** add this remote MCP server configuration to the client’s MCP settings:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/wipo-patentscope-patent-search-records"}}}
```

#### Example prompts showing MCP usage

- “Search WIPO international publications for solid-state battery cooling and return the five most recent records.”
- “Find hydrogen fuel-cell publications from Toyota and group them by classification.”

### Legality and responsible use

Use only public patent metadata, respect WIPO terms, and keep request volumes bounded. Verify consequential results in the official record. Do not treat automated search output as a completeness guarantee, patentability opinion, or freedom-to-operate advice.

### Reliability and failure behavior

The Actor uses bounded retries for temporary network, rate-limit, and upstream server failures. It rejects malformed dates and unsupported limits before requesting data. If a source response stays unavailable, the run fails clearly rather than presenting zero records as a successful search.

### Tips and limitations

- Results are restricted to international `WO` publications.
- Bibliographic coverage varies by patent family and language; some fields can be empty.
- Search and detail data come directly from public WIPO PATENTSCOPE pages. PATENTSCOPE may change its session or page structure.
- `maxItems` is capped at 1,000 to keep runs bounded.
- This Actor does not provide legal advice or a patentability/freedom-to-operate opinion.

### Troubleshooting

**No records returned:** simplify the query, remove optional filters, or verify the date range.

**A field is empty:** the PATENTSCOPE publication may not expose it in the requested language. Try English or open the PATENTSCOPE link.

**The run fails with an upstream error:** retry later. The Actor retries transient WIPO failures and starts up to three fresh sessions, but fails clearly after bounded exhaustion rather than returning a misleading empty success.

### Related automation-lab Actors

This Actor is currently standalone because no published automation-lab Actor covers the same WIPO-focused workflow. Use Apify platform integrations to combine it with your own research pipeline.

### FAQ

**Does it require a WIPO account?** No.

**Can I search national-only publications?** No. This Actor intentionally focuses on WO international publications.

**Can I schedule portfolio monitoring?** Yes. Use Apify Schedules with a stable applicant/date query and compare outputs in your preferred destination.

**Is the output legal advice?** No. Consult a qualified patent professional for legal conclusions.

# Actor input Schema

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

Keywords, a patent title, or a WO publication number.

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

Optional applicant or assignee name filter.

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

Optional inventor name filter.

## `publishedFrom` (type: `string`):

Optional earliest publication date in YYYY-MM-DD format.

## `publishedTo` (type: `string`):

Optional latest publication date in YYYY-MM-DD format.

## `language` (type: `string`):

Preferred language for titles and abstracts.

## `maxItems` (type: `integer`):

Maximum number of normalized patent records to save.

## Actor input object example

```json
{
  "query": "solid state battery",
  "language": "en",
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset containing the validated patent publication records saved by this run.

# 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 = {
    "query": "solid state battery",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/wipo-patentscope-patent-search-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 = {
    "query": "solid state battery",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/wipo-patentscope-patent-search-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 '{
  "query": "solid state battery",
  "maxItems": 20
}' |
apify call automation-lab/wipo-patentscope-patent-search-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/wipo-patentscope-patent-search-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/aaqaRHcGdsGpf3SoJ/builds/Aa5HSacgkpfFzqhGb/openapi.json