# Google Patents & Citation Network Scraper (`scraper-engine/google-patents-scraper`) Actor

🔎 Google Patents Scraper extracts rich patent data from Google Patents—titles, abstracts, claims, inventors, assignees, CPC/IPC, citations, legal status, dates & PDFs. ⚙️ Export CSV/JSON. 🚀 Ideal for prior art, IP due diligence, competitive intel & tech scouting.

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

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Google Patents Scraper — Citation Network, Assignee and Filing Data

Google Patents & Citation Network Scraper pulls patent bibliographic data — `patentNumber`, `title`, `assignee`, `filingDate` — plus a fully expanded citation network (backward references, forward citations, similar documents) from Google Patents, returned as structured JSON with no HTML parsing required. Search by keyword, patent link, publication number, assignee, or inventor. Run it on Apify to get your first citation-mapped patent dataset in minutes.

### What is Google Patents & Citation Network Scraper?

Google Patents & Citation Network Scraper is an Apify Actor that searches Google Patents and pulls each matching patent's bibliographic data, full text, classification codes, and citation network — every backward reference and forward citation expanded into a full record (title, dates, assignee) rather than a bare publication-number string. It fetches Google Patents' own public search and detail endpoints directly, so no Google account, login, or session cookie is used or required. It's built for patent attorneys, IP researchers, and R\&D/competitive-intelligence teams who need citation-linked patent data without manually clicking through Google Patents pages or a BigQuery pipeline.

### What Google Patents data is publicly available to scrape?

Anyone who opens a patent's page on patents.google.com — no account required — can see its full bibliographic record, description, claims, classifications, and citation lists. A few adjacent categories of patent information simply aren't published on Google Patents at all, at any access level.

| Data Category | Publicly Available on Google Patents | Restricted (not on Google Patents) |
| --- | --- | --- |
| Bibliographic data (number, title, dates, assignee, inventors) | Yes | — |
| Full description and claims text | Yes | — |
| Backward/forward citation lists | Yes | — |
| Patent family members | Yes | — |
| CPC/IPC classification codes | Yes | — |
| Similar documents / prior-art suggestions | Yes | — |
| Legal status and prosecution history (office actions) | No | Requires USPTO Public PAIR or the relevant national patent office system |
| Litigation, licensing, and ownership-transfer records | No | Requires court dockets (e.g. PACER) or IP transaction databases |

Google Patents & Citation Network Scraper only returns publicly visible data — what any visitor sees on patents.google.com. Nothing behind a login wall.

### What data can I extract with Google Patents & Citation Network Scraper?

Google Patents & Citation Network Scraper returns one JSON row per patent covering identity/bibliographic data, full text, and a labeled citation network, plus optional child datasets for citations and similar documents.

| Field Name | Description |
| --- | --- |
| `patentNumber` | Publication number (e.g. `US11234567B2`) |
| `title` | Cleaned patent title |
| `abstract` | Patent abstract/snippet |
| `inventors` | Array of inventor names |
| `assignee` | Assignee/owning organization |
| `filingDate` | Filing date |
| `publicationDate` | Publication date |
| `grantDate` | Grant date, if granted |
| `priorityDate` | Earliest priority date, if available |
| `language` | Primary document language |
| `docId` | Google Patents internal document ID |
| `rank` | Result rank on the search page this patent was found on |
| `url` | Canonical `patents.google.com` URL |
| `pdfUrl` | Direct PDF download URL |
| `thumbnailUrl` | First-figure thumbnail image URL, if any |
| `figures` | Array of `{thumbnailUrl, fullUrl}` figure images |
| `classifications` | `{cpc: [...], ipc: [...]}` classification codes (populated when `includeClassificationCodes` is on) |
| `fullText` | `{description, claims}` full text (populated per `includeFullDescription` / `includeClaimsText`) |
| `patentFamily` | Array of related publication numbers in the same patent family |
| `citations` | `{citedBy: [...], references: [...]}` — bare publication-number strings (base-compatible field) |
| `citationNetwork` | `{references: {original, familyToFamily}, citedBy: {original, familyToFamily}}` — each entry a full record: `publicationNumber`, `title`, `assignee`, `priorityDate`, `publicationDate`, `url`, `citedBySource` (`"examiner"` or `"applicant"`) |
| `citationCounts` | `{referencesOriginal, referencesFamilyToFamily, citedByOriginal, citedByFamilyToFamily}` counts |
| `nonPatentCitations` | Array of non-patent-literature citation strings (journal articles, standards docs) |
| `similarDocuments` | Array of `{publicationNumber, isPatent, title, publicationDate, url}` related/prior-art hits |
| `totalNumResults` | Total number of results for the search this patent came from |
| `resultPage` | Search result page this patent was found on |
| `scrapedAt` | ISO-8601 UTC timestamp of when the row was collected |
| `type` | Row type — `"patent"` for regular rows |

