Google Patents Search Scraper

Google Patents Search Scraper exports public patent search results and detail metadata from queries, Google Patents URLs, or publication IDs. Collect titles, inventors, assignees, dates and source links for prior-art discovery and IP research, then download CSV, Excel or JSON.

Search snapshots and detail lookups have different field coverage. Abstracts, classifications and citations depend on available detail pages. This Actor does not extract full claims or expand patent-family graphs.

Quick start

Open the input, replace the sample queries and clear any unwanted sample patent IDs. Start with an explicit small limit:

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

Run the Actor, then open its dataset to view or export records. Provide at least one query or patent URL/ID. When both are supplied, direct patent inputs are processed first and share the same record limit.

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

Ready-to-run examples

Choose a public example to see its settings before starting a run:

• Fast Google Patents search export
• Build an EV charging patent dataset
• Extract metadata from patent IDs

What you get

One row per unique patent publication, with its ID, source URL and available title and search metadata. Optional detail lookups can add abstracts, contributor lists, classifications, limited citation values and document links. Search-only and direct-only records have different field coverage, with unknown values kept as null or empty arrays.

Who is it for?

• Patent researchers assembling bounded candidate lists for source-page review.
• R&D analysts exploring technologies and named assignees with Google Patents query syntax.
• IP data teams connecting known publication IDs to available public detail metadata.
• Technology researchers retaining source-backed records for further expert analysis.

How you can use the data

• Review a Tesla battery search sample. Use the existing assignee query with a five-record cap and details enabled. Keep patentId, patentTitle, patentUrl and available contributor fields together, then open the source before relying on attribution.
• Look up a known publication directly. Use the existing US10000000B2 URL with a one-record cap and no query. Direct inputs fetch details but do not acquire search-only snippet, language, status or priority/publication-date fields.
• Choose a lightweight search export or a detail-enriched sheet. Disable optional details for search snapshots, or enable them for available abstracts, classifications and citation values. A retained search row with warnings remains distinct from a complete detail record.
• Join by publication identity in your own research. Keep patentId, source, scrapedAt and warnings. Direct lookups run first under the shared cap, and duplicate publication IDs are saved once. Treat saved-set rank as collection position rather than a per-query relevance score, and do not infer legal status or patent-family completeness.

Input settings

Setting	JSON key	Purpose
Search queries	queries	Search text or operators such as assignee:(Tesla) and inventor:(Smith).
Patent URLs or IDs	patentUrls	Direct publication lookups, processed before queries.
Maximum patent records	maxItems	Total saved-row cap across all inputs. Set an explicit value for API calls.
Include detail-page metadata	includeDetails	Add available detail fields to search records. Direct lookups always fetch details.
Proxy configuration	proxyConfiguration	Optional connection settings. Direct access is the default. See field help for supported settings.

For a known patent, use this alternative input. No search query is needed:

{
  "queries": [],
  "patentUrls": ["https://patents.google.com/patent/US10000000B2/en"],
  "maxItems": 1,
  "includeDetails": true
}

Output data

Each saved row represents one patent publication. Duplicate publication IDs are saved only once across a run. rank is the position in the saved set, not a separate ranking for each query.

Illustrative shape only, not an observed patent record. The excerpt omits other fields:

{
  "query": "solar panel",
  "rank": 1,
  "patentId": "US10000000B2",
  "patentUrl": "https://patents.google.com/patent/US10000000B2/en",
  "patentTitle": null,
  "abstract": null,
  "classifications": [],
  "citations": [],
  "source": "search",
  "warnings": []
}

Fields	Meaning and availability
patentId, patentUrl, patentTitle	Publication ID, source page and available title.
query, rank	Originating query and saved-set position. Null for direct inputs.
snippet, abstract	Search snippet. Abstract requires available detail metadata.
inventor, assignee	Search-provided strings. Null on direct-only records.
inventors, assignees	Parsed lists. Direct lookups use available contributor metadata. Verify important attribution against the source.
priorityDate, filingDate, publicationDate, grantDate	Available date values. Detail-derived grantDate is the last page date, not a verified legal grant date.
applicationNumber, publicationNumber	Available application number and publication identifier.
language, status, jurisdictions	Search-provided language and family-level status/jurisdiction hints. Not a legal-status determination.
classifications, citations	Detail-page codes and up to 100 relation values. Not a complete forward/backward citation network.
pdfUrl, thumbnailUrl	Available links, not downloaded PDF/image files.
source, scrapedAt, warnings	search or detail, collection time and any optional-enrichment warnings.

Direct-only records do not gain search-only fields such as snippet, priority/publication dates, language or status. Missing values remain null or empty arrays.

Download your results

Open your run's dataset, choose Export and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See Apify's download and export guide for the available formats and field options.

Pricing

Pay-per-event pricing uses a one-time run-start start event and an item charge for each saved patent record, including a search record retained with an enrichment warning. Failed direct lookups do not save empty records.

See the live Pricing tab for current rates.

Tips for best results

• Set a small explicit shared record cap. Direct patent inputs run before queries, so include only the direct lookups you intend to collect first.
• Choose optional detail coverage deliberately. Search snapshots are lighter, while available abstracts, classifications and citations require details.
• Keep warnings with retained search rows. An optional detail failure does not necessarily invalidate the useful search metadata.
• Inspect source pages for important attribution and dates. Parsed contributors and date labels are research leads rather than verified legal conclusions.
• Check the summary before repeating unfinished work. Pending scopes are diagnostic information rather than an automatic resume feature.

Limits and caveats

