# Google Patents Scraper - Claims, Citations & Legal Status (`scrapewise/google-patents-scraper`) Actor

Scrape Google Patents without an API key: search by keyword, assignee, inventor, country and date, then optional full details (abstract, claims, CPC, citations, cited by, family, legal events, expiry). US$ 2 per 1,000 patents, +2.50 with details.

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

## Pricing

from $1.70 / 1,000 patent delivereds

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, claims, citations, legal status and expiry

Scrape [Google Patents](https://patents.google.com/) **without an API key, an account or a browser**. Search 100+
patent offices (USPTO, EPO, WIPO, CNIPA, JPO, KIPO and more) by **keyword, assignee, inventor, office, date range,
status, type and language**, exactly like the Google Patents search box, and get one clean row per patent: number,
title, snippet, priority / filing / publication / grant dates, inventor, assignee, PDF link and family status.

Turn on **Full details** and each row also gets the **abstract, every claim (independent or dependent), CPC codes,
backward citations, cited-by (forward citations), family members, timeline, legal events, legal status and expiration
date**. Paste patent numbers or links to get the full record of specific patents.

Built for patent attorneys and IP analysts running prior-art and freedom-to-operate searches, R\&D and competitive
intelligence teams watching a competitor's portfolio, tech-transfer offices, investors doing due diligence, and
anyone building patent datasets for AI and RAG.

**US$ 2.00 per 1,000 patents. Full details +US$ 2.50 per 1,000 (US$ 4.50 for the complete record). No start fee, no
monthly fee. Error rows and duplicates are free.**

### At a glance

- **Search row, per 1,000:** US$ 2.00
- **Complete record (claims, citations...), per 1,000:** US$ 4.50
- **Fee per run start:** None
- **Filters: office, assignee, inventor, dates, status, type, language:** Yes
- **Claims with independent / dependent flag:** Yes
- **Cited-by (forward citations) and family:** Yes
- **Legal events, legal status and expiration date:** Yes
- **Full description text (optional):** Yes
- **Resumes after a platform restart without charging twice:** Yes

### What you can do with it

- **Prior-art search.** Run your keywords with a priority-date cutoff, turn on details, read claims and CPC codes in
  a spreadsheet instead of opening 200 tabs.
- **Watch a competitor.** `assignees: ["Samsung Electronics"]`, `sortBy: newest`, scheduled weekly: every new
  publication lands in your dataset.
- **Map a technology.** Query + office filter + date range, then pivot by assignee, CPC code or year.
- **Check if a patent is still alive.** Paste the numbers: `legalStatus`, `expirationDate` and `legalEvents` tell you.
- **Citation analysis.** `citations` and `citedBy` give you both directions, with the examiner-cited flag.
- **Feed an AI.** Claims, abstract and (optionally) the full description as clean text, ready for embeddings.

### Input

| Field | What it does |
|---|---|
| `searchQueries` | Keywords, one query per line. Google Patents syntax works: `"solid state" battery`, `OR`, `NOT`, parentheses. |
| `patentIds` | Numbers or links: `US9674549B2`, `EP3067979B1`, `https://patents.google.com/patent/US9674549B2/en`. Always returned with details. |
| `assignees` / `inventors` | Only patents of these companies / people. Work alone (whole portfolio) or with the queries. |
| `maxResultsPerQuery` | Patents per query. Default 20, up to 1,000 (Google Patents' own limit per search). |
| `maxItems` | Hard cap on charged patents for the whole run. |
| `includeDetails` | Opens each patent page and adds the full record. |
| `includeDescription` | With details, also the full specification text. |
| `countries` | Office codes: US, EP, WO, CN, JP, KR, DE, GB, FR, IN, BR... |
| `dateFrom` / `dateTo` / `dateType` | Date range (YYYY-MM-DD or a year) on the priority, filing or publication date. |
| `status` | `any`, `granted` or `application`. |
| `patentType` | `any`, `patent` (utility) or `design`. |
| `language` | ENGLISH, GERMAN, CHINESE, JAPANESE, KOREAN... |
| `sortBy` | `relevance`, `newest` or `oldest`. |

Example: Toyota's newest hydrogen-tank patents at the US office, with full details.

```json
{
  "searchQueries": ["hydrogen tank"],
  "assignees": ["Toyota"],
  "countries": ["US"],
  "sortBy": "newest",
  "maxResultsPerQuery": 50,
  "includeDetails": true
}
```

An empty input runs a small example (10 patents for "solid state battery electrolyte"), so the Actor never fails
on a blank form.

### Output

#### Search row (details off), one real row

From a local test run on 2026-09-29 (the empty-input example).

```json
{
  "type": "patent",
  "publicationNumber": "US9692078B2",
  "title": "High-performance rechargeable batteries with fast solid-state ion conductors",
  "url": "https://patents.google.com/patent/US9692078B2/en",
  "countryCode": "US",
  "snippet": "A high-performance rechargeable battery using ultra-fast ion conductors. In one embodiment the rechargeable battery apparatus includes an enclosure, a first electrode operatively connected to the enclosure, ...",
  "priorityDate": "2009-09-25",
  "filingDate": "2016-11-22",
  "publicationDate": "2017-06-27",
  "grantDate": "2017-06-27",
  "inventor": "Joseph C. Farmer",
  "assignee": "Lawrence Livermore National Security, Llc",
  "language": "en",
  "pdfUrl": "https://patentimages.storage.googleapis.com/c7/3c/4e/94354895cd93e5/US9692078.pdf",
  "thumbnailUrl": "https://patentimages.storage.googleapis.com/09/91/1f/9052fa67d9bf1e/US09692078-20170627-D00000.png",
  "familyStatus": [{"countryCode": "WO", "state": "NOT_ACTIVE"}, {"countryCode": "US", "state": "NOT_ACTIVE"}],
  "query": "solid state battery electrolyte",
  "position": 1,
  "detailsLoaded": false,
  "source": "query:solid state battery electrolyte",
  "scrapedAt": "2026-09-29T21:03:12Z",
  "errorCode": null
}
```

#### Full record (details on), same patent, lists cut to one element

The real row has 2 claims, 16 citations, 42 cited-by, 20 CPC codes, 9 timeline events, 8 legal events, 4 family
members and 25 similar documents.

```json
{
  "type": "patent",
  "publicationNumber": "US9692078B2",
  "title": "High-performance rechargeable batteries with fast solid-state ion conductors",
  "abstract": "A high-performance rechargeable battery using ultra-fast ion conductors. In one embodiment the rechargeable battery apparatus includes an enclosure, a first electrode operatively connected to the enclosure, a second electrode operatively connected to the enclosure, a nanomaterial in the enclosure, and a heat transfer unit.",
  "inventors": ["Joseph C. Farmer"],
  "originalAssignees": ["Lawrence Livermore National Security LLC"],
  "currentAssignees": ["Lawrence Livermore National Security LLC"],
  "applicationNumber": "US15/358,518",
  "kindCode": "B2",
  "priorityDate": "2009-09-25",
  "filingDate": "2016-11-22",
  "publicationDate": "2017-06-27",
  "grantDate": "2017-06-27",
  "legalStatus": "Expired - Fee Related",
  "priorArtKeywords": ["electrode", "enclosure", "flowing material", "battery", "suspended"],
  "cpcClassifications": [{"code": "B82Y30/00", "description": "Nanotechnology for materials or surface science, e.g. nanocomposites", "first": true}],
  "claimsCount": 2,
  "independentClaimsCount": 2,
  "claims": [{"number": 1, "text": "1. A rechargeable battery apparatus, comprising: an enclosure, a first electrode operatively connected to said enclosure wherein said first electrode is an electro-catalytic anode, ...", "independent": true}],
  "citations": [{"publicationNumber": "US3443997A", "priorityDate": "1966-02-11", "publicationDate": "1969-05-13", "assignee": "North American Rockwell", "title": "Solid state electrochemical devices", "examinerCited": false, "familyCitation": false}],
  "citedBy": [{"publicationNumber": "US9705136B2", "priorityDate": "2008-02-25", "publicationDate": "2017-07-11", "assignee": "Traverse Technologies Corp.", "title": "High capacity energy storage", "examinerCited": false, "familyCitation": true}],
  "similarDocuments": [{"publicationNumber": "US9614251B2", "publicationDate": "2017-04-04", "title": "High-performance rechargeable batteries with nanoparticle active materials, photochemically regenerable active materials, and fast solid-state ion conductors"}],
  "familyMembers": [{"publicationNumber": "US20110076542A1", "publicationDate": "2011-03-31"}],
  "timeline": [{"date": "2016-11-22", "title": "Application filed by Lawrence Livermore National Security LLC", "type": "filed", "critical": true}],
  "legalEvents": [{"date": "2016-12-15", "code": "AS", "title": "Assignment", "details": {"Owner name": "LAWRENCE LIVERMORE NATIONAL SECURITY, LLC, CALIFOR", "Effective date": "20161215"}}],
  "pdfUrl": "https://patentimages.storage.googleapis.com/c7/3c/4e/94354895cd93e5/US9692078.pdf",
  "detailsLoaded": true,
  "source": "patent:US9692078B2",
  "errorCode": null
}
```

#### Error rows (never charged)

| errorCode | When |
|---|---|
| `NOT_FOUND` | Google Patents has no page for that number. |
| `INVALID_URL` | The text is not a patent number or a patents.google.com/patent link. |
| `NO_RESULTS` | The search found nothing. |
| `BLOCKED` | Google Patents refused every attempt for that request. |
| `NOT_REACHED` | The run timeout arrived before this patent. |
| `INVALID_INPUT` | A field has a value the Actor cannot use (the message says which). |
| `UNEXPECTED` | Anything else; the rest of the run continues. |

If the details page of a search result fails, you still get the search row, charged as a search row only, with
`detailsError` saying why.

### Pricing

Pay per event, no start fee:

| Event | Price per 1,000 (Free plan) | Charged for |
|---|---|---|
| Patent delivered | **US$ 2.00** | each unique patent row |
| Full details added | **US$ 2.50** | each row whose patent page was read (details on, or numbers you pasted) |

Examples: 1,000 search rows cost US$ 2.00. 200 patents with full details cost US$ 0.90. Error rows and duplicates
are free, and `maxItems` is a hard stop.

### How it works and limits

- Search uses the same JSON endpoint as the Google Patents results page; details come from the public patent page.
  Plain HTTP through the Apify datacenter proxy, with a new IP on any refused request. No browser, no API key.
- **1,000 results per query** is Google Patents' own cap. For bigger sets, split by date range or office.
- Names come as the office publishes them: a Japanese or Chinese filing may list the assignee in Japanese or Chinese
  (Toyota appears as トヨタ自動車株式会社 or 丰田自动车株式会社).
- Some older WIPO and other documents only have OCR claim text; then `claimsFromOcr` is `true`, the claims come as one
  block and `independentClaimsCount` is `null`.
- Legal status and expiration are Google's own estimate, not a legal opinion.
- No emails or phone numbers are returned. Inventor and assignee names are part of the public patent record.

### FAQ

**Do I need a Google or SerpApi key?** No.

**Why are details a separate price?** Reading each patent page is a second request with ~450 KB of HTML. If you only
need titles, dates and assignees, keep details off and pay US$ 2.00 per 1,000.

**Can I get all patents of a company?** Put the company in `assignees`, leave the query empty and split by year with
`dateFrom` / `dateTo` if it has more than 1,000.

**What if the run is restarted by the platform?** Patents already in the dataset are not charged again: the Actor
reads its own dataset when it starts and skips what was delivered.

**How fast is it?** In our tests: 120 search rows in 5 s; 8 patents with full details in 9 to 27 s.

### Changelog

- **0.1 (2026-09-29):** first version: search with filters, full details, numbers and links, resume after restart.

Independent tool, not affiliated with Google.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords, one query per line, exactly as you would type them on patents.google.com. Google Patents syntax works: quotes for phrases ("solid state" battery), OR, AND, NOT, parentheses. Each query returns up to 'Max results per query' patents.

## `patentIds` (type: `array`):

Publication numbers or Google Patents links, one per line: US9674549B2, EP3067979B1, WO2019009625A1, https://patents.google.com/patent/US9674549B2/en. Each one returns the full record (always with details).

## `assignees` (type: `array`):

Only patents of these assignees, one per line (Toyota, Apple Inc, Samsung Electronics). Works alone (whole portfolio) or together with the queries.

## `inventors` (type: `array`):

Only patents naming these inventors, one per line. Works alone or together with the queries.

## `maxResultsPerQuery` (type: `integer`):

How many patents to take from each query, in Google Patents' order. Empty = 20. Google Patents shows at most 1,000 per query; split big searches by date range to get more.

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

Hard cap on charged patents for the whole run. Empty or 0 = no cap besides the per-query limit.

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

Opens each patent page and adds abstract, all claims (with independent/dependent flag), CPC codes, citations and cited-by lists, family members, timeline, legal events, legal status and expiration date. Adds US$ 2.50 per 1,000 patents. Off = the search row only (title, snippet, dates, inventor, assignee, PDF link).

## `includeDescription` (type: `boolean`):

With details on, also returns the full specification text (often 20,000 to 200,000 characters per patent). Off by default to keep rows small. No extra charge.

## `countries` (type: `array`):

Two-letter office codes, one per line: US, EP, WO, CN, JP, KR, DE, GB, FR, IN, BR... Empty = all offices.

## `dateFrom` (type: `string`):

YYYY-MM-DD or just a year (2018). Uses the date type below.

## `dateTo` (type: `string`):

YYYY-MM-DD or just a year.

## `dateType` (type: `string`):

Which date the From/To filter applies to. Empty = priority date.

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

Keep only granted patents or only published applications. Empty = any.

## `patentType` (type: `string`):

Utility or design patents. Empty = any.

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

Original language of the document, in capitals as Google Patents names it: ENGLISH, GERMAN, CHINESE, JAPANESE, KOREAN, FRENCH... Empty = any.

## `sortBy` (type: `string`):

Order of the search results. Empty = relevance.

## `proxyConfiguration` (type: `object`):

Apify datacenter proxy is the default and works for Google Patents. Refused requests are retried on a new IP.

## Actor input object example

```json
{
  "searchQueries": [
    "solid state battery electrolyte"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `resultsCsv` (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 = {
    "searchQueries": [
        "solid state battery electrolyte"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapewise/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 = {
    "searchQueries": ["solid state battery electrolyte"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapewise/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 '{
  "searchQueries": [
    "solid state battery electrolyte"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapewise/google-patents-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapewise/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/4ampZnU3INLK8QxQh/builds/LOelYUMzUkbHZ3MF1/openapi.json