# Patent Intelligence Tracker — Google Patents Search & Monitor (`gochujang/google-patents-scraper`) Actor

Search patents from Google Patents (150M+ docs). Filter by keyword, assignee, inventor, date, CPC code. Extract abstracts and claims. Track competitor IP, run FTO research, analyze patent portfolios. No API key required.

- **URL**: https://apify.com/gochujang/google-patents-scraper.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Education
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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

### What does Google Patents Scraper do?

**Google Patents Scraper** searches and extracts structured patent data from [Google Patents](https://patents.google.com) — covering 150M+ documents from the USPTO, EPO, WIPO, and 100+ national patent offices worldwide. Filter patents by keyword, assignee (company), inventor, publication date range, and **CPC classification code**. Optionally extract the full abstract and full claims text for each result. At the end of every run the actor delivers an analytics summary: top assignees, filings by year, top jurisdictions, and top CPC groups. No API key or Google account required.

This is the most accessible **patent data extractor** available — replacing enterprise patent intelligence platforms that charge $10,000–$20,000/year for the same underlying data, at $0.003 per patent.

***

### Why use Google Patents Scraper?

1. **Competitor R\&D monitoring** — Set `assignee` to a rival company and schedule daily runs to see exactly what they are patenting in real time. Track their technology bets before they announce product launches.
2. **Freedom-to-operate (FTO) research** — Search your product's technology area by keyword and CPC code, then pull full claims to identify blocking patents before you ship. This **USPTO patent search API** alternative returns the same underlying data at a fraction of the cost.
3. **Investment due diligence** — Evaluate a startup's patent moat by counting filings, reading claims, and checking assignee history across jurisdictions. Essential for IP-heavy sectors like biotech, semiconductors, and clean energy.
4. **Technology trend analysis** — Filter by CPC classification and read the year-over-year filing counts in the run summary to map the velocity of innovation in any technology domain.
5. **M\&A target identification** — Use the `top_assignees` summary to find the most prolific patent holders in a niche — identifying acquisition targets or licensing partners the market has not yet valued.

***

### How to use Google Patents Scraper

1. Open the Actor on Apify and click **Try for free**.
2. Provide at least one filter: `keywords`, `assignee`, `inventor`, or `cpcClassification`.
3. (Optional) Set `dateFrom` / `dateTo` to limit to a date window, and `maxResults` (up to 1,000).
4. Enable `includeAbstract: true` for full abstract text (default on). Enable `includeClaims: true` for full legal claims (slower, larger output).
5. Click **Start** — results appear in the dataset, plus a run-end analytics summary in the key-value store.
6. Export as JSON/CSV, or read via the Apify API. Schedule weekly runs for ongoing competitor monitoring.

***

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | string | — | Technology keyword search, e.g. `transformer neural network`, `solid state battery`. At least one of keywords / assignee / inventor / cpcClassification required. |
| `assignee` | string | — | **Company or organization** that owns the patents, e.g. `Apple`, `Moderna`, `Samsung`. |
| `inventor` | string | — | Inventor name, e.g. `Geoffrey Hinton`. |
| `dateFrom` | string | — | Publication date range start (`YYYY-MM-DD`). |
| `dateTo` | string | — | Publication date range end (`YYYY-MM-DD`). |
| `cpcClassification` | string | — | **CPC code** prefix, e.g. `G06N` (AI/ML), `A61K` (pharma), `H01M` (batteries), `H04L` (networking). |
| `maxResults` | integer | `100` | Maximum patents to return (1–1000). |
| `includeAbstract` | boolean | `true` | Fetch full abstract from each patent page. |
| `includeClaims` | boolean | `false` | Fetch full claims text (slower, larger output — for FTO and legal analysis). |
| `proxyConfiguration` | object | — | Optional Apify Proxy (residential). Enable only if rate-limited. |

***

### Output

Each patent is one dataset item:

```json
[
  {
    "patent_number": "US11126475B2",
    "title": "Systems and methods to use neural networks to transform a model into a neural network model",
    "assignees": ["DeepMind Technologies Limited"],
    "inventors": ["Jane Doe", "John Smith"],
    "priority_date": "2019-01-01",
    "filing_date": "2019-02-01",
    "grant_date": "2021-09-21",
    "publication_date": "2021-09-21",
    "countries": ["US", "EP", "CN"],
    "snippet": "…a neural network model that transforms legacy models into…",
    "abstract": "Systems and methods for transforming legacy models into neural network representations using learned transformation functions…",
    "cpc_codes": ["G06N3/08", "G06N3/04", "G06F9/541"],
    "pdf_url": "https://patentimages.storage.googleapis.com/…/US11126475B2.pdf",
    "patent_url": "https://patents.google.com/patent/US11126475B2/en",
    "source": "Google Patents"
  },
  {
    "patent_number": "EP3876198A1",
    "title": "Method for producing mRNA-based vaccine compositions",
    "assignees": ["Moderna TX, Inc."],
    "inventors": ["Katalin Karikó"],
    "publication_date": "2021-09-15",
    "countries": ["EP", "US", "WO"],
    "patent_url": "https://patents.google.com/patent/EP3876198A1/en",
    "source": "Google Patents"
  }
]
```

***

### Data fields

| Field | Example | Description |
|---|---|---|
| `patent_number` | `US11126475B2` | **Patent number** with kind code |
| `title` | `Systems and methods…` | Patent title |
| `assignees` | `["DeepMind…"]` | **Patent assignees** (current owners) |
| `inventors` | `["Jane Doe"]` | Listed inventors |
| `priority_date` | `2019-01-01` | Earliest priority date |
| `filing_date` | `2019-02-01` | Application filing date |
| `grant_date` | `2021-09-21` | Grant date (if granted) |
| `publication_date` | `2021-09-21` | Publication date |
| `countries` | `["US","EP","CN"]` | Jurisdictions in this patent family |
| `snippet` | `…neural network…` | Short text snippet from search results |
| `abstract` | Full text | Full abstract (when `includeAbstract: true`) |
| `claims` | Full text | Full legal claims (when `includeClaims: true`) |
| `cpc_codes` | `["G06N3/08"]` | **CPC classification codes** |
| `pdf_url` | `https://patentimages…` | Link to PDF download |
| `patent_url` | `https://patents.google.com/…` | Google Patents page URL |

***

### Cost estimation

**Pay-Per-Event pricing**

| Event | Price |
|---|---|
| Actor start (one-time per run) | $0.005 |
| Per patent returned | $0.003 |

| Run type | Patents | Estimated cost |
|---|---|---|
| Quick competitor scan | 50 | **$0.155** |
| Standard FTO search | 100 | **$0.305** |
| Technology landscape | 500 | **$1.505** |
| Full portfolio audit | 1,000 | **$3.005** |

**Cost comparison with commercial patent intelligence platforms:**

| Platform | Typical annual cost |
|---|---|
| Clarivate Derwent Innovation | $15,000+/year |
| PatSnap | $20,000+/year |
| Questel Orbit | $10,000+/year |
| **Google Patents Scraper** | **$0.003 per patent** |

1,000 patents for $3. No seats, no annual contract, no sales call.

***

### FAQ

**Does this require a Google account or API key?**
No. This **Google Patents scraper** queries the public `patents.google.com` search interface. No Google account, no API key, no registration. Run it immediately.

**How does this compare to the USPTO patent search API or EPO Open Patent Services?**
The **USPTO patent search API** and EPO OPS only cover their respective jurisdictions. Google Patents aggregates 150M+ documents from 100+ patent offices into one unified, deduplicated search index covering US, EP, WO, CN, JP, KR, and more — making it the most comprehensive single source for global patent intelligence. This actor exposes that index as a structured **patent data extractor** at $0.003 per result.

**Can I use this for legal freedom-to-operate (FTO) analysis?**
Yes, but with caveats. Enable `includeClaims: true` to pull the full legal claims text for each patent. Claims define the legal scope of the patent. The actor also returns all jurisdictions in each patent family so you know where protection applies. However, FTO analysis for legal purposes should always be reviewed by a qualified patent attorney — this tool accelerates research, not legal opinion.

> **Disclaimer:** This actor extracts publicly available data from Google Patents. It is not affiliated with, endorsed by, or operated by Google LLC. Patent data is provided for research and informational purposes only. For legal freedom-to-operate opinions, consult a qualified patent attorney.

***

### Related actors

- [SEC EDGAR Filing Tracker](https://apify.com/gochujang/sec-edgar-tracker) — Regulatory filings intelligence
- [Insider Trading Tracker](https://apify.com/gochujang/insider-trading-tracker) — Executive stock transaction signals

**Keywords:** Google Patents scraper, patent data extractor, USPTO patent search API, patent intelligence tracker, competitor R\&D monitoring, freedom-to-operate research, FTO patent search, patent portfolio analysis, CPC classification search, IP research tool, patent landscape analysis

# Actor input Schema

## `keywords` (type: `string`):

Technology keywords to search in patent text (e.g. 'transformer neural network', 'mRNA vaccine'). Combined with the other filters using AND.

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

Filter by the patent owner/assignee (e.g. 'Apple', 'Google', 'Moderna'). Tracks a competitor's portfolio.

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

Filter by inventor name (e.g. 'Geoffrey Hinton').

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

Only patents published/granted on or after this date (YYYY-MM-DD).

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

Only patents published/granted on or before this date (YYYY-MM-DD).

## `cpcClassification` (type: `string`):

Cooperative Patent Classification code filter (e.g. 'G06N' for AI/ML, 'A61K' for pharma, 'H04L' for networking).

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

Maximum number of patent records to return.

## `includeAbstract` (type: `boolean`):

Fetch the full patent abstract from each patent page. A search-result snippet is always included regardless.

## `includeClaims` (type: `boolean`):

Fetch the full claims text from each patent page (much larger response, slower).

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

Optional proxy. Google Patents may rate-limit direct traffic; enable Apify Proxy (residential) if you encounter blocks.

## Actor input object example

```json
{
  "keywords": "",
  "assignee": "",
  "inventor": "",
  "dateFrom": "",
  "dateTo": "",
  "cpcClassification": "",
  "maxResults": 100,
  "includeAbstract": true,
  "includeClaims": false,
  "proxyConfiguration": {}
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/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 = {}

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

```

## MCP server setup

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