# Google Patents Scraper — Search, Citations, Family Graph (`memo23/google-patents-scraper`) Actor

Scrape Google Patents across USPTO, EPO, WIPO, JPO and 100+ offices. Six modes: keyword search, ID lookup, assignee and inventor portfolios, family graphs, and citation hops. Paste a patents.google.com URL or a query. Claims, CPC, expiry, PDF. Pay-per-event, no API key.

- **URL**: https://apify.com/memo23/google-patents-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Automation, AI, MCP servers
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 patent record (basic)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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, Citations, Family Graph

Scrape **Google Patents** — keyword search, publication IDs, assignee and inventor portfolios, family graphs, and citation hops — and get one structured row per publication: title, abstract, dates, claims, CPC, citations, family members, expiry, and a PDF link. Paste a `patents.google.com` URL or a query. No API key.

#### How it works

![How the Google Patents scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-google-patents.png)

#### ✨ Why use this scraper?

- **Six modes.** Keyword search, ID lookup, assignee portfolio, inventor portfolio, family graph, and N-hop citation crawl — same surface as the Store leader, plus URL input.
- **Paste a URL.** Search pages (`?q=`, `?assignee=`, `?inventor=`) and detail pages (`/patent/US10000000B2/en`) are classified automatically.
- **Arrays, not singles.** Multiple queries, assignees, inventors, or IDs in one run.
- **CPC filter.** Restrict search with `G06N` or a full leaf like `G01S7/4863`.
- **Deep records.** Claims, forward/backward citations, family ID + members, CPC leaves, full description, expiry, legal events, PDF.
- **No key, no browser.** Search hits Google's public `/xhr/query` JSON; details parse server-rendered HTML.

#### 🎯 Use cases

| Who | What they use it for |
| --- | --- |
| **Patent attorneys & agents** | Prior-art search, claim review, family coverage across offices. |
| **IP / competitive intel** | Assignee and inventor portfolios, citation neighborhoods around a seed. |
| **R\&D and product teams** | Landscape a technology area (query + CPC + date) before filing. |
| **Legal-tech & AI agents** | Structured patent records for MCP / RAG / landscaping tools. |

#### 📥 Supported inputs

| You paste | What happens |
| --- | --- |
| `https://patents.google.com/?q=lidar` | Keyword search |
| `https://patents.google.com/?assignee=Apple+Inc.` | Assignee portfolio |
| `https://patents.google.com/?inventor=Geoffrey+Hinton` | Inventor portfolio |
| `https://patents.google.com/patent/US10000000B2/en` | Detail / family / citation seed |
| `US10000000B2` / `US-10000000-B2` | Same as a detail URL |

Not supported: Google Scholar-only literature, login-gated office dockets, or uploading a PDF for OCR.

#### 🔄 How it works

1. **Choose a mode** and give it queries, IDs, names, or start URLs.
2. **Search** pages the public `xhr/query` JSON (100 hits per page).
3. **Details** fetch `/patent/{id}/{lang}` and read `itemprop` fields (claims, family, citations, CPC, expiry).
4. **Family / citations** walk those fields and, when depth is deep, fetch each member or hop.
5. **Export** one row per publication as JSON, CSV, or Excel.

#### ⚙️ Input parameters

| Field | Type | Description |
| --- | --- | --- |
| `mode` | enum | `search`, `details`, `byAssignee`, `byInventor`, `family`, `citationNetwork`. |
| `startUrls` | array | Optional patents.google.com URLs. Classified automatically. |
| `searchQueries` / `searchQuery` | array / string | Free-text queries for `search`. Boolean AND/OR, quotes, wildcards. |
| `patentIds` | array | Publication numbers for `details`, `family`, `citationNetwork`. |
| `assigneeNames` / `assigneeName` | array / string | Company names for `byAssignee`. |
| `inventorNames` / `inventorName` | array / string | Person names for `byInventor`. |
| `countryCodes` | array | Office codes (`US`, `EP`, `WO`, `JP`…). |
| `cpc` | array | CPC prefixes. |
| `dateFrom` / `dateTo` | string | `YYYY-MM-DD` bounds. |
| `status` | enum | `ANY`, `GRANT`, `APPLICATION`. |
| `patentType` | enum | `ANY`, `PATENT`, `DESIGN`, `OTHER`. |
| `language` | string | Detail language (`en`, `de`, `ja`, `zh`). Default `en`. |
| `maxItems` | integer | Hard cap. Default 50. Caps citation nodes too. |
| `enrichmentDepth` | enum | `basic` or `deep`. |
| `citationDirection` | enum | `backward`, `forward`, `both`. |
| `citationDepth` | integer | Hops, 1–3. |
| `proxy` | object | Default Apify residential US. Direct works from many networks. |

#### Example input

```json
{
  "mode": "search",
  "searchQueries": ["\"large language model\" training"],
  "countryCodes": ["US", "EP"],
  "dateFrom": "2023-01-01",
  "status": "GRANT",
  "maxItems": 25,
  "enrichmentDepth": "basic"
}
```

