# Google Patents Scraper (Search, Abstracts, CPC) (`webdatatools/google-patents-scraper`) Actor

Search Google Patents by keyword, assignee, inventor, country, status and date, and return one row per patent with dates, assignee, PDF link and optionally abstract, claims, CPC codes and legal status.

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

## Pricing

from $1.20 / 1,000 patents

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?

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

## Google Patents Scraper (Search, Abstracts, CPC)

### What is Google Patents Scraper?

Google Patents Scraper searches Google Patents by keyword, assignee, inventor, country, status and publication date. It returns one row per patent: publication number, title, snippet, assignee, inventors, priority, filing and publication dates, country, PDF link and the Google Patents page. Optionally it opens each patent page for the abstract, claims, CPC classification codes and legal status. You can also skip the search and look up specific patent numbers.

Use it for prior-art searches, competitor tracking by assignee, technology scans by CPC topic and patent lists for research. It reads the public Google Patents search endpoint and patent pages. No Google login is used.

### What data does Google Patents Scraper extract?

| Field | Type | Meaning |
|---|---|---|
| publicationNumber | string | Patent or application number, e.g. US9123456B2 |
| position | number | Rank within the search (1 = first) |
| page | number or null | Search page the row came from (100 per page) |
| query | string or null | The keywords used |
| title | string | Patent title |
| snippet | string or null | Excerpt from the search result |
| assignee | string or null | Current assignee as Google shows it |
| inventors | string or null | Inventors, separated by semicolons |
| priorityDate, filingDate, grantDate, publicationDate | string or null | ISO dates (YYYY-MM-DD) |
| country | string | Office code from the number, e.g. US, CN, EP |
| language | string or null | Language of the record |
| url | string | Google Patents page for the patent |
| pdfUrl | string or null | Link to the patent PDF |
| abstract | string or null | Abstract (with includeDetails or patent numbers) |
| claimCount, claims | number or null, string or null | Number of claims and their text, up to 20,000 characters |
| cpcCodes | string or null | Leaf CPC codes, separated by semicolons |
| legalStatus | string or null | Status Google shows, e.g. Active, Expired - Fee Related |
| scrapedAt | string | ISO timestamp of the scrape |

### How to use Google Patents Scraper

1. Enter keywords in "Search keywords", e.g. `solid-state battery`.
2. Optional: add an assignee, an inventor, a country code, a status or a publication date range.
3. Set "Max patents" (default 50, up to 500).
4. Turn on "Include full record" if you need the abstract, claims, CPC codes and legal status.
5. Or leave the keywords empty and list patent numbers under "Patent numbers" to look up those patents only.
6. Start the run and download the dataset, or read it through the API.

### Example input

```json
{
    "query": "solid-state battery",
    "assignee": "Tesla",
    "status": "GRANT",
    "maxResults": 20,
    "includeDetails": true
}
```

### Example output

Real row from a patent-number lookup on 23 Oct 2026 (abstract and claims shortened here):

```json
{
    "publicationNumber": "US9123456B2",
    "position": 1,
    "title": "High frequency cable, high frequency coil and method for manufacturing high frequency cable",
    "assignee": "Fujikura Ltd",
    "inventors": "Takashi Shinmoto; Shotaro Yoshida; Shinji Katayama; Taikou TODA; Takamasa Kato; Masanori DAIBO; Akio Kawakami",
    "priorityDate": "2010-03-23",
    "filingDate": "2012-09-21",
    "grantDate": null,
    "publicationDate": "2015-09-01",
    "country": "US",
    "language": "en",
    "url": "https://patents.google.com/patent/US9123456B2/en",
    "pdfUrl": "https://patentimages.storage.googleapis.com/6c/70/d5/8682e85a6a4c05/US9123456.pdf",
    "abstract": "A high frequency cable includes: a central conductor made from aluminum or an aluminum alloy; a covering layer made from copper covering the central conductor ...",
    "claimCount": 5,
    "claims": "1. A high frequency cable, comprising: a central conductor made from aluminum or an aluminum alloy; ...",
    "cpcCodes": "H01B13/00; H01B13/0006; H01B13/06; B21C3/00; ...; H01B7/00; H01B7/30; H01F27/00; ...",
    "legalStatus": "Expired - Fee Related",
    "scrapedAt": "2026-10-23T10:18:34.674Z"
}
```

### Input parameters

| Parameter | Default | Description |
|---|---|---|
| query | empty (demo `solid-state battery` when no patent numbers are given) | Keywords |
| patentNumbers | empty | Patent numbers to look up, one per line |
| assignee | empty | Company or person that owns the patent |
| inventor | empty | Inventor name |
| country | empty | Office code: US, CN, EP, WO, JP, KR |
| status | any | any, GRANT or APPLICATION |
| publishedAfter, publishedBefore | empty | Publication date range, YYYY-MM-DD |
| maxResults | 20 | Patents per run, 1 to 500 |
| includeDetails | false | Open each patent page for abstract, claims, CPC and status |