Google can throttle requests or omit metadata, and the saved-row cap does not guarantee that many matches. Optional detail failures can leave search records intact with warnings. Valid searches without matches can return an empty dataset, while all attempted sources failing with no saved records causes run failure. Failed direct lookups do not become empty dataset records.

Search-only records and direct lookups expose different fields. Direct-only records lack search-provided snippet, priority/publication dates, language and status. Important contributor attribution should be checked at the source. Missing values remain null or empty arrays.

The Actor does not extract full claims, traverse patent-family graphs or download PDF and image files. Citation output contains up to one hundred relation values rather than a complete forward/backward network. Search-provided status and jurisdictions are family-level hints, not legal-status determinations. A detail-derived grantDate is the last page date rather than a verified legal grant date.

RUN_SUMMARY normally records saved counts, warnings and failures, and time-bounded unfinished scopes may appear in PENDING_WORK. This does not provide automatic resumption, and storage failures can prevent those records from being written. This independent public metadata tool requires no Google login or API key and is not an official patent-office service or legal advice.

Automation and integrations

Save your settings for next time

Once you have an input that works for you, save it as an Apify task. This keeps your settings together so you can use them again without filling in the form from scratch.

Run on a schedule

Need fresh results regularly? You can schedule the Actor or a saved task to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

Send results to your other tools

Use n8n, Make or Zapier to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the Apify integration guides for your chosen tool.

For a custom connection, an Apify webhook can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its defaultDatasetId to fetch the results.

For setup instructions, see Apify's JavaScript client guide, Python client guide and Actor runs API reference.

cURL

curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~google-patents-search-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  --data @- <<'JSON'
{
  "queries": [
    "assignee:(Tesla) battery"
  ],
  "patentUrls": [],
  "maxItems": 5,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
JSON

Node.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"
  ],
  "patentUrls": [],
  "maxItems": 5,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/google-patents-search-scraper').call(run_input={'queries': ['assignee:(Tesla) battery'], 'patentUrls': [], 'maxItems': 5, 'includeDetails': True, 'proxyConfiguration': {'useApifyProxy': False}})
print(client.dataset(run['defaultDatasetId']).list_items().items)

API usage notes

The HTTP endpoint starts an asynchronous run. Wait for completion and use the returned defaultDatasetId to retrieve results.

MCP and AI agents

You can ask your AI assistant to collect data with Google Patents Search Scraper and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the Apify MCP server. MCP gives your assistant a way to find this scraper, run it and read the results. Follow the official setup and sign-in guide for your app.

Easier setup with an Apify plugin

If you use a supported coding assistant, the official Apify plugin can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

Use Apify AI in Console

Prefer to keep everything in Apify? Open Apify AI in Console and ask it to find Fetch Cat's Google Patents Search Scraper. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

Choose your assistant

• Claude and Claude Code (Anthropic): Apify setup guide.
• ChatGPT and Codex (OpenAI): Apify setup guides.
• Grok Bot (xAI): Apify plugin guide.
• Gemini CLI (Google): MCP server setup guide. Use the server URL below with the HTTP configuration supported by Gemini CLI.

Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

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

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

Use Apify's general server

Already connected to the general Apify MCP server at https://mcp.apify.com? You can use it to find this scraper without adding another server. Ask your assistant to use Google Patents Search Scraper by Fetch Cat, or give it the identifier fetch_cat/google-patents-search-scraper.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

Example requests

• “Use Fetch Cat’s Google Patents Search Scraper to collect up to 5 publications for assignee:(Tesla) battery with detail metadata enabled. Show source links and available titles, abstracts and contributor lists, keeping enrichment warnings.”
• “Retrieve the known publication US10000000B2 through its Google Patents URL with no search query and a one-record cap. Show available detail metadata and leave search-only fields unknown.”
• “Collect up to 3 publications for inventor:(Smith) battery with optional search details disabled. Keep publication IDs, source links and saved-set positions for source review, without claiming a complete patent landscape or a legal-status conclusion.”

Normal Apify charges apply. Check the live Pricing tab before asking your assistant to run a larger batch.

Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through x402. This experimental option lets an agent use Apify without a conventional account.

Apify AGI provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

Other ways for agents to pay

Apify also supports MPP for prepaid access through AGI and Skyfire for eligible Actors. If your agent already uses one of these, see the agentic payment guide to choose the right setup.

FAQ

Can I search Google Patents by inventor or assignee?

Yes. Put Google Patents syntax such as inventor:(Smith) or assignee:(Tesla) in queries. Check the returned source pages for relevance.

Is this a Google Patents search API?

It is an independent Apify workflow for collecting public Google Patents metadata, callable through API or MCP. It is not an official Google API and requires no Google login or API key.

Can I export a patent dataset to CSV or Excel?

Yes. Open the run's dataset and select an export format, or retrieve JSON through the dataset API.

Why are abstracts or citations missing?

Search-only records do not contain these detail fields. Set includeDetails: true. Available detail pages can still omit values. Check row warnings and source pages before drawing conclusions.

Can I extract full claims or patent-family graphs?

No. The output is search/detail metadata, with limited citation values rather than graph traversal. For broader tools, compare their supported fields before choosing an alternative.

Related Actors

• Google Scholar Profiles Scraper — Research author profiles alongside patent research.
• Google News Scraper — Add company and technology news context.
• Google Autocomplete Scraper — Explore related search phrases.
• Bing Search Results Scraper — Find supporting public web sources with ranked Bing results rather than Google results.
• Google Trends Scraper — Collect current country-level trending topics and related news, without measuring interest in a specified technology.

Support and feedback

For custom additions or integrations, email hello@fetchcat.dev.

Found an error or have a feature request? Open an issue with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See Apify’s guide to sharing a run when reporting an issue. Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. Leave a review to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