# Google Patents Scraper — Claims, Citations & Legal Status (`datasmithhq/google-patents-scraper`) Actor

Look up any patent by number on Google Patents: title, abstract, legal status and expiry, assignees, CPC codes, every claim, citations both ways and litigation count. Any country, English translations. Pay per patent.

- **URL**: https://apify.com/datasmithhq/google-patents-scraper.md
- **Developed by:** [Data Smith](https://apify.com/datasmithhq) (community)
- **Categories:** Business, AI
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 patents

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Patents Scraper — Claims, Citations & Legal Status

Paste a list of patent numbers and get one clean record per patent from Google Patents: title, abstract, legal status and expiry date, assignee, CPC codes, every claim (with independent claims flagged), citations in both directions and litigation count. Works for any country Google Patents covers, with English translations of non-English patents. Export to JSON, CSV, Excel or Google Sheets.

### Why this patent scraper?

- **Any number format.** `US10000000B2`, `US 10,000,000 B2`, `US10000000` (no kind code), `EP3000000A1`, `WO2020000001A1` or a Google Patents URL. Duplicates are removed.
- **Claims you can analyse.** Every claim as text, numbered, with `independent: true/false`, plus counts of all and independent claims. It also works for machine-translated claims, where Google's markup doesn't link dependent claims.
- **Legal status in one field.** `legalStatus` (Active, Granted, Ceased, Withdrawn…), `expirationDate` and `grantDate` without digging through the event timeline.
- **Citations both ways.** Patents it cites and patents citing it, each with publication number, dates, assignee, title and whether the examiner cited it, plus the family-level versions. Counts are always included, and the lists are capped by a setting you choose.
- **Litigation flag.** `litigationCount` counts the US court cases Google Patents lists for the patent.
- **English or original.** Get Google's English translation of Japanese, Korean, Chinese, German and other patents (`translatedFrom` tells you the source language), or the original text as filed.
- **You only pay for patents found.** Numbers that don't exist are logged and not charged.

### Input

| Field | What it does | Default |
|---|---|---|
| Patent numbers or URLs | The patents to look up | (required) |
| Language | `English` or `Original language` | English |
| Include claims | Full claim text | on |
| Include citation lists | Cited and citing patents | on |
| Max citations per list | Caps each citation list | 100 |
| Include full description | The whole specification text (long) | off |
| Include legal events | Patent-office events: date, code, title | off |

### Output example

```json
{
  "input": "US10000000B2",
  "publicationNumber": "US10000000B2",
  "title": "Coherent LADAR using intra-pixel quadrature detection",
  "url": "https://patents.google.com/patent/US10000000B2/en",
  "countryCode": "US",
  "kindCode": "B2",
  "abstract": "A frequency modulated (coherent) laser detection and ranging system includes…",
  "translatedFrom": null,
  "legalStatus": "Active",
  "expirationDate": "2036-05-13",
  "priorityDate": "2015-03-10",
  "filingDate": "2015-03-10",
  "publicationDate": "2018-06-19",
  "grantDate": "2018-06-19",
  "applicationNumber": "US14/643,719",
  "assignee": "Raytheon Co",
  "familyId": "55456961",
  "cpcCodes": [{ "code": "G01S7/4863", "description": "Detector arrays, e.g. charge-transfer gates", "isFirst": true }],
  "claimsCount": 20,
  "independentClaimsCount": 3,
  "litigationCount": 5,
  "citationsCount": 5,
  "citedByCount": 22,
  "pdfUrl": "https://patentimages.storage.googleapis.com/c0/d5/f7/86ad5b42759506/US10000000.pdf",
  "claims": [{ "number": 1, "text": "1. A laser detection and ranging (LADAR) system, comprising: …", "independent": true }],
  "citedBy": [{ "publicationNumber": "US10845468B2", "publicationDate": "2020-11-24", "assignee": "Raytheon Company", "title": "Coherent LADAR using intra-pixel quadrature detection", "examinerCited": true }]
}
```

The output also has `events` (the timeline: filing, priority, publication, grant, reassignment, litigation, expiry), `assigneesOriginal` / `assigneesCurrent`, `priorArtKeywords`, and family citation lists.

### Use cases

- **Portfolio reviews:** status, expiry and claim counts for a list of patents in one spreadsheet
- **Prior-art and citation analysis:** who cites a patent, and what it cites
- **Competitor monitoring:** a company's patents with CPC codes and current status
- **Licensing and litigation research:** which patents have US court cases
- **Data pipelines and AI:** clean claim text and abstracts as input for search or LLM analysis

### FAQ

**Can I search by keyword or company?** Not in this version. It looks up patents by number. Google Patents' own search page lets you find numbers to paste in, and you can export result lists from it as CSV.

**Are inventor names included?** No. The output covers the patent and its owners (assignees), not the people named as inventors. When a cited or citing patent was filed by a private person rather than a company, its `assignee` is left empty.

**How accurate are translations?** They're Google Patents' machine translations, the same text you see on the site. Use `Original language` for the text as filed.

**Why is `assigneesCurrent` empty for some patents?** Some patent offices don't report changes of ownership. `assignee` falls back to the original applicant.

**Is it legal?** It reads publicly available patent records from Google Patents' individual patent pages.

**Something broke?** Open an issue on the Issues tab and it will be fixed quickly.

# Actor input Schema

## `patentNumbers` (type: `array`):

Publication numbers from any country, with or without the kind code (US10000000B2, US10000000, EP3000000A1, WO2020000001A1, CN108000000A), or Google Patents URLs. Spaces and commas are ignored.

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

English: non-English patents come machine-translated by Google Patents (the output says which language they were translated from). Original: the text as filed, e.g. German for a German EP application.

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

Full text of every claim, with independent claims flagged.

## `includeCitations` (type: `boolean`):

Lists of cited patents and patents citing this one (counts are always included).

## `maxCitations` (type: `integer`):

Caps each citation list (cites, cited by, and their family versions).

## `includeDescription` (type: `boolean`):

The full specification text. Can be very long (tens of thousands of characters).

## `includeLegalEvents` (type: `boolean`):

Patent-office legal events (date, code, title), e.g. fee payments, assignments, lapses.

## `concurrency` (type: `integer`):

How many patents to fetch at the same time. Higher is faster for long lists.

## `maxRetries` (type: `integer`):

Retries per patent when Google Patents rate-limits or a connection drops.

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

Apify Proxy keeps large lookups reliable.

## Actor input object example

```json
{
  "patentNumbers": [
    "US10000000B2",
    "EP3000000A1"
  ],
  "language": "en",
  "includeClaims": true,
  "includeCitations": true,
  "maxCitations": 100,
  "includeDescription": false,
  "includeLegalEvents": false,
  "concurrency": 5,
  "maxRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One item per patent: bibliographic data, legal status, claims, citations and CPC codes.

# 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 = {
    "patentNumbers": [
        "US10000000B2",
        "EP3000000A1"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datasmithhq/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 = {
    "patentNumbers": [
        "US10000000B2",
        "EP3000000A1",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("datasmithhq/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 '{
  "patentNumbers": [
    "US10000000B2",
    "EP3000000A1"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call datasmithhq/google-patents-scraper --silent --output-dataset

```

## MCP server setup

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