#### Patent identity and bibliographic fields

`patentNumber`, `title`, `abstract`, `inventors`, `assignee`, `filingDate`, `publicationDate`, `grantDate`, `priorityDate`, `language`, `docId`, `url`, `pdfUrl`, `thumbnailUrl`, `figures`, `classifications`.

#### Citation network and prior-art fields

`citations`, `citationNetwork`, `citationCounts`, `nonPatentCitations`, `similarDocuments`, `patentFamily`.

#### Full text and search-context fields

`fullText`, `rank`, `totalNumResults`, `resultPage`, `scrapedAt`, `type`.

#### 🤖 Add-on: Need additional research data?

Scraper-Engine doesn't currently have another patent-, IP-, or citation-network-specific scraper to pair this one with — this is the only Actor in the catalog covering Google Patents. If your research also touches other Google properties, Google Trends Scraper and Google Hotels Scraper are available in the same account for trend and travel-pricing data respectively.

### How does Google Patents & Citation Network Scraper differ from the official Google Patents API?

Google doesn't publish a keyword-in, JSON-out REST API for Google Patents — the closest official surface is Google Patents Public Data, distributed as bulk tables on Google Cloud BigQuery, which means a Google Cloud project with billing enabled and working SQL/BigQuery knowledge before you can run a single query.

| Feature | Google Patents Public Data (BigQuery) | Google Patents & Citation Network Scraper |
| --- | --- | --- |
| Access method | SQL queries against BigQuery tables | Apify Actor run, structured JSON out |
| Setup required | GCP account, billing enabled, BigQuery/SQL skills | Apify account, fill in the input form |
| Update cadence | Periodic bulk snapshot exports | Live scrape of patents.google.com at run time |
| Citation format | Publication-number references in relational tables, joins needed to expand them | Citations pre-expanded into full records, labeled examiner vs applicant, original vs family-to-family |
| Filtering | Custom SQL you write yourself | Built-in assignee, inventor, date-range, country, and document-kind filters — no SQL |
| Output format | BigQuery result table | Structured JSON, exportable as CSV/Excel |

Use BigQuery if you need bulk, warehouse-scale historical analysis and already have GCP/SQL infrastructure. Use Google Patents & Citation Network Scraper when you want current, citation-expanded JSON for a specific search, patent list, or ongoing monitoring run without setting up a data warehouse.

### How to use Google Patents & Citation Network Scraper

Google Patents & Citation Network Scraper runs as an Apify Actor — no separate signup or API onboarding beyond an Apify account.

1. Open the Actor's page on the Apify Store or in your Apify Console.
2. Provide at least one of `keywordQuery`, `patentLinksOrSearchLinks`, or `publicationNumbers` — the Actor needs one of these to know what to search for (nothing is returned if all three are empty).
3. Optionally narrow with `assigneeFilter`, `inventorFilter`, `patentOffice`, `publishedAfter`/`publishedBefore`, or `documentKind`, and toggle which enrichment fields you want (citation network, claims, family, classifications, similar documents).
4. Start the run.
5. Download the dataset as JSON or CSV, or stream it via the Apify API — the citation and similar-documents child datasets appear on the run's Storage tab when their toggles are on.

#### How to scale to bulk Google Patents extraction

Both `patentLinksOrSearchLinks` and `publicationNumbers` accept multiple lines in a single run — paste as many patent links or publication numbers as you need, and they're deduplicated and OR-merged automatically. `maxPatents` caps how many patents a single keyword/filter search expands into (set it to `0` for no cap). For genuinely separate keyword searches, run the Actor once per query rather than trying to combine unrelated searches in one `keywordQuery` value.

### What can you do with Google Patents data?