#### 📊 Output overview

One dataset row per publication. Basic search rows carry id, title, snippet, dates, assignee, inventors, and the Google Patents URL. Deep (or any details/family/citation run) adds abstract, description, claims, CPC, citations, family, expiry, legal events, and PDF.

#### 📦 Output sample

```json
{
  "patentId": "US10000000B2",
  "title": "Coherent LADAR using intra-pixel quadrature detection",
  "assignee": "Raytheon Co",
  "inventors": ["Joseph Marron"],
  "filingDate": "2015-03-10",
  "publicationDate": "2018-06-19",
  "expirationDate": "2036-05-13",
  "countryCode": "US",
  "kindCode": "B2",
  "claimsCount": 20,
  "familyId": "55456961",
  "familyMembers": ["US10000000B2", "US10845468B2", "EP3268771B1", "WO2016144528A1"],
  "cpc": ["G01S7/4863", "G01S17/894"],
  "pdfUrl": "https://patentimages.storage.googleapis.com/c0/d5/f7/86ad5b42759506/US10000000.pdf",
  "googlePatentsUrl": "https://patents.google.com/patent/US10000000B2/en",
  "mode": "details"
}
```

#### 🗂 Key output fields

| Field | When |
| --- | --- |
| `patentId`, `title`, `assignee`, `inventors[]`, dates | Always |
| `snippet` | Search / assignee / inventor |
| `abstract`, `description`, `claims[]`, `cpc[]`, `pdfUrl` | Deep / details |
| `citationsBackward[]`, `citationsForward[]` | Deep / details |
| `familyId`, `familyMembers[]` | Deep / family |
| `expirationDate`, `legalEvents[]` | Details |
| `citationHop`, `citationSeed` | citationNetwork |
| `googlePatentsUrl`, `mode`, `scrapedAt` | Always |

#### ❓ FAQ

**Can I paste a patents.google.com URL?**\
Yes. Search, assignee, inventor, and `/patent/…` URLs are classified and merged with the other fields.

**How do I get claims and citations?**\
Set `enrichmentDepth` to `deep`, or use `mode: "details"` with `patentIds`.

**How do I follow citations?**\
`mode: "citationNetwork"` with seed IDs, then `citationDirection` and `citationDepth`. Cap with `maxItems`.

**Does this need an API key?**\
No. Search uses Google's public xhr endpoint; details are public HTML.

**Coming from another Google Patents scraper?**\
This one accepts start URLs, multiple queries/assignees/inventors, a CPC filter, full description, and expiry — fields the current Store leader leaves out.

#### 💬 Support

