# Google Patents Search Pro (`red.cars/google-patents-search-pro`) Actor

Search 100M+ patents across 100+ patent offices by keyword, office, status and date range. Full records with complete abstract, claim texts, backward and forward citations and CPC codes. No API key needed.

- **URL**: https://apify.com/red.cars/google-patents-search-pro.md
- **Developed by:** [AutomateLab](https://apify.com/red.cars) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 patent records

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 Search Pro

Search and fetch full patent records across USPTO, EPO, WIPO, JPO, CN, KR and 100+ patent offices. Two modes: free-text search with hard filters for country, status, patent type and priority-date range, and full records for specific patent IDs with complete abstracts, claim texts, backward and forward citations with totals, and CPC codes. Clean JSON rows, no API key needed.

### Why this one

Most patent actors in the store advertise more modes than they deliver, return fewer results than the count you asked for, or hide their pricing. Google Patents Search Pro paginates properly and stops exactly at your max count, applies every filter server-side so non-matching rows are never fetched or billed, and publishes its pricing upfront: **$2.00 per 1,000 patent records** plus $0.005 per run.

The store's current patent-discovery leader returns partial pages past result 100 and carries zero verified reviews. This actor was built to fix exactly those two things: correct pagination to any count up to 1,000, and rows you can verify in the dataset before you pay beyond the run start.

### Comparison

| | Google Patents Search Pro | Current store leader |
|---|---|---|
| Monthly users | New actor | ~33 |
| Verified reviews | Launching with full public README and tables | 0 |
| Price per 1,000 records | $2.00 | $2.00 |
| Run start fee | $0.005 | hidden |
| Max results per run | 1,000, paginated exactly | partial pages past 100 |
| Filters applied server-side | Yes, non-matching rows never billed | partial |
| Pricing published | Yes | partial |

### Input

| Field | Type | Purpose |
|---|---|---|
| mode | string | `search` (default) to discover patents by query, or `details` to fetch full records for specific patent IDs. |
| searchQuery | string | Free-text query. Supports quoted phrases, boolean operators and wildcards, e.g. `"solid state battery" electrolyte`. |
| patentIds | array\[string] | Publication numbers for details mode, e.g. `US10517421B2`, `EP3612345A1`. |
| countryCodes | array\[string] | Restrict to offices: `US`, `EP`, `WO`, `JP`, `CN`, `KR`, `DE` and more. Empty means all. |
| status | string | `GRANT` for granted only, `APPLICATION` for pending only, empty for any. |
| patentType | string | `PATENT` for utility, `DESIGN` for design, empty for any. |
| dateFrom / dateTo | string | Priority-date bounds in `YYYY-MM-DD`. Empty means unbounded. |
| sort | string | Empty for relevance, `new` for newest first. |
| depth | string | `basic` (default, fast search rows) or `deep` (adds claims, citations, CPC per patent). |
| maxItems | integer | Hard cap on dataset items. Default 10, maximum 1,000. |

### Output

Each dataset item is one JSON row. In basic mode:

| Field | Description |
|---|---|
| type | `patent` |
| patentId | Canonical publication number, e.g. `US10517421B2`. |
| title | Published title. |
| abstract | Abstract snippet. |
| priorityDate / filingDate / grantDate / publicationDate | ISO dates. |
| assignee | Primary assignee. |
| inventors | Inventor names as an array. |
| countryCode / kindCode | Office and publication kind codes parsed from the ID. |
| language | Publication language. |
| patentUrl | Link to the patent on Google Patents. |
| pdfUrl | Direct link to the published PDF. |

In `deep` mode each row is a `patent_detail` and adds:

| Field | Description |
|---|---|
| abstract | Complete abstract. |
| claimsCount / claims | Number and full text of claims. |
| cpc | CPC classification codes. |
| citationsBackward / citationsBackwardTotal | Prior-art citations and count. |
| citationsForward / citationsForwardTotal | Later patents citing this one, and count. |

### Pricing

Pay per event, published upfront:

- **Actor start: $0.005** per run
- **Patent record: $0.002** per dataset item, i.e. **$2.00 per 1,000 patent records**

A 10-record test costs about $0.025 all-in. Non-matching rows are never fetched, so filtered runs cost only for matching records.

### Use cases

- **Prior-art search**: screen a technology area before filing, with hard date and office filters.
- **IP landscaping**: map who is patenting what across jurisdictions for an assignee or CPC area.
- **Competitive intelligence**: watch a competitor's newest filings with `sort: new` on a schedule.
- **M\&A and freedom-to-operate**: pull full claims and citation networks for candidate portfolios.
- **AI agents and RAG**: clean structured patent rows for MCP clients and RAG pipelines.

### FAQ

**Which offices are covered?** Any office indexed on Google Patents: USPTO, EPO, WIPO, JPO, KIPO, CNIPA, DPMA and 100+ more, selected by `countryCodes`.

**Does it need an API key or account?** No. Provide an input, run it, read the dataset.

**What is the difference between basic and deep?** Basic is one fast row per patent from search results. Deep fetches each patent's complete record: full abstract, claim texts, backward and forward citations with totals, and CPC codes. Deep is per-patent work, so it costs the same per record but takes longer.

**Can I fetch details for patents I found elsewhere?** Yes. Switch to `details` mode with a list of publication numbers.

**How large can a run be?** Up to 1,000 records per run. Pagination stops exactly at `maxItems`, so you are never billed for rows you did not ask for.

**What date does dateFrom/dateTo filter on?** Priority date, the earliest claimed filing date of the patent family.

# Actor input Schema

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

search: discover patents by free-text query with filters. details: fetch full records (claims, citations, CPC) for specific patent IDs.

## `searchQuery` (type: `string`):

Free-text patent query. Supports quoted phrases, boolean operators and wildcards, e.g. '"solid state battery" electrolyte'. Required in search mode.

## `patentIds` (type: `array`):

Patent publication numbers for details mode, e.g. US10517421B2, EP3612345A1. Ignored in search mode.

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

Restrict to patent office codes: US, EP, WO, JP, CN, KR, DE and more. Empty means all offices.

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

Granted patents only, pending applications only, or any.

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

Utility patents, design patents, or any.

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

Only patents with priority date on or after this date. Empty means no lower bound.

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

Only patents with priority date on or before this date. Empty means no upper bound.

## `sort` (type: `string`):

Sort by relevance (default) or newest first.

## `depth` (type: `string`):

Basic returns one row per patent from search results. Deep additionally fetches each patent's full record: complete abstract, claim texts, backward and forward citations with totals, and CPC codes.

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

Hard cap on dataset items saved. Pagination stops exactly at this count; extra rows are never fetched or billed.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "solid state battery",
  "patentIds": [
    "US10517421B2"
  ],
  "countryCodes": [],
  "status": "",
  "patentType": "",
  "sort": "",
  "depth": "basic",
  "maxItems": 10
}
```

# Actor output Schema

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

URL to the dataset items: one clean JSON row per patent, with title, abstract, dates, assignee, inventors, office and kind codes, patent and PDF links; deep mode adds claim texts, backward and forward citations with totals, 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 = {
    "searchQuery": "solid state battery",
    "patentIds": [
        "US10517421B2"
    ],
    "countryCodes": [],
    "dateFrom": "",
    "dateTo": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("red.cars/google-patents-search-pro").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 = {
    "searchQuery": "solid state battery",
    "patentIds": ["US10517421B2"],
    "countryCodes": [],
    "dateFrom": "",
    "dateTo": "",
}

# Run the Actor and wait for it to finish
run = client.actor("red.cars/google-patents-search-pro").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 '{
  "searchQuery": "solid state battery",
  "patentIds": [
    "US10517421B2"
  ],
  "countryCodes": [],
  "dateFrom": "",
  "dateTo": ""
}' |
apify call red.cars/google-patents-search-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,red.cars/google-patents-search-pro"
        }
    }
}
```

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/yndQfcoZSttZYkv0n/builds/qxL3o5i4l2RLpQ8EC/openapi.json