# Google Patents & Assignee Portfolio Scraper (`api-empire/google-patents-scraper`) Actor

🔎 Google Patents Scraper (google-patents-scraper) extracts structured patent data from Google Patents—titles, abstracts, inventors, assignees, CPC, claims, citations, priority dates & PDF links. ⚙️ Ideal for IP research, competitive intel & R\&D. Export to CSV/JSON for analysis. 🚀

- **URL**: https://apify.com/api-empire/google-patents-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 0 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/platform/actors/running/actors-in-store#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 — Extract Patents, Portfolios & Citations

Google Patents & Assignee Portfolio Scraper pulls a company's or inventor's entire patent portfolio from Google Patents in one run, returning typed JSON for every patent, plus a per-container portfolio summary and a whole-corpus search summary. No HTML, no selectors — every response is normalized JSON with stable field names, ready to drop into a spreadsheet, database, or LLM pipeline. After a run, you'll have a full list of a company's or inventor's patents, their legal status and ownership history, and aggregate stats on filing activity and classification codes.

### What is Google Patents & Assignee Portfolio Scraper?

Google Patents & Assignee Portfolio Scraper is an Apify Actor that queries `patents.google.com` for a named company, a named inventor, keywords, publication numbers, or direct patent/search links, and returns structured records for every matching patent. It requires no Google account and no login — Google Patents itself is a public index. Beyond a standard keyword search, this variant adds a dedicated portfolio-container mode that pages through every result for a given assignee or inventor instead of stopping at a small default page count.

- Scrape a company's or inventor's full patent portfolio, not just a capped keyword search
- Collect per-patent details: title, abstract, inventors, dates, classifications, citations, patent family, and full claims/description text on request
- Track ownership history with `originalAssignee` / `currentAssignee` / `ownershipChanged` per patent
- Get one portfolio-level summary row per run (filings by year, active-vs-expired ratio, top CPC codes)
- Export results as JSON, CSV, Excel, or any format Apify's dataset supports — no proxy setup required

### What data does Google Patents & Assignee Portfolio Scraper collect?

The Actor returns three distinct row types in the same dataset: individual patent records, one portfolio-level summary row per run, and one whole-corpus search-summary row per run.

| Data Type | Key Fields | JSON Field Names |
| --- | --- | --- |
| Patents | patent number, title, abstract, inventors, dates, legal status | `patentNumber`, `title`, `abstract`, `inventors`, `filingDate`, `publicationDate`, `legalStatus`, `isActive` |
| Ownership & ownership history | original vs. current assignee, ownership-change flag | `originalAssignee`, `currentAssignee`, `ownershipChanged` |
| Citations, family & classifications | backward/forward citations, patent family, CPC/IPC codes | `citations.citedBy`, `citations.references`, `patentFamily`, `classifications.cpc` |
| Portfolio summary (one row per run) | patents by year, active/expired ratio, top CPC codes | `patentCountByYear`, `activeVsExpiredRatio`, `topCpcCodes` |
| Search summary (one row per run) | whole-result-set facets: top assignees, inventors, related landscapes | `topAssignees`, `topInventors`, `relatedLandscapes` |

#### Need more Google Patents data?

Google Patents & Assignee Portfolio Scraper is currently the only Google Patents Actor published under this account. If you need a different slice of Google Patents data — a lighter, keyword-only scraper without the portfolio and ownership features — check the Apify Store for other Google Patents listings rather than assuming one exists here.

### Why not build this yourself?

Google doesn't publish a simple, free, general-purpose API for arbitrary Google Patents lookups. Google Patents Public Datasets exist on BigQuery for bulk analytical queries, and USPTO and EPO each publish their own APIs — but those only cover their own jurisdiction's filings, not a unified live lookup across assignees, inventors, and countries the way `patents.google.com`'s own search does. Building that yourself means reverse-engineering Google's internal query and detail endpoints, maintaining HTML parsers as markup shifts, and running a proxy ladder to stay online — all before you write a single line of analysis code. Google Patents & Assignee Portfolio Scraper already does this: it handles the query building, pagination, per-patent enrichment, and proxy fallback, and returns a stable JSON schema on the other end.

### Why do developers and teams scrape Google Patents?

#### For IP and legal teams