Open an issue on the [actor page](https://console.apify.com/actors/MLc3iCNkv2oNYoPZO/issues) or email via the Store profile. Include the run ID and the input you used.

#### 🛠 Additional services

Custom fields, scheduled landscaping into a warehouse, or a private build for a filing workflow — say what you need on the Issues tab.

#### 🔎 Explore more scrapers

Sibling IP actor: [USPTO Trademark Search](https://apify.com/memo23/uspto-trademark-scraper). Other actors: [memo23 on Apify](https://apify.com/memo23).

### 🤖 For AI Agents & LLM Apps

Actor: `memo23/google-patents-scraper` (slug after first publish).

**Purpose:** Search Google Patents and return one structured publication record per row.

**Minimal input:**

```json
{
  "mode": "search",
  "searchQueries": ["lidar perception"],
  "maxItems": 25
}
```

For a known ID: `"mode": "details", "patentIds": ["US10000000B2"]`.

**Behaviors an agent should know:**

- One `mode` per run. Arrays (`searchQueries`, `patentIds`, `assigneeNames`, `inventorNames`) each run as their own query and merge.
- Always set `maxItems`. Citation hops grow fast.
- `enrichmentDepth: "deep"` costs more and fetches the detail page per hit.
- `startUrls` accept patents.google.com search and detail URLs.
- Pay-per-event — see the Pricing tab.

### ⚠️ Disclaimer

This Actor reads **publicly available** patent publications on Google Patents for research, landscaping, and business-analysis use. It is an independent tool and is **not** affiliated with, endorsed by, or connected to Google, the USPTO, the EPO, WIPO, or any patent office.

The output is not legal advice. Patentability, freedom-to-operate, and validity calls belong to a qualified attorney. Use the data in line with applicable law and Google's terms. The Actor does not store scraped data; rows go to your Apify dataset.

### SEO Keywords

Google Patents scraper, Google Patents API, patent search scraper, USPTO patent scraper, EPO patent scraper, WIPO patent search, patent citation network, patent family scraper, CPC patent search, assignee patent portfolio, inventor patent search, prior art search tool, patent claims scraper, patent landscaping, IP intelligence scraper, Google Patents URL scraper, patent JSON export, patent CSV, patent MCP, patent expiry date

# Actor input Schema

## `mode` (type: `string`):

search = keyword discovery. details = full record for known patent IDs. byAssignee / byInventor = portfolios. family = jurisdictional family of a seed. citationNetwork = N-hop citation crawl.

## `startUrls` (type: `array`):

Optional. Paste patents.google.com search pages (?q=, ?assignee=, ?inventor=) or detail pages (/patent/US10000000B2/en). Classified automatically and merged with the fields below.

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

Free-text Google Patents queries for mode=search. Boolean AND/OR, quotes, and wildcards work. Each query is a separate search; results are merged. Use searchQuery for a single string if you prefer.

## `searchQuery` (type: `string`):

Single free-text query for mode=search. Same syntax as patents.google.com. Prefer searchQueries when you have more than one.

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

Publication numbers for details, family, and citationNetwork. Accepts US10000000B2, US-10000000-B2, EP3000000B1, WO2018000000A1.

## `assigneeNames` (type: `array`):

Company / organization names for mode=byAssignee. Each name is its own query.

## `assigneeName` (type: `string`):

Single assignee for mode=byAssignee. Prefer assigneeNames for more than one.

## `inventorNames` (type: `array`):

Person names for mode=byInventor. Each name is its own query.

## `inventorName` (type: `string`):

Single inventor for mode=byInventor.

## `countryCodes` (type: `array`):

Two-letter office codes (US, EP, WO, JP, CN, KR, …). Applied as country:XX operators. Ignored in details and family modes.

## `cpc` (type: `array`):

CPC prefixes to restrict search, e.g. G06N or G01S7/4863. Applied as CPC= operators. Ignored in details and family modes.

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

Lower bound YYYY-MM-DD. Filters publication date (or filing date when status=APPLICATION).

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

Upper bound YYYY-MM-DD.

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

ANY returns grants and applications. GRANT = issued only. APPLICATION = published applications only.

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

ANY, PATENT (utility), DESIGN, or OTHER (plant and similar).

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

Detail-page language (en, de, ja, zh, …). Google auto-translates when a translation exists.

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

Hard cap on patent records returned. In citationNetwork this caps total nodes across hops. Default 50.

## `enrichmentDepth` (type: `string`):

basic = id, title, snippet/abstract, dates, assignee, inventors, URL ($0.002). deep = plus claims, citations, family, CPC, PDF, description, expiry ($0.005). details / family / citationNetwork always fetch the detail page.

## `citationDirection` (type: `string`):

citationNetwork only. backward = prior art this seed cites. forward = later patents that cite the seed. both = both directions.

## `citationDepth` (type: `integer`):

citationNetwork hops. 1 = direct citations. 2–3 grow very fast — keep maxItems tight.

## `maxConcurrency` (type: `integer`):

Parallel HTTP fetches (1–20). Default 8.

## `proxy` (type: `object`):

Default: Apify residential US. Direct works from many home IPs; Google has been seen returning HTTP 500 on filtered queries from datacenter IPs.

## Actor input object example

```json
{
  "mode": "search",
  "startUrls": [
    "https://patents.google.com/?q=machine+learning"
  ],
  "searchQueries": [
    "machine learning autonomous vehicle"
  ],
  "patentIds": [
    "US10000000B2"
  ],
  "assigneeNames": [
    "Apple Inc."
  ],
  "inventorNames": [
    "Geoffrey Hinton"
  ],
  "dateFrom": "2020-01-01",
  "status": "ANY",
  "patentType": "ANY",
  "language": "en",
  "maxItems": 50,
  "enrichmentDepth": "basic",
  "citationDirection": "both",
  "citationDepth": 1,
  "maxConcurrency": 8,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

All patent records from this run

## `deep` (type: `string`):

Records with claims, citations, family, CPC, and PDF

# 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 = {
    "startUrls": [
        "https://patents.google.com/?q=machine+learning"
    ],
    "searchQueries": [
        "machine learning autonomous vehicle"
    ],
    "patentIds": [
        "US10000000B2"
    ],
    "assigneeNames": [
        "Apple Inc."
    ],
    "inventorNames": [
        "Geoffrey Hinton"
    ],
    "dateFrom": "2020-01-01"
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 = {
    "startUrls": ["https://patents.google.com/?q=machine+learning"],
    "searchQueries": ["machine learning autonomous vehicle"],
    "patentIds": ["US10000000B2"],
    "assigneeNames": ["Apple Inc."],
    "inventorNames": ["Geoffrey Hinton"],
    "dateFrom": "2020-01-01",
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/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 '{
  "startUrls": [
    "https://patents.google.com/?q=machine+learning"
  ],
  "searchQueries": [
    "machine learning autonomous vehicle"
  ],
  "patentIds": [
    "US10000000B2"
  ],
  "assigneeNames": [
    "Apple Inc."
  ],
  "inventorNames": [
    "Geoffrey Hinton"
  ],
  "dateFrom": "2020-01-01"
}' |
apify call memo23/google-patents-scraper --silent --output-dataset

```

## MCP server setup

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