- A patent attorney doing freedom-to-operate work uses `citationNetwork` and `patentFamily` to map blocking prior art around a target technology before filing.
- An R\&D or competitive-intelligence analyst uses `assignee` and `classifications` to track which competitors are filing in a given CPC/IPC technology area.
- An IP due-diligence analyst valuing a portfolio uses `citationCounts.citedByOriginal` and `citedByFamilyToFamily` as a signal of how influential a given patent is.
- A prior-art searcher uses `similarDocuments` and `nonPatentCitations` to surface related patents and non-patent literature the examiner already considered.
- An AI engineer builds a patent-research assistant by feeding `title`, `abstract`, and `fullText.claims` into a vector store, letting an LLM agent answer prior-art questions grounded in real patent text instead of hallucinating citations.

### How does Google Patents & Citation Network Scraper handle rate limits and blocking?

Requests go out through a proxy ladder: direct first, then Apify's Datacenter proxy group, then Residential proxy, retrying up to three times per stage; once a stage succeeds, the run sticks with that proxy tier for subsequent requests. Concurrent HTTP connections are capped at 8, and a short randomized 1–2 second delay is added between sequential requests. The Actor does not solve CAPTCHAs. If a specific patent's detail page can't be fetched after the proxy ladder is exhausted, that patent is still saved with whatever bibliographic fields came from the search results, logged as having "limited detail," rather than failing the whole run.

### ⬇️ Input

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `patentLinksOrSearchLinks` | No | array | One entry per line: patent URLs, search URLs (with `q=`), or plain keywords. Plain lines are search phrases, OR-merged with `keywordQuery`. | `["https://patents.google.com/patent/US12438891B1", "citation network"]` |
| `keywordQuery` | No | string | Main keyword search. OR-merged with any `q=` terms from search URLs and with publication numbers. | `"neural network training"` |
| `publicationNumbers` | No | array | Specific publication numbers to pull the full citation network for. Combined with keywords using OR. | `["US11234567B2"]` |
| `assigneeFilter` | No | string | Focus on patents owned by a particular organization. | `"Acme Robotics, Inc."` |
| `inventorFilter` | No | string | Find patents listing a specific inventor. | `"Jane A. Doe"` |
| `patentOffice` | No | string (enum) | Country/office filter — `ANY` or one of 38 office codes (US, EP, WO, CN, JP, KR, DE, GB, FR, CA, AU, IN, BR, TW, RU, IT, ES, NL, SE, CH, AT, HK, SG, MX, NO, DK, FI, PL, IL, NZ, ZA, SA, AR, TH, MY, PH, ID, VN). | `"US"` |
| `publishedAfter` | No | string | Calendar date (`YYYY-MM-DD`) or relative range (e.g. `30 days`, `6 months`). Empty = no lower bound. | `"2020-01-01"` |
| `publishedBefore` | No | string | Same format as above. Empty = no upper bound. | `""` |
| `documentKind` | No | string (enum) | `ANY`, `PATENT` (granted), `APPLICATION`, or `DESIGN`. | `"PATENT"` |
| `maxPatents` | No | integer | Cap on how many patents to build a citation network for. `0` = no limit. | `10` |
| `includeCitationNetwork` | No | boolean | Adds backward/forward citations expanded into full records, labeled examiner- vs applicant-cited and original vs family-to-family; also fills the flat `citations` field and a `<runId>-citations` child dataset. | `true` |
| `maxCitationsPerGroup` | No | integer | Safety cap on expanded records built per citation group and per similar-document list. `0` = no cap. | `50` |
| `includeNonPatentLiteratureCitations` | No | boolean | Adds journal articles/standards/other non-patent citations as `nonPatentCitations`. | `true` |
| `includeSimilarDocuments` | No | boolean | Adds Similar Documents (related patents + Google-Scholar prior-art hits) as `similarDocuments` and a `<runId>-similar-documents` child dataset. | `true` |
| `includeFullDescription` | No | boolean | Adds the full written patent description text. | `false` |
| `includeClaimsText` | No | boolean | Adds the patent claims text. | `true` |
| `includeFamilyMembers` | No | boolean | Adds related publications in the same patent family. | `true` |
| `includeClassificationCodes` | No | boolean | Adds CPC/IPC classification codes. | `true` |
| `proxySettings` | No | object | Apify Proxy configuration. Leave the default if you don't need to change it. | `{"useApifyProxy": true}` |

#### Example input