Patent attorneys, paralegals, and licensing teams use this data for prior-art searches, freedom-to-operate checks, and IP due diligence ahead of an acquisition or investment. A common workflow: set `portfolioAssignee` to the target company, enable `includeOwnershipSplit`, and filter by `jurisdiction`, then review `legalStatus` and `ownershipChanged` across the full portfolio to see how many patents are still active and whether any have already changed hands — a signal of past licensing or M\&A activity.

#### For R\&D and competitive intelligence teams

R\&D and competitive-intelligence teams track a competitor's filing cadence and technology focus over time. Setting `portfolioInventor` or `portfolioAssignee` with `fetchClassifications` on returns CPC/IPC codes per patent, and the run's `portfolioSummary` row aggregates `topCpcCodes` and `patentCountByYear` — enough to see whether a competitor's R\&D investment in a technology area is growing, shrinking, or shifting, without manually reading hundreds of individual filings.

#### For patent analytics and data teams

Teams building internal patent-analytics tools or dashboards use the structured `patentCountByYear`, `activeVsExpiredRatio`, and `topCpcCodes` fields directly as pipeline inputs, skipping the parsing step entirely. Because every run also returns a `searchSummary` row with whole-result-set facets (`topAssignees`, `topInventors`, `relatedLandscapes`), analysts can layer portfolio-level and corpus-level views from a single dataset rather than stitching together separate queries.

#### For AI engineers and agent builders

AI and RAG builders index patent text — `title`, `abstract`, and, when `fetchFullDescription`/`fetchClaims` are enabled, the full `fullText.description` and `fullText.claims` — into a vector store for patent-search copilots or due-diligence agents. Because every field is typed JSON with stable names, an agent can call this Actor as a tool, receive a company's portfolio, and reason over `legalStatus`, `citations`, and `patentFamily` without a parsing step between the scrape and the LLM context window.

### How to scrape Google Patents (step by step)

1. Open Google Patents & Assignee Portfolio Scraper on the Apify Store or in the Apify Console and start a new run — no Google account is required.
2. Enter a `portfolioAssignee` (company name) or `portfolioInventor` (inventor name) to pull a full portfolio, or use `keywordSearch`, `publicationIds`, or `patentLinks` for a plain search instead.
3. Narrow the results with `jurisdiction`, `publishedAfter`/`publishedBefore`, and `documentKind`, and toggle the per-patent enrichment fields (`fetchClaims`, `fetchCitations`, `fetchPatentFamily`, `fetchClassifications`, `fetchFullDescription`) you need.
4. Click Start to run the Actor.
5. Download results as JSON, CSV, or Excel from the dataset, or pull them programmatically via the Apify API.

#### What to do when Google Patents changes its structure

The Actor is actively maintained, and its output schema is kept stable — field names and types stay the same on your end even when Google Patents changes its markup internally, so downstream integrations keep working without changes.

### ⬇️ Input

No single field is strictly required by the schema, but the run needs at least one of `portfolioAssignee`, `portfolioInventor`, `keywordSearch`, `publicationIds`, or `patentLinks` to resolve to a real query — otherwise the run stops immediately with an error instead of returning results.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `portfolioAssignee` | No | string | Company/organization name; pulls every patent assigned to it (legacy key: `assignee`) | `"Splunk"` |
| `portfolioInventor` | No | string | Inventor name; pulls every patent listing them (legacy key: `inventor`) | `""` |
| `fullPortfolioMode` | No | boolean | When on (default), pages through every result for the container above instead of stopping at a small default | `true` |
| `maxPortfolioSize` | No | integer | Safety cap on patents collected; `0` = entire portfolio (legacy key: `maxResults`) | `40` |
| `patentLinks` | No | array | Patent URLs, search URLs, or plain keyword lines, one per entry (legacy key: `urls`) | `[]` |
| `keywordSearch` | No | string | Keyword search, OR-merged with the portfolio container and any links (legacy key: `searchQuery`) | `""` |
| `publicationIds` | No | array | Specific patent publication numbers to include (legacy key: `patentNumbers`) | `[]` |
| `jurisdiction` | No | string (enum) | Patent office/country filter; also the reference country for `legalStatus` (legacy key: `country`) | `"US"` |
| `publishedAfter` | No | string | Absolute date (`YYYY-MM-DD`) or relative range (e.g. `30 days`) (legacy key: `dateFrom`) | `"2020-01-01"` |
| `publishedBefore` | No | string | Absolute or relative date, same format as above (legacy key: `dateTo`) | `""` |
| `documentKind` | No | string (enum) | Limit to granted patents, applications, designs, or any (legacy key: `patentType`) | `"PATENT"` |
| `fetchFullDescription` | No | boolean | Add the full written description | `false` |
| `fetchClaims` | No | boolean | Add the patent claims text | `true` |
| `fetchCitations` | No | boolean | Add backward/forward citation lists | `true` |
| `fetchPatentFamily` | No | boolean | Add related publications in the same patent family | `true` |
| `fetchClassifications` | No | boolean | Add CPC/IPC classification codes; also feeds the portfolio's top CPC stat | `true` |
| `includeOwnershipSplit` | No | boolean | Add `originalAssignee`/`currentAssignee`/`ownershipChanged` per patent (default on) | `true` |
| `includePortfolioStats` | No | boolean | Add the one-row-per-run portfolio summary (default on) | `true` |
| `connectionSettings` | No | object | Apify Proxy configuration (legacy key: `proxyConfiguration`) | `{"useApifyProxy": true}` |