### Pricing

Pay per patent: **$2.00 per 1,000 patents** on the free plan ($0.002 per patent). Volume tiers lower the price on paid Apify plans.

Measured on 23 Oct 2026 at 256 MB: one run for 150 patents (keyword `battery`, search only) finished in 18 seconds. Platform usage is shown in the Apify run details; the figure depends on the run time, so check the run page for your own input.

### Google Patents Scraper vs. alternatives

Google Patents Scraper returns what the public Google Patents search shows: its ranking, its assignee and inventor names as Google writes them, and the CPC codes from the patent page. It does not replace an official patent office bulk download or a commercial patent database with legal-status history. Use this Actor when you need a quick, filtered list from Google Patents with the full record on demand.

### Using Google Patents Scraper with AI agents / MCP

An agent sends `query` (or `patentNumbers`) plus the filters and reads the dataset rows. Keep `maxResults` small for broad queries, because each patent is one charged row and the caller's `maxTotalChargeUsd` caps the total.

### FAQ

**Is this legal?** The Actor reads public Google Patents pages and the public search endpoint that those pages use. It does not log in. Check Google's terms for your own use, and respect the rights of the patent holders for any reuse of the text or PDFs.

**Why is grantDate empty for some patents?** Google shows a grant date only when the record has one. Older patents and some applications have none. The publication and priority dates are still filled.

**Why is the abstract empty for some patents?** In one test (EP3586387B1, 19 of 20 records had an abstract), the page had no abstract in the markup the Actor reads. The row is still returned with the other fields.

**How many patents can one run return?** Up to 500 per run. Google reports the total hits for each query in its results, but the Actor stops at your `maxResults`.

**Are there blocks or captchas?** In four test runs from Apify, the search endpoint and the patent pages answered every request without a proxy. Retries are built in for rate limits (HTTP 429) and server errors.

**Does it work with n8n, Make or Zapier?** Those tools can start any Apify Actor through their Apify integrations. This was not tested for this Actor.

**What about errors and limits?** A run fails only when no patent is collected. Patent numbers that are not found are reported in the log and skipped. Each run stops when the caller's maximum charge is reached.

### Related Actors

Other Actors from the same publisher are listed on its Apify profile.

### Support

Open an issue on the Actor's Issues tab on Apify. Include the run ID, your input and the log lines that mention a problem.

### Limitations

- The search returns Google's own ranking and Google's own assignee and inventor names. Names are not normalised across spellings.
- Legal status is what Google shows on the page. It is not a legal opinion, and it can lag the patent office register.
- Claims are cut at 20,000 characters per patent. Very long claim sets are truncated.
- Full records need one extra page request per patent. Runs with `includeDetails` take longer.

# Actor input Schema

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

Keywords to search in Google Patents, e.g. solid-state battery or "lithium iron phosphate". Leave empty when you only give patent numbers.

## `patentNumbers` (type: `array`):

Look up specific patents by publication number, one per line, e.g. US9123456B2 or EP3000000A1. Use this without keywords to get the full record of each patent.

## `assignee` (type: `string`):

Only patents owned by this company or person, e.g. Tesla or Toyota. Optional.

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

Only patents with this inventor name, e.g. Takashi Shinmoto. Optional.

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

Two-letter patent office code, e.g. US, CN, EP, WO, JP, KR. Leave empty for all offices.

## `status` (type: `string`):

GRANT returns granted patents only, APPLICATION returns applications only, any returns both.

## `publishedAfter` (type: `string`):

Optional. Earliest publication date as YYYY-MM-DD, e.g. 2020-01-01.

## `publishedBefore` (type: `string`):

Optional. Latest publication date as YYYY-MM-DD, e.g. 2026-12-31.

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

How many patents to return, e.g. 50. Google Patents returns up to 100 per page; the Actor pages until this number is reached.

## `includeDetails` (type: `boolean`):

When on, each patent page is also opened for its abstract, claims, CPC codes and legal status. Slower; the price per patent is the same.

## Actor input object example

```json
{
  "query": "solid-state battery",
  "patentNumbers": [],
  "assignee": "",
  "inventor": "",
  "country": "",
  "status": "any",
  "publishedAfter": "",
  "publishedBefore": "",
  "maxResults": 20,
  "includeDetails": false
}
```

# Actor output Schema

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

All patents from 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"
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdatatools/google-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 = { "query": "solid-state battery" }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,webdatatools/google-patents-scraper"
        }
    }
}
```

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/hJgkZPwDPcbwGGd7B/builds/hljuTHilxv3gLvSM0/openapi.json