```json
{
  "patentLinksOrSearchLinks": ["https://patents.google.com/patent/US12438891B1", "autonomous drone navigation"],
  "keywordQuery": "machine learning",
  "publicationNumbers": ["US11234567B2"],
  "assigneeFilter": "Acme Robotics, Inc.",
  "inventorFilter": "",
  "patentOffice": "US",
  "publishedAfter": "2019-01-01",
  "publishedBefore": "",
  "documentKind": "PATENT",
  "maxPatents": 25,
  "includeCitationNetwork": true,
  "maxCitationsPerGroup": 50,
  "includeNonPatentLiteratureCitations": true,
  "includeSimilarDocuments": true,
  "includeFullDescription": false,
  "includeClaimsText": true,
  "includeFamilyMembers": true,
  "includeClassificationCodes": true,
  "proxySettings": { "useApifyProxy": true }
}
```

### ⬆️ Output

Each patent is one typed JSON row in the default dataset, with a consistent field set regardless of which patent or search matched. Export the dataset as JSON, CSV, Excel, or the other formats Apify's dataset export supports. Once per run, a single `type: "searchSummary"` row (whole-result-set assignee/inventor/CPC facets) is also pushed to the default dataset — filter it out with `type === "patent"` if you only want per-patent rows, since it isn't a citation record. When `includeCitationNetwork` or `includeSimilarDocuments` is on, the run also writes to two separate named datasets, `<runId>-citations` and `<runId>-similar-documents`, visible on the run's Storage tab.

#### Example output

```json
{
  "patentNumber": "US11234567B2",
  "title": "Machine Learning System for Autonomous Navigation",
  "abstract": "A system and method for training a navigation model using sensor fusion data...",
  "inventors": ["Jane A. Doe", "Wei Chen"],
  "assignee": "Acme Robotics, Inc.",
  "filingDate": "2019-03-14",
  "publicationDate": "2022-02-01",
  "grantDate": "2022-02-01",
  "priorityDate": "2019-03-14",
  "language": "en",
  "docId": "abcdef123456",
  "rank": 1,
  "url": "https://patents.google.com/patent/US11234567B2",
  "pdfUrl": "https://patentimages.storage.googleapis.com/US11234567B2.pdf",
  "thumbnailUrl": "https://patentimages.storage.googleapis.com/thumb/US11234567B2-0.png",
  "figures": [
    { "thumbnailUrl": "https://patentimages.storage.googleapis.com/thumb/US11234567B2-0.png", "fullUrl": "https://patentimages.storage.googleapis.com/full/US11234567B2-0.png" }
  ],
  "classifications": { "cpc": ["G06N 3/08", "G05D 1/0221"], "ipc": ["G06N 3/08"] },
  "fullText": { "claims": "1. A method comprising: receiving sensor data from a plurality of..." },
  "patentFamily": ["EP3712345A1", "WO2020123456A1"],
  "citations": { "citedBy": ["US10987654B2"], "references": ["US9876543B1"] },
  "citationNetwork": {
    "references": {
      "original": [
        { "publicationNumber": "US9876543B1", "title": "Sensor Fusion for Robotics", "assignee": "Robotics Labs Inc.", "priorityDate": "2016-05-02", "publicationDate": "2018-01-09", "url": "https://patents.google.com/patent/US9876543B1", "citedBySource": "examiner" }
      ],
      "familyToFamily": []
    },
    "citedBy": {
      "original": [
        { "publicationNumber": "US10987654B2", "title": "Autonomous Drone Path Planning", "assignee": "SkyNet Dynamics", "priorityDate": "2020-06-11", "publicationDate": "2023-04-18", "url": "https://patents.google.com/patent/US10987654B2", "citedBySource": "applicant" }
      ],
      "familyToFamily": []
    }
  },
  "citationCounts": { "referencesOriginal": 1, "referencesFamilyToFamily": 0, "citedByOriginal": 1, "citedByFamilyToFamily": 0 },
  "nonPatentCitations": ["Smith et al., \"Deep Learning for Robotic Navigation\", IEEE Trans. Robotics, 2019"],
  "similarDocuments": [
    { "publicationNumber": "US20210123456A1", "isPatent": true, "title": "Vision-Based Obstacle Avoidance System", "publicationDate": "2021-05-06", "url": "https://patents.google.com/patent/US20210123456A1" }
  ],
  "totalNumResults": 4820,
  "resultPage": 0,
  "scrapedAt": "2026-07-25T14:02:11Z",
  "type": "patent"
}
```

