# Google Patents Search Scraper (`fetch_cat/google-patents-search-scraper`) Actor

Scrape Google Patents search results and patent metadata from public pages.

- **URL**: https://apify.com/fetch\_cat/google-patents-search-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Patents Search Scraper

Google Patents Search Scraper exports public patent search results and patent detail metadata from Google Patents queries, URLs, or publication IDs.

Use it for prior-art discovery, assignee monitoring, inventor research, competitive IP landscaping, and structured patent datasets for analysis.

### At a glance

- **Extracts:** patent ID, title, URL, snippet, inventor and assignee data, key dates, jurisdiction/status hints, classifications, citations, PDF URL, and scrape timestamp when available.
- **Inputs:** Google Patents queries, direct patent URLs or IDs, maximum records, detail enrichment toggle, and optional proxy settings.
- **Best for:** IP research, R\&D monitoring, patent landscape snapshots, competitive intelligence, and API-based patent collection.
- **Exports:** Apify dataset rows downloadable as CSV, JSON, Excel, or available through the API.
- **Login:** no Google account, cookies, or Google API key are required.
- **Run diagnostics:** each run writes a `RUN_SUMMARY` record with saved-row count, source warnings, and any time-bounded pending work.

### Ready-to-run examples

Use these saved Store examples as starting points. Open any example to prefill the Actor input, then adjust URLs, keywords, limits, or filters for your own run.

