# Google Patents Inventor, Assignee & Citation Lookup (`dataspryva/google-patents-inventor-assignee-and-citation`) Actor

Search Google's aggregated patent index by keyword, inventor, assignee, classification code, or citation graph, and get abstract, claims, dates, family, and citations for each matching patent.

- **URL**: https://apify.com/dataspryva/google-patents-inventor-assignee-and-citation.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Records, Claims & Citation Graph

Read Google Patents without cookies, logins or an API key. Search the worldwide patent index by keyword, inventor, assignee or CPC class, or open known publications by number or URL. Return structured records with claims, legal status, legal events, citations, cited-by, family members, classifications, figures and PDF links.

### Modes

| Mode | What it does |
|---|---|
| `searchPatents` | Keyword search with office, language, status, type, date, sort, grouping and litigation filters. |
| `byPatent` | Full record for one or more publication numbers. |
| `byInventor` | Portfolio search for one or more inventor names. |
| `byAssignee` | Portfolio search for one or more companies or applicants. |
| `byClassification` | CPC class or prefix search. Use `searchPatents` to combine a keyword query with a class. |
| `byCitation` | Walk backward citations, forward cited-by links, or both, up to three hops. |
| `byFamily` | One row per family member or family publication. |
| `byUrl` | Paste patent pages or Google Patents search URLs; all search filters in the URL are kept. |

### Input reference

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `searchPatents` | `searchPatents`, `byPatent`, `byInventor`, `byAssignee`, `byClassification`, `byCitation`, `byFamily` or `byUrl`. |
| `searchQueries` | array | `["quantum computing"]` | Keyword queries for `searchPatents`. |
| `publicationNumbers` | array | `[]` | IDs for `byPatent`, `byCitation` and `byFamily`. |
| `inventors` | array | `[]` | Names for `byInventor`, or an optional search filter. |
| `assignees` | array | `[]` | Companies for `byAssignee`, or an optional search filter. |
| `classifications` | array | `[]` | CPC codes for `byClassification`, or an optional search filter. |
| `urls` | array | `[]` | Patent or search URLs for `byUrl`. |
| `countryCodes` | array | `[]` | Two-letter office codes; empty means all offices. |
| `documentLanguages` | array | `[]` | Original publication languages (16 values). |
| `detailLanguage` | string | `en` | Detail-page language. |
| `status` | string | `ANY` | `ANY`, `GRANT` or `APPLICATION`. |
| `patentType` | string | `ANY` | `ANY`, `PATENT` or `DESIGN`. |
| `dateType` | string | `priority` | `priority`, `filing` or `publication`. |
| `dateFrom` | string | `""` | Earliest date, inclusive, `YYYY-MM-DD`. |
| `dateTo` | string | `""` | Latest date, inclusive, `YYYY-MM-DD`. |
| `sortBy` | string | `relevance` | `relevance`, `new` or `old`. |
| `grouping` | string | `family` | `family` or `publication`. |
| `includeSimilar` | boolean | `true` | Keep Google's similar documents or drop them. |
| `includeNonPatentLiterature` | boolean | `false` | Also return Google Scholar rows. |
| `litigation` | string | `ANY` | `ANY`, `YES` or `NO`. |
| `citationDirection` | string | `both` | `backward`, `forward` or `both`. |
| `citationDepth` | integer | `1` | Citation hops, 1-3. |
| `fetchFullDetails` | boolean | `false` | Fetch each search hit's patent page. |
| `maxItems` | integer | `25` | Hard cap across all queries; prefill is 3. |
| `maxItemsPerQuery` | integer | `0` | Optional per-query cap; 0 means global only. |

### Filters