### How does it work?

Google Patents & Citation Network Scraper calls the same internal search and result endpoints (`xhr/query`, `xhr/result`) that the patents.google.com web app itself uses, so it sees exactly what a visitor's browser sees. Requests start direct and automatically escalate through Apify's Datacenter and then Residential proxy groups if blocked, with small randomized delays between requests. Citation, similar-document, classification, and family data are all extracted from the same detail-page HTML already fetched for the base record, so enabling them adds no extra HTTP requests. Only publicly visible page content is ever returned — no login, cookies, or session state are used — and the output field names stay the same regardless of how Google redesigns the patents.google.com page layout.

### Integrations

Google Patents & Citation Network Scraper works wherever you can make an HTTP call or run an Apify Actor — no Google-specific SDK required.

#### Calling Google Patents & Citation Network Scraper programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("google-patents-and-citation-network-scraper").call(run_input={
    "keywordQuery": "autonomous navigation",
    "maxPatents": 25,
    "includeCitationNetwork": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

#### MCP integration for AI agents

Google Patents & Citation Network Scraper is reachable through Apify's Actors MCP Server, which exposes any Apify Actor as a callable MCP tool. Register it by running `npx -y @apify/actors-mcp-server --actors google-patents-and-citation-network-scraper` (with your `APIFY_TOKEN` set) and connect it as an MCP server in Claude Desktop, Claude Code, or any other MCP-compatible client — the Actor then appears as a tool the agent can call with `keywordQuery` or `publicationNumbers` directly.

#### No-code tools (n8n, Make, LangChain)

In **n8n**, use the HTTP Request node pointed at Apify's `run-sync-get-dataset-items` endpoint for this Actor, passing your search input as the request body. In **Make**, use the Apify app's "Run Actor and get dataset items" module and map your keyword or patent-number input into its input field. In **LangChain**, load results through the Apify dataset loader after a run completes, and pass each row's `abstract` and `fullText.claims` into your chain as document content.

### Is it legal to scrape Google Patents?

Yes — scraping publicly available Google Patents data, the kind visible to any visitor without logging in, is generally permissible, though Google's own Terms of Service place restrictions on automated access, so use is at your own discretion. Google Patents & Citation Network Scraper only returns publicly available data: patent numbers, titles, claims, assignees, inventors, and citations, all of which are part of the public patent record filed with a patent office — comparable to any other public legal or business filing rather than personal data scraped from a private profile, even though inventor names are technically personal names, because they appear as part of a public statutory record. Consult legal counsel if your use case involves bulk storage or redistribution of this data at scale.

### Frequently asked questions

#### What Google Patents fields does Google Patents & Citation Network Scraper return?