Example JSON input:

```json
{
  "portfolioAssignee": "Splunk",
  "portfolioInventor": "",
  "fullPortfolioMode": true,
  "maxPortfolioSize": 40,
  "patentLinks": [],
  "keywordSearch": "",
  "publicationIds": [],
  "jurisdiction": "US",
  "publishedAfter": "2020-01-01",
  "publishedBefore": "",
  "documentKind": "PATENT",
  "fetchFullDescription": false,
  "fetchClaims": true,
  "fetchCitations": true,
  "fetchPatentFamily": true,
  "fetchClassifications": true,
  "includeOwnershipSplit": true,
  "includePortfolioStats": true,
  "connectionSettings": { "useApifyProxy": true }
}
```

The most common input mistake is leaving `portfolioAssignee`, `portfolioInventor`, `keywordSearch`, `publicationIds`, and `patentLinks` all blank — the run has no query to resolve and exits immediately rather than returning an empty dataset.

### ⬆️ Output

Every run writes to one Apify dataset containing typed, normalized JSON — exportable as JSON, CSV, or Excel. Three row shapes can appear, distinguished by their `type` field: `"patent"` (one per matched patent, billed per row), `"portfolioSummary"` (one per run, free), and `"searchSummary"` (one per run, free). Only `"patent"` rows are charged under the `row_result` event; filter a downloaded dataset on `item.type === "patent"` if you want to isolate billable records from the two summary rows.

#### Scraped patent

```json
{
  "type": "patent",
  "patentNumber": "US10110617B2",
  "title": "Systems and methods for detecting anomalous network activity",
  "abstract": "A system for identifying anomalous network activity based on baseline traffic patterns...",
  "inventors": ["Jane Doe", "John Smith"],
  "assignee": "Splunk Inc",
  "filingDate": "2016-03-14",
  "publicationDate": "2018-10-23",
  "grantDate": "2018-10-23",
  "classifications": { "cpc": ["H04L63/1425"], "ipc": ["H04L 63/1425"] },
  "url": "https://patents.google.com/patent/US10110617B2",
  "pdfUrl": "https://patentimages.storage.googleapis.com/pdfs/US10110617B2.pdf",
  "scrapedAt": "2026-07-25T09:12:03Z",
  "citations": { "citedBy": ["US10999999B2"], "references": ["US8990888B2"] },
  "priorityDate": "2016-03-14",
  "language": "en",
  "docId": "abcdef123456",
  "rank": 3,
  "thumbnailUrl": "https://patentimages.storage.googleapis.com/thumbs/US10110617B2-thumb.png",
  "figures": [{ "thumbnailUrl": "https://patentimages.storage.googleapis.com/thumbs/fig1.png", "fullUrl": "https://patentimages.storage.googleapis.com/full/fig1.png" }],
  "totalNumResults": 214,
  "resultPage": 0,
  "legalStatus": { "countryCode": "US", "state": "ACTIVE", "isActive": true },
  "isActive": true,
  "originalAssignee": "Splunk Inc",
  "currentAssignee": "Cisco Technology Inc",
  "ownershipChanged": true,
  "fullText": { "description": "The present disclosure relates to...", "claims": "1. A method comprising..." },
  "patentFamily": ["US10110617B2", "WO2017160823A1"]
}
```

#### Portfolio summary

One row per run, added when a `portfolioAssignee`/`portfolioInventor` container is set and `includePortfolioStats` is on:

```json
{
  "type": "portfolioSummary",
  "portfolioAssignee": "Splunk",
  "portfolioInventor": null,
  "scrapedAt": "2026-07-25T09:14:41Z",
  "totalPortfolioSize": 214,
  "collectedCount": 214,
  "portfolioCoverageNote": null,
  "patentCountByYear": { "2018": 12, "2019": 18, "2020": 21 },
  "activeCount": 178,
  "expiredCount": 22,
  "unknownLegalStatusCount": 14,
  "activeVsExpiredRatio": 0.89,
  "topCpcCodes": [{ "code": "H04L63/1425", "count": 34 }, { "code": "G06F21/55", "count": 21 }]
}
```

#### Search summary

One free row per run, built from Google's own whole-result-set facets on the first results page:

```json
{
  "type": "searchSummary",
  "patentNumber": null,
  "totalNumResults": 214,
  "summarySampleSize": 214,
  "topAssignees": [{ "name": "Splunk Inc", "count": 214 }, { "name": "Cisco Technology Inc", "count": 46 }],
  "topAssigneesText": "Splunk Inc (214), Cisco Technology Inc (46)",
  "topInventors": [{ "name": "Jane Doe", "count": 9 }],
  "topInventorsText": "Jane Doe (9)",
  "topCpcCodes": [{ "code": "H04L63/1425", "count": 34 }],
  "topCpcCodesText": "H04L63/1425 (34)",
  "relatedLandscapes": [{ "name": "Network security", "type": "technology" }],
  "relatedLandscapesText": "Network security",
  "scrapedAt": "2026-07-25T09:12:00Z"
}
```

### How many results can you scrape with Google Patents & Assignee Portfolio Scraper?

There's no hard cap coded into the Actor itself — `maxPortfolioSize` sets the ceiling, and `0` means collect the entire portfolio. When a company or inventor container is set with `fullPortfolioMode` on and no explicit cap given, the Actor defaults internally to unlimited (0); a plain keyword search with no container defaults to 10 unless you raise it. Pagination continues page by page until either your cap is hit or Google Patents stops returning results for that query.

Google Patents' own search index still limits how many results any single query can page through before it plateaus — very large portfolios (thousands of patents) may not be fully retrievable in one query. When that happens, the `portfolioSummary` row's `portfolioCoverageNote` reports the shortfall honestly (collected vs. total indexed), and narrowing by date range or jurisdiction pages deeper into a large portfolio.

### Integrate Google Patents & Assignee Portfolio Scraper and automate your workflow

Google Patents & Assignee Portfolio Scraper works with any language or tool that can send an HTTP request.

#### REST API integration

```python
import requests

TOKEN = "YOUR_APIFY_API_TOKEN"
ACTOR_ID = "YOUR_USERNAME~google-patents-and-assignee-portfolio-scraper"

resp = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR_ID}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={"portfolioAssignee": "Splunk", "jurisdiction": "US"},
    timeout=300,
)
resp.raise_for_status()
for row in resp.json():
    if row.get("type") == "patent":
        print(row["patentNumber"], row["title"])
```

Works in Python, Node.js, Go, Ruby, cURL.

#### MCP for AI agents

This Actor can be exposed as a callable tool through Apify's own MCP Server, which lets MCP-compatible clients (such as Claude Desktop or Cursor) run any Apify Actor and read its dataset directly inside an agent loop, without a separate scraping or parsing step.

#### Automation platforms (n8n, Make)

In n8n, the official Apify node's "Run Actor and Get Dataset Items" operation can call this Actor by its Actor ID and pass the same input JSON shown above. In Make, the Apify app's "Run Actor" module does the same — trigger it on a schedule to re-check a company's portfolio for new filings, and route the output straight into a downstream module (a spreadsheet, CRM, or database) without writing any parsing code.

### Is it legal to scrape Google Patents?

Yes. Google Patents & Assignee Portfolio Scraper only returns data that is already publicly published — granted patents and published applications are public records that patent offices are legally required to disclose, and Google Patents republishes that same public index. This falls under standard terms-of-service and database-rights considerations rather than GDPR, since the underlying records are official government filings, not incidental personal data collection — even where a patent's `inventors` field names a real person, that name is part of the patent's own mandated public disclosure. Use the data in line with Google's terms of service, and consult legal counsel before any commercial use involving bulk personal-name data.

### Frequently asked questions

#### Does Google Patents & Assignee Portfolio Scraper work without a Google account?