- **[Run multiple Google Patents searches at once](https://apify.com/fetch_cat/google-patents-search-scraper/examples/multi-query-patent-monitoring)**
- **[Fast Google Patents search export](https://apify.com/fetch_cat/google-patents-search-scraper/examples/patent-search-fast-export)**
- **[Build an EV charging patent dataset](https://apify.com/fetch_cat/google-patents-search-scraper/examples/ev-charging-patent-landscape)**
- **[Search AI medical imaging patents](https://apify.com/fetch_cat/google-patents-search-scraper/examples/ai-medical-imaging-patents)**
- **[Extract metadata from Google Patents URLs](https://apify.com/fetch_cat/google-patents-search-scraper/examples/patent-url-batch-extraction)**
- **[Extract metadata from patent IDs](https://apify.com/fetch_cat/google-patents-search-scraper/examples/known-patent-id-metadata)**
- **[View all ready-to-run examples](https://apify.com/fetch_cat/google-patents-search-scraper/examples)** (10 examples)

### What can it do?

- **Export Google Patents search results:** run public patent queries and save structured rows for analysis.
- **Enrich known patent IDs:** pass publication IDs or patent URLs to collect detail-page metadata.
- **Monitor assignees and inventors:** use Google Patents query operators to track companies, inventors, technologies, or date ranges.
- **Collect IP research fields:** save titles, assignees, inventors, dates, abstracts, classifications, citations, PDF URLs, and source links when available.
- **Use as a patent data API workflow:** run from Apify API, export CSV/Excel/JSON, schedule repeat searches, or expose the Actor to AI agents through Apify MCP.

### Common workflows

- **Search by assignee or inventor:** use Google Patents operators such as `assignee:(Company)` or `inventor:(Name)`.
- **Build patent landscape samples:** run broad technical queries with a small `maxItems`, then expand once the query is right.
- **Enrich known IDs:** paste publication IDs or Google Patents URLs into `patentUrls` and enable details.
- **Collect API-ready patent rows:** schedule repeat runs and export dataset rows into BI, notebooks, or internal databases.

### Input configuration

| Setting | JSON key | Description |
| --- | --- | --- |
| Search queries | `queries` | Google Patents search strings. You can use natural language or Google Patents syntax such as `assignee:(Tesla)`, `inventor:(Smith)`, `before:2024`, or `after:2020`. |
| Patent URLs or IDs | `patentUrls` | Direct Google Patents URLs or publication IDs such as `US7654321B2`. These are processed before query results. |
| Maximum patent records | `maxItems` | Maximum rows to save across all queries and direct inputs. |
| Include detail-page metadata | `includeDetails` | Fetch each patent detail page to add richer metadata such as abstracts, citations, classifications, PDF URLs, and additional dates. |
| Proxy configuration | `proxyConfiguration` | Optional Apify Proxy settings. Leave disabled for normal public runs; enable only if Google returns temporary errors from your network. |

### Example input

```json
{
  "queries": ["assignee:(Tesla) battery"],
  "patentUrls": ["US7654321B2"],
  "maxItems": 10,
  "includeDetails": true,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### Output fields

| Field | Description |
| --- | --- |
| `query`, `rank` | Search query and saved result rank, or null for direct patent inputs. |
| `patentId`, `patentUrl`, `patentTitle` | Normalized patent identifier, Google Patents URL, and title when available. |
| `snippet`, `abstract` | Search snippet and detail-page abstract when available. |
| `inventor`, `inventors` | Primary inventor string and parsed inventor list. |
| `assignee`, `assignees` | Primary assignee string and parsed assignee list. |
| `priorityDate`, `filingDate`, `publicationDate`, `grantDate` | Patent dates when returned by search or detail pages. |
| `applicationNumber`, `publicationNumber` | Patent application and publication numbers when available. |
| `language`, `status`, `jurisdictions` | Public language/status/jurisdiction hints from Google Patents data. |
| `classifications`, `citations` | Detail-page classification and citation values when enrichment finds them. |
| `pdfUrl`, `thumbnailUrl` | Public PDF and thumbnail URLs when exposed by Google Patents. |
| `source`, `scrapedAt` | Whether the row came from search or direct detail input, plus scrape timestamp. |
| `warnings` | Non-fatal detail-enrichment or source-quality warnings for that saved row. |

### Example output

```json
{
  "query": "assignee:(Tesla) battery",
  "rank": 1,
  "patentId": "US7654321B2",
  "patentUrl": "https://patents.google.com/patent/US7654321B2/en",
  "patentTitle": "Example battery patent title",
  "inventors": ["Example Inventor"],
  "assignees": ["Example Assignee"],
  "publicationDate": "2026-01-01",
  "classifications": ["H01M"],
  "pdfUrl": "https://patents.google.com/patent/US7654321B2/en.pdf",
  "source": "search",
  "scrapedAt": "2026-07-03T09:00:00.000Z"
}
```

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee charged when a run starts. | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Charged per patent search result or detail record produced. | $0.06193 / 1,000 | $0.05385 / 1,000 | $0.042 / 1,000 | $0.03231 / 1,000 | $0.02154 / 1,000 | $0.01508 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Tips for best results

- **Start with small limits:** test a query with 5-10 records before collecting larger samples.
- **Use Google Patents syntax:** assignee, inventor, date, and quoted phrase operators can make results much cleaner.
- **Enable details when you need richer fields:** detail enrichment is slower but can add abstracts, classifications, citations, and PDF URLs.
- **Use direct IDs for known patents:** `patentUrls` is the cleanest path when you already have publication numbers.

### Limits and caveats

- **Detail fields depend on page availability:** some patents do not expose every date, citation, PDF, or classification in the same way.
- **No full claims extraction:** this Actor collects search/detail metadata. It does not parse every claim or the full legal description text.
- **Google can throttle:** if you see temporary errors, lower volume or enable an appropriate proxy configuration.
- **Partial enrichment is visible:** if a search result is saved but its optional detail page is temporarily unavailable, the base row is retained and `warnings` explains the missing enrichment. A direct patent-ID run does not save an empty placeholder record when its detail page cannot be read.
- **Time-bounded runs preserve progress:** saved rows are written progressively. If the run stops before the platform timeout, check `RUN_SUMMARY` and `PENDING_WORK` in key-value storage for remaining scopes.
- **Patent data is informational:** verify important legal conclusions against official patent offices or counsel.

### API usage

Run from the Apify API or SDK with the same input keys shown above.

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/google-patents-search-scraper').call({
  queries: ['assignee:(Tesla) battery'],
  maxItems: 10,
  includeDetails: true
});
console.log(run.defaultDatasetId);
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/google-patents-search-scraper").call(run_input={
    "queries": ["assignee:(Tesla) battery"],
    "maxItems": 10,
    "includeDetails": True,
})
print(run["defaultDatasetId"])
```

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~google-patents-search-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["assignee:(Tesla) battery"],"maxItems":10,"includeDetails":true}'
```

### MCP and AI agents

For AI agents, use the official Apify MCP server. The focused single-Actor URL is:

```text
https://mcp.apify.com?tools=fetch_cat/google-patents-search-scraper
```

The default MCP server can search and run Actors. The focused URL exposes this Actor directly to clients that support tool-scoped MCP connections.

For Claude Code, add the focused server:

```bash
claude mcp add --transport http apify-google-patents "https://mcp.apify.com?tools=fetch_cat/google-patents-search-scraper"
```

Or add this MCP configuration to a compatible client:

```json
{
  "mcpServers": {
    "apify-google-patents": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=fetch_cat/google-patents-search-scraper"
    }
  }
}
```

Example prompts: “Find 20 public battery patents assigned to Tesla” or “extract metadata for US10000000B2 and return its citations.”

### FAQ

**Can I search by assignee or inventor?** Yes. Use Google Patents query syntax such as `assignee:(Tesla)` or `inventor:(Smith)`.

**Can I scrape a list of patent IDs?** Yes. Put publication IDs or Google Patents URLs in `patentUrls`.

**Should I enable detail enrichment?** Enable it when you need abstracts, PDF URLs, classifications, citations, or additional dates. Disable it for faster search-result snapshots.

**Why are some fields empty?** Google Patents does not expose every field for every record, and detail fields require available detail pages.

**Can I export to CSV, Excel, JSON, or API?** Yes. Use Apify dataset exports or the dataset API after the run finishes.

### Related actors

- [Google Scholar Profiles Scraper](https://apify.com/fetch_cat/google-scholar-profiles-scraper)
- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper)
- [Google Play Apps Scraper](https://apify.com/fetch_cat/google-play-apps-scraper)
- [Google Ads Transparency Center Scraper](https://apify.com/fetch_cat/google-ads-transparency-scraper)

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

### Privacy and data handling

This Actor runs with Apify limited permissions and only processes data needed for the documented run. It uses search/query inputs and public search, trend, app, patent, news, or profile results to produce the output dataset and sends requests to public Google Patents Search pages/endpoints; results are stored in Apify run storage for your account. FetchCat does not use your inputs or outputs for advertising, does not use them for model training, and does not retain them outside the Apify run except for transient support debugging when you explicitly share run details. You are responsible for using the Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs.

# Actor input Schema

## `queries` (type: `array`):

Google Patents queries. You can use natural language or Google Patents syntax such as assignee:(Tesla), inventor:(Smith), before:2024, or after:2020.

## `patentUrls` (type: `array`):

Optional direct Google Patents URLs or publication IDs such as US7654321B2. These are scraped before query results.

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

Maximum number of patent records to save across all queries and direct URLs.

## `includeDetails` (type: `boolean`):

Fetch each patent detail page to add abstracts, citations, classifications, PDF URLs, and additional dates. Slower but richer.

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

Optional Apify Proxy settings. Leave disabled for normal public Google Patents runs; enable Apify Proxy only if your network receives temporary Google errors.

## Actor input object example

```json
{
  "queries": [
    "solar panel",
    "assignee:(Tesla) battery"
  ],
  "patentUrls": [
    "US7654321B2",
    "https://patents.google.com/patent/US10000000B2/en"
  ],
  "maxItems": 20,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "solar panel",
        "assignee:(Tesla) battery"
    ],
    "patentUrls": [
        "US7654321B2",
        "https://patents.google.com/patent/US10000000B2/en"
    ],
    "maxItems": 20,
    "includeDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/google-patents-search-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 = {
    "queries": [
        "solar panel",
        "assignee:(Tesla) battery",
    ],
    "patentUrls": [
        "US7654321B2",
        "https://patents.google.com/patent/US10000000B2/en",
    ],
    "maxItems": 20,
    "includeDetails": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/google-patents-search-scraper").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 '{
  "queries": [
    "solar panel",
    "assignee:(Tesla) battery"
  ],
  "patentUrls": [
    "US7654321B2",
    "https://patents.google.com/patent/US10000000B2/en"
  ],
  "maxItems": 20,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/google-patents-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ieuO9p9joVygD3Hdu/builds/4eYKf1bmCzrABu0dK/openapi.json