# Google Patents Scraper    Claims Inventors Citations 1 (`scrapepilot/google-patents-scraper----claims-inventors-citations-1`) Actor

Scrape complete patent data from Google Patents. Returns full claims text, abstract, inventors, applicants, IPC/CPC classifications, filing dates, legal status and citation counts. Search by patent ID, keyword, assignee or inventor. RESIDENTIAL proxy included.

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

## Pricing

from $7.00 / 1,000 patent result scrapeds

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Patent Data, Claims, Inventors & Classifications

> **The most complete Google Patents Scraper on Apify.** Extract full patent records from Google Patents — title, abstract, claims, inventors, assignees, filing dates, IPC/CPC classifications, legal status, citation counts, and patent family data. Search by keyword, assignee, inventor, or country. No API key required.

---

> 🆓 **Try FREE for 2 hours** — no credit card needed. Then just **$8.99/month** for unlimited Google Patents scraping — by patent ID, keyword search, assignee, inventor, or country.

---

### 📌 Table of Contents

- [What Is This Actor?](#what-is-this-actor)
- [Why This Is the Best Google Patents Scraper](#why-this-is-the-best-google-patents-scraper)
- [💰 Pricing](#-pricing)
- [2 Scraping Modes](#2-scraping-modes)
- [Use Cases](#use-cases)
- [Output Fields (Full Reference)](#output-fields-full-reference)
- [Input Parameters](#input-parameters)
- [Example Inputs & Outputs](#example-inputs--outputs)
- [How the Google Patents Scraper Works](#how-the-google-patents-scraper-works)
- [Search Filters Guide](#search-filters-guide)
- [Patent ID Formats](#patent-id-formats)
- [IPC & CPC Classification Guide](#ipc--cpc-classification-guide)
- [Proxy Configuration](#proxy-configuration)
- [Performance & Speed](#performance--speed)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Terms of Use](#legal--terms-of-use)

---

### 🔍 What Is This Actor?

**Google Patents Scraper** is a production-grade Apify actor that extracts complete patent records from [Google Patents](https://patents.google.com) — the world's largest free patent search engine covering patents from the USPTO, EPO, WIPO, and dozens of national patent offices worldwide.

This Google Patents scraper supports two input modes: provide **specific patent IDs** (US10000000B2, EP1234567A1, etc.) for full detail extraction, or provide a **search query** with optional filters (assignee, inventor, country, date range) to discover and extract matching patents at scale.

Every patent record returned by this Google Patents scraper includes the complete set of structured fields: patent title, abstract, full claims text, description excerpt, inventors list, applicants and assignees, filing date, publication date, priority date, legal status (active/expired/pending), IPC and CPC classification codes, citation counts, patent family members, and country of origin.

Whether you are an IP attorney building a prior art database, a corporate IP team monitoring competitor patent activity, a researcher studying technology trends, or a developer integrating patent data into a product — this Google Patents scraper delivers enterprise-grade data with no API key and no per-query fees.

---

### 🚀 Why This Is the Best Google Patents Scraper

| Feature | This Actor | Google Patents API (via BigQuery) | Lens.org | Derwent / Clarivate |
|---|---|---|---|---|
| **No API key required** | ✅ | ❌ GCP account needed | ✅ | ❌ |
| **Full claims text** | ✅ | ✅ | ⚠️ Limited | ✅ |
| **Full abstract** | ✅ | ✅ | ✅ | ✅ |
| **IPC + CPC classifications** | ✅ Both | ✅ | ✅ | ✅ |
| **Legal status** | ✅ | ✅ | ✅ | ✅ |
| **Patent family data** | ✅ | ✅ | ✅ | ✅ |
| **Citation counts** | ✅ | ✅ | ✅ | ✅ |
| **Assignee search** | ✅ Built-in | ✅ | ✅ | ✅ |
| **Inventor search** | ✅ Built-in | ✅ | ✅ | ✅ |
| **Country filter** | ✅ Built-in | ✅ | ✅ | ✅ |
| **Bulk patent ID lookup** | ✅ | ⚠️ Complex | ⚠️ | ✅ |
| **Price** | **$8.99/mo** | Free (complex setup) | Free (limited) | $5,000+/yr |

> **This Google Patents scraper gives you enterprise-grade patent data at $8.99/month** — compared to $5,000+/year for professional patent intelligence platforms.

---

### 💰 Pricing

#### 🆓 Free Trial — 2 Hours, No Credit Card

Start using this Google Patents scraper **immediately** with a full 2-hour free trial. No credit card. Click **Try for free**, enter a patent ID or search query, and get your first patent records in under 2 minutes.

During the free trial you get:
- ✅ Both scraping modes — Patent ID lookup + Search query
- ✅ All output fields — claims, abstract, inventors, classifications, legal status, citations
- ✅ Assignee, inventor, country, and date filters
- ✅ Full detail mode — visits each patent's detail page for complete data
- ✅ JSON output ready for export or API integration

#### 💳 Paid Plan — $8.99/Month

After the free trial, continue with **$8.99/month** for unlimited Google Patents scraping:

- ✅ **Unlimited patent ID lookups** — extract full records for any number of patents
- ✅ **Unlimited search runs** — search by keyword, assignee, inventor, country, date
- ✅ **Full claims text** — the most valuable part of any patent, fully extracted
- ✅ **IPC + CPC classification codes** — for technology landscape mapping
- ✅ **Legal status** — know instantly if a patent is active, expired, or pending
- ✅ **Apify scheduling** — automate weekly competitor patent monitoring
- ✅ **API access** — integrate patent data into your IP platform or research tool

#### 💡 $8.99/Month vs Patent Intelligence Alternatives

| Tool | Price | Claims | Classifications | Bulk Lookup | API |
|---|---|---|---|---|---|
| **This Google Patents Scraper** | **$8.99/mo** | ✅ Full text | ✅ IPC + CPC | ✅ | ✅ Apify |
| Google Patents (manual) | Free | ✅ | ✅ | ❌ One-by-one | ❌ |
| Lens.org | Free | ⚠️ Limited | ✅ | ⚠️ | ✅ Limited |
| PatSnap | $500+/mo | ✅ | ✅ | ✅ | ✅ |
| Derwent Innovation | $5,000+/yr | ✅ | ✅ | ✅ | ✅ |
| Questel Orbit | $3,000+/yr | ✅ | ✅ | ✅ | ✅ |

> 🎯 **$8.99/month delivers the same core patent data as tools costing $3,000–$5,000 per year.** Try it free for 2 hours first.

---

### 🎬 2 Scraping Modes

#### Mode 1: Patent ID Lookup (Direct)
Provide one or many patent IDs and extract the complete detail record for each — title, abstract, full claims, inventors, assignees, dates, classifications, legal status, citation counts, and patent family.

Supported patent ID formats:
````

US10000000B2      ← US patent, granted
EP1234567A1       ← European patent application
WO2023123456A1    ← PCT international application
CN112345678A      ← China patent
JP2023123456A     ← Japan patent
KR102345678B1     ← South Korea patent
DE102021123456A1  ← Germany patent
GB2601234A        ← UK patent

```

#### Mode 2: Search Query (Discovery)
Provide a keyword search query — with optional filters for assignee company, inventor name, country, and date range — and extract all matching patents. When `fetch_full_details: true`, the scraper visits each result's detail page for the complete record.

Search query examples:
```

machine learning drug discovery
electric vehicle battery management system
quantum computing error correction
CRISPR gene editing
natural language processing transformer
solar panel efficiency improvement

````

---

### 🎯 Use Cases

#### ⚖️ IP Due Diligence & Legal Research
Use this Google Patents scraper to perform prior art searches for patent applications, freedom-to-operate analyses, and patent validity assessments. Extract full claims text for any patent portfolio in minutes rather than hours.

#### 🏢 Corporate IP Strategy & Competitor Monitoring
Monitor competitor patent filings by scraping all patents assigned to a specific company (`assignee: "Tesla"`, `assignee: "Samsung"`). Track new filings weekly to understand competitor R&D direction and identify technology whitespace.

#### 🔬 Technology & Innovation Research
Map technology landscapes by extracting patents across a technology domain. Analyze IPC/CPC classification distributions to identify which subtechnologies are most active, which inventors are most prolific, and how filing rates are trending over time.

#### 🎓 Academic & Policy Research
Build structured patent datasets for academic research on innovation, technology transfer, patent thickets, or industrial policy. Extract inventor networks, assignee histories, and citation graphs from Google Patents at scale without manual data collection.

#### 💹 Investment & Market Intelligence
Identify technology leaders in emerging sectors by analyzing patent filing velocity, citation impact, and patent family breadth. Track which startups and research institutions are most active in your investment thesis areas.

#### 🤝 Licensing & Partnership Research
Find patent holders in a specific technology area by searching Google Patents by IPC classification or technology keyword. Identify potential licensing partners or acquisition targets based on their patent portfolio.

#### 🛡️ Patent Infringement Analysis
Extract claims text from competitor patents to identify potential infringement risk areas. The full claims text returned by this Google Patents scraper is the primary legal document defining patent scope.

#### 💻 Building IP Intelligence Platforms
Developers building patent analytics tools, IP management platforms, or technology intelligence products can use this Google Patents scraper as their data pipeline — clean JSON with all structured fields ready for any database.

---

### 📋 Output Fields (Full Reference)

Every record from this Google Patents scraper is labeled `"ENTERPRISE"` grade and contains:

#### 📄 Core Patent Identity Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `Patent_ID` | string | Normalized patent number | `"US10000000B2"` |
| `Title` | string | Patent title (max 500 chars) | `"System and method for neural network..."` |
| `Country_Code` | string | 2-letter country code | `"US"`, `"EP"`, `"WO"` |
| `Country` | string | Full country / office name | `"United States"`, `"World (PCT)"` |
| `Source_URL` | string | Direct Google Patents URL | `"https://patents.google.com/patent/US10000000B2"` |

#### 📝 Document Content Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `Abstract` | string | Patent abstract (max 3000 chars) | `"A system comprising..."` |
| `Claims` | string | Full claims text (max 5000 chars) | `"1. A method comprising the steps of..."` |
| `Claims_Count` | integer | Number of claims in the patent | `20` |
| `Description` | string | Description excerpt (max 3000 chars) | `"The present invention relates to..."` |

#### 👥 People & Organization Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `Inventors` | array | List of inventor names | `["John Smith", "Jane Doe"]` |
| `Applicants` | array | List of applicant/assignee names | `["Apple Inc."]` |
| `Assignee` | string | Primary assignee (first in list) | `"Apple Inc."` |
| `Agent` | string | Patent agent or attorney | `"Kilpatrick Townsend & Stockton LLP"` |

#### 📅 Date Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `Publication_Date` | string | Publication date (YYYY-MM-DD) | `"2024-06-18"` |
| `Filing_Date` | string | Application filing date | `"2022-03-15"` |
| `Priority_Date` | string | Priority / earliest claim date | `"2021-09-30"` |

#### 🏷️ Classification Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `IPC_Classification` | array | International Patent Classification codes | `["G06N3/04", "G06N20/00"]` |
| `CPC_Classification` | array | Cooperative Patent Classification codes (max 10) | `["G06N3/044", "G06N3/08"]` |

#### ⚖️ Status & Citation Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `Legal_Status` | string | Patent legal status | `"Active"`, `"Expired"`, `"Pending"` |
| `Cited_Patents_Count` | integer | Number of patents cited by this patent | `45` |
| `Cited_By_Count` | integer | Number of patents that cite this patent | `312` |

#### 👨‍👩‍👧‍👦 Patent Family Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `Patent_Family` | array | Related patents in the same family (max 10) | `["US10000001B2", "EP3456789A1"]` |
| `Patent_Family_Count` | integer | Total family member count | `8` |

#### 🔧 Meta Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `Extraction_Status` | string | Extraction result indicator | `"Verified ✅"` or `"Failed ❌"` |
| `Data_Grade` | string | Quality label | `"ENTERPRISE"` |
| `Timestamp` | string | ISO extraction timestamp | `"2024-11-01T10:30:00Z"` |

---

### ⚙️ Input Parameters

```json
{
  "patent_ids":          ["US10000000B2", "EP1234567A1"],
  "search_query":        "electric vehicle battery",
  "assignee":            "Tesla",
  "inventor":            "",
  "country":             "US",
  "date_from":           "2022-01-01",
  "max_results":         20,
  "fetch_full_details":  true,
  "proxyConfiguration": {
    "useApifyProxy":     true,
    "apifyProxyGroups":  ["RESIDENTIAL"]
  }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `patent_ids` | array or string | `[]` | Specific patent IDs to look up. Accepts array or newline/comma-separated string. IDs are normalized automatically (e.g. `10000000` → `US10000000`). |
| `search_query` | string | `""` | Keyword search query for Google Patents search. Used when no `patent_ids` are provided. |
| `assignee` | string | `""` | Filter search results by assignee (company) name — e.g. `"Apple"`, `"Samsung"`, `"MIT"` |
| `inventor` | string | `""` | Filter search results by inventor name — e.g. `"Elon Musk"`, `"Jane Smith"` |
| `country` | string | `""` | Filter by country code — e.g. `"US"`, `"EP"`, `"CN"`, `"JP"` |
| `date_from` | string | `""` | Filter patents published before this date (YYYY-MM-DD format) |
| `max_results` | integer | `20` | Maximum number of patent records to extract |
| `fetch_full_details` | boolean | `true` | When `true`, visits each patent's detail page for complete data (recommended). When `false`, returns search-result-level data only (faster). |
| `proxyConfiguration` | object | Off | Apify proxy config — **RESIDENTIAL required** for Google Patents |

***

### 📦 Example Inputs & Outputs

#### Example 1: Specific Patent ID Lookup

**Input:**

```json
{
  "patent_ids":         ["US10000000B2"],
  "fetch_full_details": true
}
```

**Output:**

```json
{
  "Patent_ID":           "US10000000B2",
  "Title":               "Neuromorphic Computing System with Adaptive Learning",
  "Abstract":            "A neuromorphic computing system comprising adaptive synaptic weights...",
  "Claims":              "1. A neuromorphic computing system comprising: a plurality of artificial neurons...",
  "Claims_Count":        24,
  "Description":         "The present invention relates to neuromorphic computing architectures...",
  "Inventors":           ["John A. Smith", "Maria L. Rodriguez"],
  "Applicants":          ["IBM Corporation"],
  "Assignee":            "IBM Corporation",
  "Agent":               "Eschweiler & Associates LLC",
  "Publication_Date":    "2018-06-19",
  "Filing_Date":         "2016-11-15",
  "Priority_Date":       "2015-08-22",
  "IPC_Classification":  ["G06N3/04", "G06N20/00"],
  "CPC_Classification":  ["G06N3/044", "G06N3/08", "G06N20/00"],
  "Legal_Status":        "Active",
  "Cited_Patents_Count": 45,
  "Cited_By_Count":      312,
  "Patent_Family":       ["US10000001B2", "EP3234567A1", "CN107851096A"],
  "Patent_Family_Count": 8,
  "Country_Code":        "US",
  "Country":             "United States",
  "Source_URL":          "https://patents.google.com/patent/US10000000B2",
  "Extraction_Status":   "Verified ✅",
  "Data_Grade":          "ENTERPRISE",
  "Timestamp":           "2024-11-01T10:30:00Z"
}
```

***

#### Example 2: Bulk Patent ID List

**Input:**

```json
{
  "patent_ids": [
    "US10000000B2",
    "EP1234567A1",
    "WO2023123456A1",
    "CN112345678A"
  ],
  "fetch_full_details": true,
  "max_results": 4
}
```

**Output:** 4 complete patent records — one per ID — each with full claims, inventors, classifications, legal status, and citation data. The country is auto-detected from the patent ID prefix.

***

#### Example 3: Search by Keyword

**Input:**

```json
{
  "search_query":       "quantum computing error correction",
  "max_results":        10,
  "fetch_full_details": true
}
```

**Output:** Up to 10 complete patent records for quantum computing error correction patents — with full claims, inventor lists, assignee companies, IPC/CPC codes, and legal status for each.

***

#### Example 4: Company Patent Portfolio Search

**Input:**

```json
{
  "search_query": "electric vehicle",
  "assignee":     "Tesla",
  "country":      "US",
  "max_results":  20
}
```

**Output:** Up to 20 US patents assigned to Tesla in the electric vehicle technology area — useful for competitor IP monitoring and technology landscape analysis.

***

#### Example 5: Inventor Patent Search

**Input:**

```json
{
  "inventor":           "Elon Musk",
  "max_results":        15,
  "fetch_full_details": true
}
```

**Output:** Up to 15 patents where Elon Musk is listed as an inventor — with full patent details, assignees, dates, and classifications.

***

#### Example 6: Technology + Country + Date Filter

**Input:**

```json
{
  "search_query": "CRISPR gene editing",
  "country":      "EP",
  "date_from":    "2020-01-01",
  "max_results":  15
}
```

**Output:** Up to 15 European patents for CRISPR gene editing technology published since January 2020.

***

### ⚙️ How the Google Patents Scraper Works

This Google Patents scraper uses a smart two-phase extraction strategy optimized for Google Patents' specific page structure:

#### Patent ID Mode — Direct Detail Extraction

**Step 1 — ID Normalization**
Patent IDs are automatically normalized to the correct format. `10000000` becomes `US10000000`, missing country prefixes are added for US patents, and formatting inconsistencies (spaces, dashes) are cleaned.

**Step 2 — Detail Page Fetch**
The scraper requests the Google Patents detail page for each patent ID using Chrome browser impersonation and a residential proxy. The full HTML page is returned — including rendered structured data markup.

**Step 3 — Multi-Layer HTML Parsing**
Patent data is extracted using a priority system: first from `itemprop` schema.org attributes (most reliable), then from CSS class selectors for Google Patents' specific layout, then from structured data tables as fallback.

**Step 4 — Classification Extraction**
IPC and CPC classification codes are extracted from dedicated code elements. Both systems are extracted independently — giving you the international (IPC) and cooperative (CPC) classification in separate fields.

**Step 5 — Claims Analysis**
The full claims section is extracted as text, and the number of individual claims is counted by detecting numbered claim openings in the text.

#### Search Mode — Discovery + Full Detail

**Step 1 — Search Query Construction**
Keyword, assignee, inventor, country, and date filters are combined into a Google Patents search URL. The search is executed against Google Patents' results page.

**Step 2 — Results Parsing**
Search results are parsed — first from any embedded JSON data in the page, then from HTML card elements. Patent IDs, titles, assignees, and publication dates are extracted from the results list.

**Step 3 — Full Detail Fetch (when enabled)**
When `fetch_full_details: true`, each result's patent ID is used to fetch its full detail page — providing complete claims, classifications, legal status, citation counts, and patent family data beyond what appears in search results.

***

### 🔍 Search Filters Guide

#### Keyword Search (`search_query`)

Full-text search across patent titles, abstracts, and claims:

```
machine learning image recognition
lithium ion battery thermal management
autonomous vehicle lidar sensor fusion
mRNA vaccine delivery mechanism
```

#### Assignee Filter (`assignee`)

Narrow results to patents filed by a specific company or organization:

```
assignee: "Apple"
assignee: "Samsung Electronics"
assignee: "MIT"
assignee: "Pfizer"
assignee: "Toyota Motor"
```

#### Inventor Filter (`inventor`)

Find all patents listing a specific person as inventor:

```
inventor: "Jensen Huang"
inventor: "Demis Hassabis"
inventor: "Frances Arnold"
```

#### Country Filter (`country`)

Filter by patent office using standard 2-letter codes:

| Code | Patent Office |
|---|---|
| `US` | United States Patent and Trademark Office |
| `EP` | European Patent Office |
| `WO` | World Intellectual Property Organization (PCT) |
| `CN` | China National Intellectual Property Administration |
| `JP` | Japan Patent Office |
| `KR` | Korean Intellectual Property Office |
| `DE` | German Patent and Trade Mark Office |
| `GB` | UK Intellectual Property Office |
| `AU` | IP Australia |
| `CA` | Canadian Intellectual Property Office |

***

### 📚 Patent ID Formats

This Google Patents scraper accepts and auto-normalizes all major patent ID formats:

| Format | Example | Country |
|---|---|---|
| US granted patent | `US10000000B2` | United States |
| US application | `US20230123456A1` | United States |
| European patent | `EP1234567A1` | European Patent Office |
| PCT application | `WO2023123456A1` | International (WIPO) |
| China patent | `CN112345678A` | China |
| Japan patent | `JP2023123456A` | Japan |
| Korea patent | `KR102345678B1` | South Korea |
| Germany patent | `DE102021123456A1` | Germany |
| UK patent | `GB2601234A` | United Kingdom |
| Australia patent | `AU2023123456A1` | Australia |
| Bare US number | `10000000` | Auto-prefixed as `US10000000` |

***

### 🗂️ IPC & CPC Classification Guide

#### International Patent Classification (IPC)

The IPC is a hierarchical classification system used by patent offices worldwide. Each code identifies the technology field of a patent:

| Code Prefix | Technology Domain |
|---|---|
| `A` | Human necessities (food, clothing, personal items, health) |
| `B` | Performing operations; transporting |
| `C` | Chemistry; metallurgy |
| `D` | Textiles; paper |
| `E` | Fixed constructions |
| `F` | Mechanical engineering; lighting; heating; weapons |
| `G` | Physics |
| `H` | Electricity |

**Example:** `G06N3/04` = Physics → Computing → Neural networks → Architecture

#### Cooperative Patent Classification (CPC)

The CPC is a more granular extension of the IPC used by the USPTO and EPO. It has finer subdivision levels and is particularly useful for precise technology landscape mapping.

Both IPC and CPC codes are extracted separately by this Google Patents scraper, giving you flexibility to use either system for your research or analytics.

***

### 🌐 Proxy Configuration

#### ⚠️ Residential Proxy Is Required for Google Patents

Google aggressively blocks datacenter IP addresses from automated access. **A residential proxy is mandatory** for this Google Patents scraper to work reliably.

#### Recommended Setup

```json
{
  "proxyConfiguration": {
    "useApifyProxy":    true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

Without a residential proxy, Google Patents will return 403 Forbidden or CAPTCHA pages after just 1–2 requests. With a residential proxy, the scraper can reliably fetch dozens or hundreds of patent records per run.

The actor applies a **2–4 second random delay** between requests to Google Patents to respect rate limits and avoid triggering additional blocking.

***

### ⚡ Performance & Speed

#### Speed Benchmarks (with residential proxy)

| Mode | Patents | Full Details | Estimated Time |
|---|---|---|---|
| Patent ID lookup | 1 | Yes | ~15–30 seconds |
| Patent ID lookup | 10 | Yes | ~3–5 minutes |
| Patent ID lookup | 20 | Yes | ~6–10 minutes |
| Search query | 10 results | No | ~30–60 seconds |
| Search query | 10 results | Yes (full detail) | ~4–6 minutes |
| Search query | 20 results | Yes (full detail) | ~8–12 minutes |

#### `fetch_full_details` Impact

Setting `fetch_full_details: true` (recommended) visits each patent's individual page — providing claims, description, legal status, citation counts, and classification codes not available in search results. This doubles run time but dramatically increases data completeness.

Set `fetch_full_details: false` for faster runs when you only need basic fields (title, abstract, assignee, dates) from search results.

***

### ❓ FAQ

**Q: Do I need a Google account or API key?**
A: No. Google Patents is a public search engine — no account, no API key, and no authentication is required. This Google Patents scraper accesses only public patent information.

**Q: Why is a residential proxy required?**
A: Google blocks datacenter IP addresses from automated access. Residential proxies use real home internet connections that Google cannot distinguish from normal user traffic. Without a residential proxy, Google returns 403 or CAPTCHA after just a few requests.

**Q: Can I extract the full claims text for a patent?**
A: Yes — the `Claims` field contains the full claims text (up to 5,000 characters). Claims are the legally binding part of a patent defining exactly what is protected. The `Claims_Count` field tells you how many individual claims the patent has.

**Q: What is the difference between IPC and CPC classifications?**
A: IPC (International Patent Classification) is the standard global system used by all patent offices. CPC (Cooperative Patent Classification) is a finer-grained extension used by the USPTO and EPO. Both are extracted by this scraper — use whichever system your research or database requires.

**Q: Can I monitor a company's patent filings automatically?**
A: Yes — set `assignee: "CompanyName"` and schedule this Google Patents scraper to run weekly. Use Apify webhooks to send new patent alerts to Slack or email automatically.

**Q: What does `fetch_full_details: false` do?**
A: In search mode, it returns only the data available on the search results page — title, abstract snippet, assignee, publication date. It is much faster but does not include claims, legal status, citation counts, or classification codes. Use `true` for complete records.

**Q: Can I look up European (EP) or PCT (WO) patents?**
A: Yes — provide the full patent ID including the country prefix: `EP1234567A1`, `WO2023123456A1`. The country is auto-detected from the prefix and the Google Patents URL is constructed automatically.

**Q: How many patents can I extract per run?**
A: There is no hard limit. For large runs (100+ patents), we recommend batching into groups of 20–30 per run for reliability. The 2–4 second delay between requests helps avoid rate limiting.

**Q: What is the 2-hour free trial?**
A: The free trial gives you complete access to all features — both modes, all filters, all output fields, full claims and classification extraction — for 2 hours with no credit card required.

**Q: Can I use this for freedom-to-operate (FTO) analysis?**
A: This scraper extracts the claims text which is the starting point for FTO analysis. However, FTO analysis requires legal interpretation of claims by a qualified patent attorney — this tool provides the data, not the legal analysis.

***

### 📜 Changelog

#### v1.0.0 (Current)

- ✅ Patent ID lookup mode — full detail extraction for any patent ID (US, EP, WO, CN, JP, KR, DE, GB)
- ✅ Patent ID auto-normalization — bare numbers, missing prefixes, formatting variants all handled
- ✅ Search mode — keyword, assignee, inventor, country, and date filters
- ✅ Full claims text extraction (up to 5,000 characters)
- ✅ Claims count — number of individual claims counted automatically
- ✅ Abstract extraction (up to 3,000 characters)
- ✅ Description excerpt (up to 3,000 characters)
- ✅ IPC and CPC classification codes — both systems extracted independently
- ✅ Legal status extraction (Active / Expired / Pending)
- ✅ Citation count: patents cited + times cited by others
- ✅ Patent family members list and count
- ✅ Multi-layer fallback parsing — itemprop schema → CSS selectors → data tables
- ✅ `fetch_full_details` mode for search results
- ✅ 2–4 second rate-limit-safe delay between requests
- ✅ `"ENTERPRISE"` data grade label on all records
- ✅ `Extraction_Status` flag: `"Verified ✅"` or `"Failed ❌"`

***

### ⚖️ Legal & Terms of Use

This Google Patents scraper accesses publicly available patent information from Google Patents — the same data visible to anyone visiting the site in a browser. Patent documents are public domain in most jurisdictions once published.

**Usage guidelines:**

- Use extracted patent data for legitimate IP research, legal due diligence, academic research, and business intelligence
- Patent documents (text, claims, drawings) are generally public domain once published — consult a patent attorney for jurisdiction-specific guidance
- Do not use this tool to scrape at volumes that impact Google Patents' services or circumvent access controls
- This tool extracts publicly available bibliographic data — it does not provide legal advice on patent validity, infringement, or freedom-to-operate

***

### 🤝 Support & Feedback

- **Bug or extraction issue?** Contact via the Apify actor page — we respond fast
- **Need a new field or filter?** Request via the Apify Community forum
- **Loving it?** Please leave a ⭐ review — it helps other IP professionals find this Google Patents scraper!

***

> 🆓 **2-hour free trial** → 💳 **$8.99/month after** — enterprise-grade patent data from Google Patents at the lowest price available.

***

<p align="center">
  <strong>Built with ❤️ on Apify · Google Patents Scraper — Claims, Classifications & Full Patent Records</strong><br/>
  <em>Extract complete patent data from Google Patents — no API key, no quotas, no limits</em>
</p>

# Actor input Schema

## `patent_ids` (type: `string`):

Patent IDs to scrape. One per line or comma-separated.

Examples:
US10000000B2
US9876543B1
EP1234567A1
WO2023123456A1
CN112345678A

## `search_query` (type: `string`):

Search Google Patents by keyword. E.g: 'machine learning image recognition', 'electric vehicle battery', 'mRNA vaccine'

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

Search patents by company/organization name. E.g: 'Apple', 'Google', 'Samsung', 'Microsoft'

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

Search patents by inventor name. E.g: 'Elon Musk', 'Jeff Dean'

## `country` (type: `string`):

Filter by country code. E.g: US, EP, CN, JP, KR, DE, WO

## `date_from` (type: `string`):

Only return patents published after this date

## `fetch_full_details` (type: `boolean`):

ON → fetch complete patent page (claims, description, classifications). OFF → faster, returns search result data only.

## `max_results` (type: `integer`):

Maximum number of patents to return

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

RESIDENTIAL proxy required — Google blocks datacenter IPs.

## Actor input object example

```json
{
  "patent_ids": "US10000000B2\nUS9876543B1",
  "fetch_full_details": true,
  "max_results": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "patent_ids": `US10000000B2
US9876543B1`,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/google-patents-scraper----claims-inventors-citations-1").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 = {
    "patent_ids": """US10000000B2
US9876543B1""",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/google-patents-scraper----claims-inventors-citations-1").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 '{
  "patent_ids": "US10000000B2\\nUS9876543B1",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapepilot/google-patents-scraper----claims-inventors-citations-1 --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Patents Scraper    Claims Inventors Citations 1",
        "description": "Scrape complete patent data from Google Patents. Returns full claims text, abstract, inventors, applicants, IPC/CPC classifications, filing dates, legal status and citation counts. Search by patent ID, keyword, assignee or inventor. RESIDENTIAL proxy included.",
        "version": "0.0",
        "x-build-id": "BbTa1YZ5SM5CzNhju"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~google-patents-scraper----claims-inventors-citations-1/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-google-patents-scraper----claims-inventors-citations-1",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapepilot~google-patents-scraper----claims-inventors-citations-1/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-google-patents-scraper----claims-inventors-citations-1",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapepilot~google-patents-scraper----claims-inventors-citations-1/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-google-patents-scraper----claims-inventors-citations-1",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "patent_ids": {
                        "title": "Patent IDs",
                        "type": "string",
                        "description": "Patent IDs to scrape. One per line or comma-separated.\n\nExamples:\nUS10000000B2\nUS9876543B1\nEP1234567A1\nWO2023123456A1\nCN112345678A"
                    },
                    "search_query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search Google Patents by keyword. E.g: 'machine learning image recognition', 'electric vehicle battery', 'mRNA vaccine'"
                    },
                    "assignee": {
                        "title": "Assignee / Company Filter",
                        "type": "string",
                        "description": "Search patents by company/organization name. E.g: 'Apple', 'Google', 'Samsung', 'Microsoft'"
                    },
                    "inventor": {
                        "title": "Inventor Name Filter",
                        "type": "string",
                        "description": "Search patents by inventor name. E.g: 'Elon Musk', 'Jeff Dean'"
                    },
                    "country": {
                        "title": "Country Filter",
                        "type": "string",
                        "description": "Filter by country code. E.g: US, EP, CN, JP, KR, DE, WO"
                    },
                    "date_from": {
                        "title": "Date From (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only return patents published after this date"
                    },
                    "fetch_full_details": {
                        "title": "Fetch Full Details",
                        "type": "boolean",
                        "description": "ON → fetch complete patent page (claims, description, classifications). OFF → faster, returns search result data only.",
                        "default": true
                    },
                    "max_results": {
                        "title": "Max Patents",
                        "type": "integer",
                        "description": "Maximum number of patents to return",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (RESIDENTIAL Required)",
                        "type": "object",
                        "description": "RESIDENTIAL proxy required — Google blocks datacenter IPs."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```