Yes. Google Patents is a public index with no login wall, so the Actor needs no Google credentials — only an Apify account to run it.

#### How often is the scraped data updated?

Every run fetches live from `patents.google.com` at request time; nothing is served from a cache, so each run reflects Google Patents' current index for that query.

#### What happens if a search or portfolio container returns no patents?

The Actor logs "No patents matched your criteria" and finishes with an empty dataset rather than erroring out — check that the assignee/inventor name is spelled as Google Patents indexes it, or broaden the `jurisdiction`/date filters.

#### Can I scrape private or restricted patent content?

No, and there generally isn't any to scrape — Google Patents only indexes granted patents and published applications, which are public by law. The Actor cannot access unpublished or withdrawn applications because Google Patents itself doesn't expose them.

#### Does Google Patents & Assignee Portfolio Scraper work for AI agent workflows and LLM pipelines?

Yes. It's callable as an HTTP endpoint by any agent framework, and it's also reachable through Apify's MCP Server for MCP-compatible clients. Every response is typed JSON with stable field names, so it can be passed directly into an LLM context window or a vector store without a parsing step.

#### How does Google Patents & Assignee Portfolio Scraper handle Google Patents' anti-bot system?

Requests go through a proxy ladder — direct first, then an Apify datacenter proxy, then Apify residential proxy — retrying and switching to whichever tier last succeeded. Requests are spaced with small randomized delays, and detail-page enrichment is capped to a handful of concurrent requests at a time to stay under Google Patents' own request tolerance.

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

Yes. Every row is typed, normalized JSON with stable field names — no HTML, no selectors. You can pass it straight into an LLM context window, index it into a vector store, or route it through an agent tool call.

#### Can I use Google Patents & Assignee Portfolio Scraper without managing proxies?

Yes. Apify Proxy is used automatically behind the scenes with a built-in retry ladder; the optional `connectionSettings` input only needs to be touched if you want to customize the default proxy behavior.

#### What's the difference between the patent, portfolioSummary, and searchSummary rows?

Each `type` value marks a different row shape in the same dataset: `"patent"` rows are individual matched patents (the billable rows), `"portfolioSummary"` is one free aggregate row scoped to the assignee/inventor container you searched, and `"searchSummary"` is one free aggregate row over the whole result set Google Patents returned for the query.

#### What happens when Google Patents changes its structure or blocks the scraper?

The Actor is actively maintained, and its output schema stays stable on your end — field names and types don't change even when Google Patents' internal markup does, so downstream integrations keep working without modification.

### Your feedback

Found a bug or missing a field? We want to know. Use the Issues tab on this Actor's Apify Store page to report it or request a feature — active issue tracking is how this Actor stays maintained against Google Patents' changes.

# Actor input Schema

## `portfolioAssignee` (type: `string`):

🏭 Pulls every patent assigned to this organization. Same as the base actor's `assignee` field, renamed for this portfolio-focused variant (a legacy `assignee` value in your input JSON still works).

## `portfolioInventor` (type: `string`):

🧑‍🔬 Pulls every patent listing this inventor. Same as the base actor's `inventor` field, renamed here (a legacy `inventor` value still works).

## `fullPortfolioMode` (type: `boolean`):

🔁 When ON (default) and a company/inventor is set above, the run pages through EVERY result Google Patents exposes for that container instead of stopping at a small default - only an explicit 'Max patents' cap below limits it.

## `maxPortfolioSize` (type: `integer`):