- Multiple values: inventor and assignee arrays run one search per value and merge (Google's XHR keeps only the last repeat value); CPC arrays are ORed in one query; office and language arrays are comma-joined. Different filter types are combined with AND.
- Patent office: `countryCodes` accepts US, EP, WO, JP, CN, KR, DE, GB, FR, CA, AU, IN and more.
- Document language: 16 original-publication languages. This is a language filter, not a translation setting.
- Grant status: any, granted, or applications.
- Type: any, patent, or design.
- Date: priority, filing or publication date, from and to.
- Sort: relevance, newest, or oldest.
- Grouping: one row per family (Google's default) or one row per publication.
- Similar documents: keep them with `matchType=similar`, or drop them.
- Litigation: with related litigation, without known litigation, or any.
- Non-patent literature: optionally add Google Scholar rows for each keyword query.

### Output

Patent rows include `publicationNumber`, `title`, `abstract`, `claims`, `claimCount`, `inventors`, `assigneesOriginal`, `assigneesCurrent`, `primaryAssignee`, `priorityDate`, `filingDate`, `publicationDate`, `grantDate`, `priorArtDate`, `expirationDate` where the source has one, `applicationNumber`, `legalStatus`, `legalEvents`, `cpcCodes`, `classificationDetails`, `priorArtKeywords`, `familyId`, `familyMembers`, `familyApplications`, `familyCountryStatus`, `priorityApplications`, `publications`, `alsoPublishedAs`, `backwardCitations`, `forwardCitations`, `familyCitations`, `familyCitedBy`, `nonPatentCitations`, `similarDocuments`, `figures`, `thumbnailUrl`, `pdfUrl`, `externalLinks`, `patentUrl`, `matchType`, `searchRank`, `searchQuery`, `recordType` and `scrapedAt`.

Rows that do not apply are omitted; the actor never writes null, empty-string or sentinel values. Citation rows add `citationDirection`, `citationSeed`, `citationHop`, `citationDepth`, `citationParent`, `citedBy` or `citing`. Family rows add `familyId` and `sourceSeed`. Non-patent-literature rows add `authors`, `venue`, `urlHostname` and `scholarId`.

Some data is genuinely missing upstream: for example, EP B1 documents and many Japanese grants have no abstract, not every office publishes claims, and an anticipated expiration date is shown mainly for US and Canadian patents. Those fields are omitted rather than guessed.

### Examples

Keyword search with full details:

```json
{
  "mode": "searchPatents",
  "searchQueries": ["solid-state battery"],
  "countryCodes": ["US", "EP"],
  "status": "GRANT",
  "dateFrom": "2020-01-01",
  "fetchFullDetails": true,
  "maxItems": 20
}
```

Company portfolio in one office:

```json
{
  "mode": "byAssignee",
  "assignees": ["Siemens"],
  "countryCodes": ["DE", "EP"],
  "maxItems": 50
}
```

Citation graph two hops out:

```json
{
  "mode": "byCitation",
  "publicationNumbers": ["US11704715B2"],
  "citationDirection": "both",
  "citationDepth": 2,
  "maxItems": 100
}
```

Paste a search URL:

```json
{
  "mode": "byUrl",
  "urls": ["https://patents.google.com/?q=lidar&country=US&status=GRANT&after=filing:20200101"]
}
```

### Limits

Google Patents shows about 1,000 results per query (100 pages). The actor pages through that window and tells you in the run status when it hits the source cap. To go deeper, split the search by date, office or CPC class. The run status also reports the delivered count. `maxItems` is a hard cap across all queries; `maxItemsPerQuery` optionally caps each query separately.

For keyword searches sorted newest or oldest, the actor reads the accessible result window and sorts it by publication date. Google's sorted endpoint otherwise ignores bare keyword terms. Non-patent-literature rows share the same `maxItems` budget and are written after patent rows.

- `byFamily` seeds are enriched with title, grant status and legal status from the patent page plus a publication lookup; non-seed family rows carry title/status only when Google lists them.
- Similar documents carry `publicationDate` when Google shows one. Non-patent-literature rows are text/venue/URL records with no structured date; a date may appear in the text.
- In citation runs of depth 2 or 3, every row has `citationParent` (the page it was read from). `citedBy`/`citing` remain seed-based for compatibility.

### FAQ

**Do I need a Google account or API key?**
No. The actor reads public Google Patents pages. No cookies, login or key are required.

**Why did my search stop at about 1,000 rows?**
That is Google Patents' display cap for one query. Narrow the date range, choose fewer offices, or add a CPC class and run again.

**Does it return claims for every patent?**
Only when the source page has them. US, EP, WO, CN and several other offices usually do; some applications, search-report documents and designs do not.

**Why is the abstract empty on some records?**
Some documents have no abstract on Google Patents, including many EP B1 grants and Japanese grants. The field is omitted rather than filled with a placeholder.

**What is the difference between `family` and `publication` grouping?**
Family grouping returns one row per invention, as Google shows by default. Publication grouping returns separate rows for the application, grant and each office's version.

**Are citation walks recursive?**
Yes in `byCitation` mode: set `citationDepth` to 1, 2 or 3. Each row records the seed, hop and direction.

**Do multiple inventors or CPC codes work in one search?**
Yes. Inventor/assignee arrays run one search per value and merge the results; CPC arrays are ORed in one query. Duplicate publications are removed.

**Do the PDF and image links work without a referer?**
Yes. They point to public Google Cloud Storage objects.

**Can I filter by original document language?**
Yes, with `documentLanguages`. It filters publications by language; it does not translate them. Use `detailLanguage` to choose the page language for detail extraction.

**Does it use a proxy?**
The actor tries a direct request first and switches to the Apify proxy automatically if Google blocks it. There is no proxy input to configure.

### Notes

Patent documents are public records. Legal status and assignee data are Google's assumptions, not legal conclusions; confirm critical facts with the relevant patent office. This actor is independent and not affiliated with Google.

# Actor input Schema

## `mode` (type: `string`):

Which lookup path to use.

## `searchQueries` (type: `array`):

One or more keyword queries. Google Patents syntax works: quoted phrases, OR, minus, TI=(title words), CL=(claim words), CPC=H04L9/06.

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

Publication numbers such as US11704715B2, EP3789012A1, WO2020012345A1. Used by byPatent, byCitation and byFamily.

## `inventors` (type: `array`):

Inventor names. The actor runs one search per name.

## `assignees` (type: `array`):

Assignee or applicant names. The actor runs one search per name.

## `classifications` (type: `array`):

CPC codes or prefixes such as H04L9/06, G06N3/00, H01M10. Combined with a keyword query when both are set.

## `urls` (type: `array`):

Patent pages (/patent/US.../en) or search pages (/?q=...\&assignee=...\&country=...). All search filters in the URL are honoured.

## `countryCodes` (type: `array`):

Two-letter office codes: US, EP, WO, JP, CN, KR, DE, GB, FR, CA, AU, IN and more. Empty means all offices.

## `documentLanguages` (type: `array`):

Original publication languages: ENGLISH, GERMAN, FRENCH, SPANISH, JAPANESE, KOREAN, CHINESE, RUSSIAN, PORTUGUESE, ITALIAN, ARABIC, DUTCH, SWEDISH, FINNISH, NORWEGIAN, DANISH. This filters documents; it does not translate them.

## `detailLanguage` (type: `string`):

Language of the patent page text. Google translates where available.

## `status` (type: `string`):

Any status, granted patents only, or published applications only.

## `patentType` (type: `string`):

Utility-style patents or design patents.

## `dateType` (type: `string`):

Which date the From and To fields apply to.

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

Earliest date, inclusive. Leave empty for no lower bound.

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

Latest date, inclusive. Leave empty for no upper bound.

## `sortBy` (type: `string`):

Google's relevance, newest first, or oldest first.

## `grouping` (type: `string`):

One row per patent family (Google's default) or one row per publication.

## `includeSimilar` (type: `boolean`):

Google mixes similar documents into search results. Keep them (label matchType=similar) or drop them.

## `includeNonPatentLiterature` (type: `boolean`):

Also return Google Scholar non-patent literature rows for each keyword query.

## `litigation` (type: `string`):

Only patents with related litigation, only patents with no known litigation, or any.

## `citationDirection` (type: `string`):

Which side of the citation graph to walk in byCitation mode.

## `citationDepth` (type: `integer`):

How many citation hops to follow in byCitation mode: 1, 2 or 3.

## `fetchFullDetails` (type: `boolean`):

For search modes, also fetch each patent page for claims, legal status, citations, family and other detail fields.

## `maxItems` (type: `integer`):

Hard cap on emitted records. Google Patents exposes about 1,000 results per query; use date, office or CPC filters to go deeper.

## `maxItemsPerQuery` (type: `integer`):

Optional cap for each query / inventor / assignee / CPC search. 0 means only the global Max items cap applies.

## Actor input object example

```json
{
  "mode": "searchPatents",
  "searchQueries": [
    "quantum computing"
  ],
  "publicationNumbers": [],
  "inventors": [],
  "assignees": [],
  "classifications": [],
  "urls": [],
  "countryCodes": [],
  "documentLanguages": [],
  "detailLanguage": "en",
  "status": "ANY",
  "patentType": "ANY",
  "dateType": "priority",
  "dateFrom": "",
  "dateTo": "",
  "sortBy": "relevance",
  "grouping": "family",
  "includeSimilar": true,
  "includeNonPatentLiterature": false,
  "litigation": "ANY",
  "citationDirection": "both",
  "citationDepth": 1,
  "fetchFullDetails": false,
  "maxItems": 3,
  "maxItemsPerQuery": 0
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped patents.

# 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 = {
    "mode": "searchPatents",
    "searchQueries": [
        "quantum computing"
    ],
    "publicationNumbers": [],
    "inventors": [],
    "assignees": [],
    "classifications": [],
    "urls": [],
    "countryCodes": [],
    "documentLanguages": [],
    "detailLanguage": "en",
    "status": "ANY",
    "patentType": "ANY",
    "dateType": "priority",
    "sortBy": "relevance",
    "grouping": "family",
    "includeSimilar": true,
    "includeNonPatentLiterature": false,
    "litigation": "ANY",
    "citationDirection": "both",
    "citationDepth": 1,
    "fetchFullDetails": false,
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/google-patents-inventor-assignee-and-citation").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 = {
    "mode": "searchPatents",
    "searchQueries": ["quantum computing"],
    "publicationNumbers": [],
    "inventors": [],
    "assignees": [],
    "classifications": [],
    "urls": [],
    "countryCodes": [],
    "documentLanguages": [],
    "detailLanguage": "en",
    "status": "ANY",
    "patentType": "ANY",
    "dateType": "priority",
    "sortBy": "relevance",
    "grouping": "family",
    "includeSimilar": True,
    "includeNonPatentLiterature": False,
    "litigation": "ANY",
    "citationDirection": "both",
    "citationDepth": 1,
    "fetchFullDetails": False,
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/google-patents-inventor-assignee-and-citation").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 '{
  "mode": "searchPatents",
  "searchQueries": [
    "quantum computing"
  ],
  "publicationNumbers": [],
  "inventors": [],
  "assignees": [],
  "classifications": [],
  "urls": [],
  "countryCodes": [],
  "documentLanguages": [],
  "detailLanguage": "en",
  "status": "ANY",
  "patentType": "ANY",
  "dateType": "priority",
  "sortBy": "relevance",
  "grouping": "family",
  "includeSimilar": true,
  "includeNonPatentLiterature": false,
  "litigation": "ANY",
  "citationDirection": "both",
  "citationDepth": 1,
  "fetchFullDetails": false,
  "maxItems": 3
}' |
apify call dataspryva/google-patents-inventor-assignee-and-citation --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/google-patents-inventor-assignee-and-citation"
        }
    }
}
```

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/qGwyVKXBvzDrcnIAf/builds/N7bSR7wWMs9dxceBg/openapi.json