It returns `patentNumber`, `title`, `assignee`, `citationNetwork`, and `similarDocuments` per patent, along with full bibliographic, classification, and full-text fields. See [What data can I extract](#what-data-can-i-extract-with-google-patents--citation-network-scraper) above for the full field list.

#### Does Google Patents & Citation Network Scraper require a Google account or login?

No. It fetches Google Patents' own public search and detail-page endpoints over plain HTTP with no cookies or session — no Google account, password, or login of any kind is used.

#### How many patents can I extract in one run?

There's no hard ceiling in the input schema — `maxPatents` defaults to `10` and accepts any number, with `0` meaning no limit (be mindful of run time on very broad, uncapped searches, since each enriched patent requires its own detail-page fetch).

#### What happens if a patent number doesn't exist?

If a publication number in `publicationNumbers` doesn't resolve to a real patent, that entry is silently skipped and the run continues with any other numbers, keywords, or filters you provided. If none of your search criteria match anything at all, the run finishes with zero rows and logs "No patents matched your criteria" rather than erroring out.

#### Can I scrape multiple Google Patents at once?

Yes. `patentLinksOrSearchLinks` and `publicationNumbers` both accept multiple lines per run — every entry is deduplicated and OR-merged into a single search, so you don't need to loop runs for a batch of known patents.

#### How does the citation network actually work?

It's a real, one-hop citation extraction, not just a label: for each patent in your results, the Actor reads the backward-reference and forward-citation rows already present in that same patent's detail-page HTML (the same page the base fields come from), expands each cited/citing publication number into a full record (title, dates, assignee), and labels it examiner- vs applicant-cited and original vs family-to-family — all with zero extra HTTP requests. It does not recursively crawl citations-of-citations into a multi-hop graph; each patent's `citationNetwork` covers its own direct references and citers only. To follow the network further, run the Actor again against a specific citation's `publicationNumber`.

#### Does Google Patents & Citation Network Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes. It's callable as a standard HTTP API by any agent framework, and reachable through Apify's Actors MCP Server for MCP-compatible clients such as Claude.

#### Does Google Patents & Citation Network Scraper return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with consistent field names across runs — no HTML parsing or CSS selectors needed. Pass it directly to an LLM, index it in a vector store, or feed it to an agent tool.

#### What happens when Google Patents changes its layout or anti-bot system?

The Actor is maintained and its output schema is designed to stay stable across Google Patents layout changes. No specific fix turnaround time is promised.

#### Can I use Google Patents & Citation Network Scraper without managing proxies or browser infrastructure?

Yes. The Actor tries a direct request first and automatically escalates through Apify's Datacenter and Residential proxy groups on its own if blocked — you don't need to configure or rotate proxies yourself, though the `proxySettings` input lets you tune this if you want to.

#### Which Google Patents fields work best for AI training data and RAG indexing?

`abstract` and `fullText.claims` are the highest-information text fields for RAG indexing. `patentNumber`, `assignee`, `classifications`, and `citationCounts` are consistently structured across every record, making them well suited to training-data pipelines — all fields return as typed primitives (strings, arrays, and objects), with no HTML to strip.

### Related scrapers

| Scraper Name | What it extracts |
| --- | --- |
| Google Trends Scraper | Search-interest trend data from Google Trends |
| Google Hotels Scraper | Hotel listings and pricing data from Google Hotels |

Scraper-Engine doesn't currently have another patent- or IP-research-specific scraper — these are the account's other Google-platform data Actors.

### Your feedback

Found a bug or missing a field? Let us know through this Actor's Issues tab on Apify so we can take a look. Feedback like this directly shapes what gets fixed and added next.

# Actor input Schema

## `patentLinksOrSearchLinks` (type: `array`):

✅ One entry per line: patent URLs, search URLs (q=), or plain keywords (e.g. machine learning). Plain lines are search phrases. All entries OR-merge with the Keywords field. (Base-compatible alias of `urls`.)

## `keywordQuery` (type: `string`):

💡 Main keyword search. Works together with links: your text is OR-merged with any q= from search URLs and with publication numbers from patent links. (Base-compatible alias of `searchQuery`.)

## `publicationNumbers` (type: `array`):

📋 Specific patent IDs to pull the full citation network for. Combined with keywords using OR. (Base-compatible alias of `patentNumbers`.)

## `assigneeFilter` (type: `string`):

🏭 Focus on patents owned by a particular organization. (Base-compatible alias of `assignee`.)

## `inventorFilter` (type: `string`):

🧑‍🔬 Find patents listing a specific inventor. (Base-compatible alias of `inventor`.)

## `patentOffice` (type: `string`):

🗺️ Pick a country or office — or **Any** to search everywhere. (Base-compatible alias of `country`.)

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

⏳ Pick a **calendar date** or a **relative** range (e.g. *30 days*, *6 months*). Leave empty for no lower bound. (Base-compatible alias of `dateFrom`.)

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

⏳ Same as above — absolute or relative. Leave empty for no upper bound. (Base-compatible alias of `dateTo`.)

## `documentKind` (type: `string`):

📑 Limit to grants, applications, or designs — or **Any** for all types. (Base-compatible alias of `patentType`.)

## `maxPatents` (type: `integer`):

🎚️ Cap how many patents to build a citation network for. Use **0** for no limit (be mindful of run time). (Base-compatible alias of `maxResults`.)

## `includeCitationNetwork` (type: `boolean`):

↩️ Adds backward (references) and forward (cited-by) citations, each expanded into a FULL record — title, dates, assignee — and labeled examiner-cited vs applicant-cited, and original vs family-to-family. Also populates the base's flat `citations` field for backward compatibility, and pushes every expanded citation to a `<runId>-citations` child dataset. (Base-compatible alias of `includeCitations`.)

## `maxCitationsPerGroup` (type: `integer`):

🧮 Safety cap on how many expanded records to build per citation group (references/cited-by × original/family) and per similar-document list — some heavily-cited patents have 1,000+ forward citations. Use **0** for no cap.

## `includeNonPatentLiteratureCitations` (type: `boolean`):

📖 Adds journal articles / standards docs / other non-patent citations the base's citation regex silently drops, as their own `nonPatentCitations` field.

## `includeSimilarDocuments` (type: `boolean`):

🔎 Adds Similar Documents — related patents and Google-Scholar prior-art hits — as a `similarDocuments` field AND a second `<runId>-similar-documents` child dataset.

## `includeFullDescription` (type: `boolean`):

📜 Adds the full written description (large text). (Base-compatible alias of `includeFullText`.)

## `includeClaimsText` (type: `boolean`):

📋 Adds the patent claims text. (Base-compatible alias of `includeClaims`.)

## `includeFamilyMembers` (type: `boolean`):

🌍 Adds related publications in the same family. (Base-compatible alias of `includePatentFamily`.)

## `includeClassificationCodes` (type: `boolean`):

🧮 Adds classification codes for analytics and filtering. (Base-compatible alias of `includeClassifications`.)

## `proxySettings` (type: `object`):

🛟 Optional Apify Proxy settings. Leave default off if you don't need it. (Base-compatible alias of `proxyConfiguration`.)

## Actor input object example

```json
{
  "patentLinksOrSearchLinks": [
    "https://patents.google.com/patent/US12438891B1",
    "citation network"
  ],
  "publicationNumbers": [],
  "patentOffice": "ANY",
  "documentKind": "ANY",
  "maxPatents": 10,
  "includeCitationNetwork": true,
  "maxCitationsPerGroup": 50,
  "includeNonPatentLiteratureCitations": true,
  "includeSimilarDocuments": true,
  "includeClaimsText": true,
  "includeFamilyMembers": true,
  "includeClassificationCodes": true,
  "proxySettings": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped patent records (and the run's searchSummary row) in the Actor's default dataset.

# 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 = {
    "patentLinksOrSearchLinks": [
        "https://patents.google.com/patent/US12438891B1",
        "citation network"
    ],
    "keywordQuery": "",
    "publicationNumbers": [],
    "assigneeFilter": "",
    "inventorFilter": "",
    "patentOffice": "ANY",
    "publishedAfter": "",
    "publishedBefore": "",
    "documentKind": "ANY",
    "maxPatents": 10,
    "includeCitationNetwork": true,
    "maxCitationsPerGroup": 50,
    "includeNonPatentLiteratureCitations": true,
    "includeSimilarDocuments": true,
    "includeFullDescription": false,
    "includeClaimsText": true,
    "includeFamilyMembers": true,
    "includeClassificationCodes": true,
    "proxySettings": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/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 = {
    "patentLinksOrSearchLinks": [
        "https://patents.google.com/patent/US12438891B1",
        "citation network",
    ],
    "keywordQuery": "",
    "publicationNumbers": [],
    "assigneeFilter": "",
    "inventorFilter": "",
    "patentOffice": "ANY",
    "publishedAfter": "",
    "publishedBefore": "",
    "documentKind": "ANY",
    "maxPatents": 10,
    "includeCitationNetwork": True,
    "maxCitationsPerGroup": 50,
    "includeNonPatentLiteratureCitations": True,
    "includeSimilarDocuments": True,
    "includeFullDescription": False,
    "includeClaimsText": True,
    "includeFamilyMembers": True,
    "includeClassificationCodes": True,
    "proxySettings": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/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 '{
  "patentLinksOrSearchLinks": [
    "https://patents.google.com/patent/US12438891B1",
    "citation network"
  ],
  "keywordQuery": "",
  "publicationNumbers": [],
  "assigneeFilter": "",
  "inventorFilter": "",
  "patentOffice": "ANY",
  "publishedAfter": "",
  "publishedBefore": "",
  "documentKind": "ANY",
  "maxPatents": 10,
  "includeCitationNetwork": true,
  "maxCitationsPerGroup": 50,
  "includeNonPatentLiteratureCitations": true,
  "includeSimilarDocuments": true,
  "includeFullDescription": false,
  "includeClaimsText": true,
  "includeFamilyMembers": true,
  "includeClassificationCodes": true,
  "proxySettings": {
    "useApifyProxy": true
  }
}' |
apify call scraper-engine/google-patents-scraper --silent --output-dataset

```

## MCP server setup

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