🎚️ Safety cap on how many patents to collect. Use **0** to collect the whole portfolio (Google Patents' own search index still limits how deep any single query can page). Same role as the base actor's `maxResults` (a legacy `maxResults` value still works) - note the DEFAULT here is 0/unlimited for a company or inventor container, vs. the base's default of 10 for a plain keyword search.

## `patentLinks` (type: `array`):

✅ One entry per line: patent URLs, search URLs (q=), or plain keywords. Same as the base actor's `urls` field, renamed here (a legacy `urls` value still works).

## `keywordSearch` (type: `string`):

💡 Optional keyword search, OR-merged with the portfolio container and any links above. Same as the base actor's `searchQuery` field, renamed here (a legacy `searchQuery` value still works).

## `publicationIds` (type: `array`):

📋 Specific patent IDs to include. Same as the base actor's `patentNumbers` field, renamed here (a legacy `patentNumbers` value still works).

## `jurisdiction` (type: `string`):

🗺️ Pick a country or office - or **Any**. Also chooses the reference country used for the per-patent `legalStatus` (active/expired) field. Same as the base actor's `country` field, renamed here (a legacy `country` value still works).

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

⏳ Calendar date or relative range (e.g. *30 days*, *6 months*). Same as the base actor's `dateFrom` field, renamed here (a legacy `dateFrom` value still works).

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

⏳ Same as above - absolute or relative. Same as the base actor's `dateTo` field, renamed here (a legacy `dateTo` value still works).

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

📑 Limit to grants, applications, or designs. Same as the base actor's `patentType` field, renamed here (a legacy `patentType` value still works).

## `fetchFullDescription` (type: `boolean`):

📜 Adds the full written description. Same as the base actor's `includeFullText` (a legacy value still works).

## `fetchClaims` (type: `boolean`):

📋 Adds the patent claims text. Same as the base actor's `includeClaims` (a legacy value still works).

## `fetchCitations` (type: `boolean`):

↩️ Adds backward/forward citation lists. Same as the base actor's `includeCitations` (a legacy value still works).

## `fetchPatentFamily` (type: `boolean`):

🌍 Adds related publications in the same family. Same as the base actor's `includePatentFamily` (a legacy value still works).

## `fetchClassifications` (type: `boolean`):

🧮 Adds classification codes - also feeds the portfolio's Top CPC codes stat. Same as the base actor's `includeClassifications` (a legacy value still works).

## `includeOwnershipSplit` (type: `boolean`):

🏛️ Adds `originalAssignee`/`currentAssignee`/`ownershipChanged` per patent, parsed from the same detail page already fetched above (no extra request when any enrichment toggle is on).

## `includePortfolioStats` (type: `boolean`):

🧾 Adds ONE extra dataset row (`type: portfolioSummary`) per run with patent-count-by-year, active-vs-expired ratio, and top CPC codes for the company/inventor container above.

## `connectionSettings` (type: `object`):

🛟 Optional Apify Proxy settings. Same as the base actor's `proxyConfiguration` (a legacy value still works).

## Actor input object example

```json
{
  "portfolioAssignee": "Splunk",
  "fullPortfolioMode": true,
  "maxPortfolioSize": 40,
  "patentLinks": [],
  "publicationIds": [],
  "jurisdiction": "ANY",
  "documentKind": "ANY",
  "fetchClaims": true,
  "fetchCitations": true,
  "fetchPatentFamily": true,
  "fetchClassifications": true,
  "includeOwnershipSplit": true,
  "includePortfolioStats": true,
  "connectionSettings": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "portfolioAssignee": "Splunk",
    "portfolioInventor": "",
    "maxPortfolioSize": 40,
    "patentLinks": [],
    "keywordSearch": "",
    "publicationIds": [],
    "jurisdiction": "ANY",
    "publishedAfter": "",
    "publishedBefore": "",
    "documentKind": "ANY",
    "fetchFullDescription": false,
    "fetchClaims": true,
    "fetchCitations": true,
    "fetchPatentFamily": true,
    "fetchClassifications": true,
    "connectionSettings": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/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 = {
    "portfolioAssignee": "Splunk",
    "portfolioInventor": "",
    "maxPortfolioSize": 40,
    "patentLinks": [],
    "keywordSearch": "",
    "publicationIds": [],
    "jurisdiction": "ANY",
    "publishedAfter": "",
    "publishedBefore": "",
    "documentKind": "ANY",
    "fetchFullDescription": False,
    "fetchClaims": True,
    "fetchCitations": True,
    "fetchPatentFamily": True,
    "fetchClassifications": True,
    "connectionSettings": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("api-empire/google-patents-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "portfolioAssignee": "Splunk",
  "portfolioInventor": "",
  "maxPortfolioSize": 40,
  "patentLinks": [],
  "keywordSearch": "",
  "publicationIds": [],
  "jurisdiction": "ANY",
  "publishedAfter": "",
  "publishedBefore": "",
  "documentKind": "ANY",
  "fetchFullDescription": false,
  "fetchClaims": true,
  "fetchCitations": true,
  "fetchPatentFamily": true,
  "fetchClassifications": true,
  "connectionSettings": {
    "useApifyProxy": true
  }
}' |
apify call api-empire/google-patents-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=api-empire/google-patents-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/oMnp1dvJPeEIQNsRb/builds/65wMyZPgJi7A4avmN/openapi.json