Google Patents Scraper: Search, Claims, Citations, Family avatar

Google Patents Scraper: Search, Claims, Citations, Family

Pricing

from $1.08 / 1,000 patent from searches

Go to Apify Store
Google Patents Scraper: Search, Claims, Citations, Family

Google Patents Scraper: Search, Claims, Citations, Family

Search Google Patents worldwide by keyword, company, inventor or CPC, or look up patent numbers: assignee, inventors, priority, filing, grant and expiry dates, legal status, CPC, abstract, claims, citations, cited by, family and legal events. 100+ patent offices. No login.

Pricing

from $1.08 / 1,000 patent from searches

Rating

0.0

(0)

Developer

The Mine Works

The Mine Works

Maintained by Community

Actor stats

0

Bookmarked

2

Total users

1

Monthly active users

9 days ago

Last modified

Features

Limited permissions

Share

Google Patents search and full patent records from 100+ patent offices, one row per patent

Returns Google Patents results from more than 100 patent offices (US, EP, WO, CN, JP, KR, DE and the rest), one row per patent: number, title, assignee, inventors, priority, filing, publication, grant and expiry dates, legal status, and with details on the abstract, CPC classes, claims, citations, cited by, family members and legal events. Search by keywords, company, inventor or CPC class, paste a patents.google.com link, or give a list of patent numbers. No login, no cookies, no API key. You pay $1.80 per 1,000 patents from search and $4.50 per 1,000 patents with full details on the Free plan, and $1.08 and $2.70 per 1,000 on the Gold plan, plus a $0.003 start fee per run.

Part of The Mine Works Company and business data family: Company Domain Finder, GST Taxpayer Lookup, Company KYB Resolver, SEC EDGAR Filings Scraper, EU VAT Checker (VIES), Tech Stack Detector.

Updated 12 Nov 2026: first release. Bookmark this Actor on its Store page so it is one click away next time.

Why choose this actor?

  • One row per patent, ready to filter. Dates as YYYY-MM-DD, the main CPC class in cpc_main, counts as numbers (claims_count, citations_count, cited_by_count, family_members_count), and the assignee as Google Patents lists it today.
  • Worldwide, with the filters you know. Office codes, granted or applications, utility or design, priority, filing or publication date range, CPC classes, litigation only, newest or oldest first. Any search link you copy from patents.google.com works as it is.
  • Full records when you need them. Turn on includeDetails for the abstract, claim 1, the number of independent claims, all CPC leaf classes, every citation and citing patent with its assignee and dates, the family across offices, expiry, the timeline and the office legal events. 186 detailed patents in our Apify test runs came back with 0 failed pages.
  • Pay for what you get. A search row costs less than a detailed row; a patent page that fails to open is billed as a search row; error, summary and duplicate rows are never charged.

Run it on Apify

How it compares

ActorSearch rows per 1,000 (Free plan)Detailed rows per 1,000 (Free plan)Start feeLegal events and expiryLitigation cases
This actor$1.80$4.50$0.003 per runYesYes
Google Patents Scraper: Search, Citations, Family Graph$2.00$5.00$0.00005Grant status only (stated)not stated
Google Patents Intelligence$2.00$8.00$0.01Legal status (stated)not stated
Google Patents Search, Portfolio & Citation Scraper$2.00$5.00$0.005Yes (stated)not stated

Checked 12 Nov 2026 from the public Store listings.

Try it in one minute

Paste this into the input (JSON view) and press Start. It returns 20 patents about solid state batteries with full details. It took 7 seconds in our Apify test run:

{
"searchQueries": ["solid state battery"],
"maxItems": 20,
"includeDetails": true
}

Apify's free plan includes $5 of credit every month, which covers about 1,100 detailed patents or 2,700 search rows at this actor's price.

Copy to your AI assistant

themineworks/google-patents-scraper on Apify. Searches Google Patents (100+ patent offices) and returns one flat row per patent publication, no login. Call ApifyClient("TOKEN").actor("themineworks/google-patents-scraper").call(run_input={"searchQueries": ["solid state battery"], "maxItems": 50, "includeDetails": true}), then client.dataset(run["defaultDatasetId"]).list_items().items. Inputs (all optional, give at least one of searchQueries, assignees, inventors, cpcCodes, patentIds, startUrls): searchQueries (list, Google Patents query syntax), assignees (list of company names), inventors (list), patentIds (list of publication numbers like US10000000B2, always returned with details), startUrls (patents.google.com search or patent links), cpcCodes (list like H01M10/0562), countries (list of office codes like US, EP, WO, CN), status (ANY, GRANT, APPLICATION), patentType (ANY, PATENT, DESIGN), dateType (priority, filing, publication), dateFrom and dateTo (YYYY-MM-DD), sortBy (relevance, new, old), onlyLitigated (bool), skipSimilarDocuments (bool), maxItems (1 to 1000 per search, default 50), includeDetails (bool, default false), includeFullText (bool, adds claims and description), detailLanguage (default en). Patent rows have no _type field and carry patent_id, title, snippet, abstract, country_code, kind_code, application_number, priority_date, filing_date, publication_date, grant_date, expiration_date, legal_status, inventors, assignee, assignees_current, assignees_original, cpc, cpc_codes, cpc_main, claims_count, independent_claims_count, first_claim, family_id, family_members, family_members_count, family_countries, citations, cited_by, citations_count, cited_by_count, non_patent_citations_count, events, legal_events, litigation_cases, pdf_url, url, is_similar_document, details_scraped, search, search_type, total_results, page, position, scraped_at. Each run also writes one row with _type "summary" and a row with _type "error" for each input that could not be read; neither is charged. Full spec: GET https://api.apify.com/v2/acts/themineworks~google-patents-scraper/builds/default (Bearer TOKEN), which returns inputSchema and readme. Token: https://console.apify.com/account/integrations?fpr=ymnoit&utm_source=apify-readme&utm_medium=referral

Key features

  • Keywords in Google Patents syntax. Quotes, AND, OR, NOT and wildcards work the same as in the patents.google.com search box. Each term is its own search, labelled in search.
  • Company and inventor portfolios. assignees and inventors run one search per name with your filters, for example every granted US patent of one company with a priority date after 2022.
  • Patent numbers in any common form. US10000000B2, US-10,000,000-B2, EP3268771 (no kind code) and patent links all work. Every number comes back with full details.
  • CPC classes. cpcCodes narrows any search to classes such as H01M10/0562 (solid electrolytes), or on its own lists every patent in those classes.
  • Citations both ways. citations and cited_by list each patent with its assignee, dates, title and whether the examiner added it; cited_patent_ids and cited_by_patent_ids give the plain lists for graph tools.
  • Family and status. family_id, every family publication, the family per office with a representative number, each family application with its status and expiry, and the office legal events (fee payments, assignments, lapses) with their codes.
  • Stops cleanly. Google Patents answers bursts with a rate limit page; each try goes out on a new IP, 4 tries in all. 6 failed pages in a row end the run; the run stops before its time limit and keeps every row. The summary row says why.

How to use it

{
"searchQueries": ["\"large language model\" training"],
"countries": ["US", "EP", "CN"],
"dateFrom": "2023-01-01",
"maxItems": 100,
"includeDetails": true
}

In our test this returned 100 detailed patents in 80 seconds. Sort by cited_by_count to find the ones later filings lean on.

A competitor's portfolio

{
"assignees": ["Tesla"],
"countries": ["US"],
"status": "GRANT",
"dateFrom": "2022-01-01",
"sortBy": "new",
"maxItems": 500,
"includeDetails": true
}

Google Patents matches the name loosely, so assignee shows the exact owner on each row (Tesla Inc, Tesla Subsea Inc and so on); filter on it.

Look up a list of patent numbers

{
"patentIds": ["US10000000B2", "EP3268771B1", "WO2016144528A1", "CN115732737B"]
}

40 mixed numbers from 6 offices took 12 seconds in our test, 40 of 40 found.

Fast export of a whole class

{
"cpcCodes": ["H01M10/0562"],
"countries": ["CN", "JP", "KR"],
"maxItems": 1000
}

Search rows only: number, title, snippet, dates, assignee, inventors, PDF link and family status per office. 300 rows took a few seconds in our test.

Input parameters

ParameterTypeDefaultWhat it does
searchQueriesarray of stringsemptyKeywords, one search each, in Google Patents syntax.
assigneesarray of stringsemptyCompany or owner names, one search each.
inventorsarray of stringsemptyInventor names, one search each.
patentIdsarray of stringsemptyPublication numbers to look up directly, with details.
startUrlsarray of stringsemptypatents.google.com search links (kept with their own filters) or patent links.
maxItemsinteger50Most patents per search, 1 to 1,000.
includeDetailsbooleanfalseOpens each patent page for abstract, claims, CPC, citations, family, legal status and legal events.
includeFullTextbooleanfalseWith details, adds every claim and the full description.
countriesarray of stringsemptyOffice codes to keep, for example US, EP, WO, CN.
cpcCodesarray of stringsemptyCPC classes to keep (joined with OR).
statusstringANYGRANT or APPLICATION.
patentTypestringANYPATENT (utility) or DESIGN.
dateTypestringpriorityWhich date the range filters on: priority, filing or publication.
dateFrom, dateTostringemptyDate range, YYYY-MM-DD.
sortBystringrelevancenew or old for date order.
onlyLitigatedbooleanfalseOnly patents Google Patents marks as litigated.
skipSimilarDocumentsbooleanfalseDrops documents Google Patents adds as similar to your terms rather than direct matches.
detailLanguagestringenLanguage of the patent page text.

Up to 100 searches and 5,000 patent numbers per run. The filters apply to every search built from searchQueries, assignees, inventors and cpcCodes.

What data do you get?

One row per patent publication. Patent rows have no _type field; the summary and error rows do, so a filter on _type separates them.

FieldWhat it is
patent_idPublication number, e.g. US10000000B2, the key to join on
title, snippet, abstractTitle (shortened in search data, full with details), the result text, the abstract (details)
country_code, country_name, kind_code, publication_typeOffice, kind code and what it means
application_number, priority_applicationsApplication and priority application numbers (details)
priority_date, filing_date, publication_date, grant_date, expiration_dateDates, YYYY-MM-DD
legal_statusActive, Expired, Pending, Ceased and so on (details)
inventors, assignee, assignees_current, assignees_originalPeople and owners
cpc, cpc_codes, cpc_mainCPC leaf classes with descriptions, the plain codes, and the first code (details)
prior_art_keywordsKeywords Google Patents lists (details)
claims_count, independent_claims_count, first_claimClaims (details); claims and description with includeFullText
family_id, family_members, family_members_count, family_countries, family_applicationsThe family across offices (details)
family_country_statusFamily status per office from search data
citations, cited_by, citations_count, cited_by_count, cited_patent_ids, cited_by_patent_idsPatent citations both ways (details, lists capped at 200; the counts are not)
examiner_citations_count, non_patent_citations_count, family_cites_count, family_cited_by_countMore citation counts (details)
similar_documentsSimilar documents Google Patents lists (details, first 20)
events, legal_events, legal_events_count, last_legal_eventTimeline and office legal events with codes (details)
litigation_cases, litigation_cases_countLitigation listed on the page (details)
pdf_url, thumbnail_url, urlPDF, first drawing, Google Patents page
is_similar_documentAdded by Google Patents as similar, not a direct match
details_scraped, details_errorWhether the patent page was read, and why not
search, search_type, search_url, total_results, page, position, source, requested_idWhere the row came from
scraped_atWhen the row was written

Summary row (_type: "summary", never charged): searches and numbers requested, read and failed, pages read, patents delivered with and without details, duplicates and similar documents skipped, HTTP requests and retries, shortfall_reason when fewer patents came back than asked, and per_search with total_results, pages, patents delivered and why each search stopped. The same summary is saved as the OUTPUT record of the run.

Error rows (_type: "error", never charged): one per input that could not be read, with error_type (invalid_input, not_found, blocked, fetch_error), identifier and reason.

Stable fields for automations

Present in every patent row of our Apify test runs (769 rows from 6 runs), names will not change: patent_id, title, country_code, publication_date, url, details_scraped, source. With details on, also in every row: assignee, legal_status, family_id, citations_count, cited_by_count, legal_events_count.

Optional, filled when Google Patents shows them: abstract (171 of 186 detailed rows; B publications of the EPO carry none), cpc_codes (176 of 186; some new CN applications have no classes yet), claims_count (184 of 186), grant_date (granted patents), expiration_date (28 of 186; mostly US), independent_claims_count (offices whose claims mark references).

Output examples

A detailed patent (patent number lookup, test run 12 Nov 2026, trimmed):

{
"patent_id": "US10000000B2",
"title": "Coherent LADAR using intra-pixel quadrature detection",
"country_code": "US",
"kind_code": "B2",
"application_number": "US14/643,719",
"priority_date": "2015-03-10",
"filing_date": "2015-03-10",
"publication_date": "2018-06-19",
"grant_date": "2018-06-19",
"expiration_date": "2036-05-13",
"legal_status": "Active",
"inventors": ["Joseph Marron"],
"assignee": "Raytheon Co",
"cpc_main": "G01S7/4863",
"cpc_codes": ["G01S7/4863", "G01S13/89", "G01S7/4865", "G01S7/4914", "G01S7/4917", "G01S17/894"],
"claims_count": 20,
"independent_claims_count": 3,
"family_id": "55456961",
"family_members_count": 14,
"citations_count": 5,
"cited_by_count": 22,
"non_patent_citations_count": 7,
"litigation_cases_count": 5,
"legal_events_count": 5,
"last_legal_event": { "date": "2025-11-19", "code": "MAFP", "title": "Maintenance fee payment" },
"pdf_url": "https://patentimages.storage.googleapis.com/c0/d5/f7/86ad5b42759506/US10000000.pdf",
"url": "https://patents.google.com/patent/US10000000B2/en",
"details_scraped": true,
"source": "patent_id"
}

A search row from a pasted link (same day, trimmed):

{
"patent_id": "EP3998493B1",
"title": "Laser system for lidar",
"country_code": "EP",
"kind_code": "B1",
"priority_date": "2019-04-02",
"publication_date": "2023-08-16",
"grant_date": "2023-08-16",
"inventors": ["Zhengqing PAN"],
"assignee": "Hesai Technology Co., Ltd.",
"pdf_url": "https://patentimages.storage.googleapis.com/50/99/28/e6b2777155d4d7/EP3998493B1.pdf",
"family_country_status": [
{ "country_code": "EP", "status": "ACTIVE" },
{ "country_code": "US", "status": "ACTIVE" },
{ "country_code": "CN", "status": "ACTIVE" }
],
"is_similar_document": false,
"details_scraped": false,
"search_type": "url",
"total_results": 122672,
"page": 1,
"position": 88
}

An error row for a number that is not a patent number (nothing charged):

{ "_type": "error", "error_type": "invalid_input", "identifier": "XX", "reason": "Not a patent publication number. Use the form US10000000B2, EP3268771B1 or WO2016144528A1." }

Pricing

Pay per event: you pay for the patents you receive, plus a flat $0.003 per run, whatever memory you choose.

EventWhen it is chargedFree planBronze (Starter)Silver (Scale)Gold (Business)
patent-foundOnce per patent row from search data$1.80 per 1,000$1.52 per 1,000$1.28 per 1,000$1.08 per 1,000
patent-detailedOnce per patent row whose patent page was read$4.50 per 1,000$3.79 per 1,000$3.20 per 1,000$2.70 per 1,000
run-startOnce per run, after the first patents came back$0.003$0.003$0.003$0.003

A row is charged once, as one of the two events, never both.

Never charged:

  • inputs that cannot be read (each gets an error row) and patent numbers Google Patents does not have;
  • a patent that a second search of the same run finds again;
  • similar documents you chose to skip and patents past your maxItems;
  • the summary and error rows;
  • a run with no valid input, or one whose searches find nothing: the start fee is charged only once patents came back;
  • anything past your "Max cost per run". The actor checks the budget before each batch of rows and stops while the total is still below your limit, so the run ends SUCCEEDED with a partial result and a status message saying so.

Run it on a schedule

  1. Open the actor in Apify Console, set your input (for example a competitor in assignees, sortBy new) and click Save as a new task.
  2. In the task, open Schedules, click Add schedule and pick how often (every Monday at 08:00 and so on).
  3. Compare runs on patent_id to see new filings, and on legal_status or last_legal_event to see status changes.
  4. Optional: add an integration (Google Sheets, Slack, a webhook) so each run lands where your team works.

FAQ

What does this actor read?

Google Patents' public search results and public patent pages, as anyone sees them at patents.google.com without logging in. Google Patents gathers publications from more than 100 patent offices.

How many patents can I get?

Up to 1,000 per search, because Google Patents itself shows at most 1,000 results for one search. For more, split by date range (dateFrom, dateTo) or by office (countries); each split is its own search. Up to 100 searches and 5,000 patent numbers per run.

What is the difference between search rows and detailed rows?

Search rows come from the results list: number, title (shortened for long titles), snippet, dates, assignee, inventors, PDF and family status per office. Detailed rows add everything on the patent page: abstract, claims, CPC, citations both ways, family, legal status, expiry, timeline and legal events. Patent numbers are always detailed.

What are similar documents?

For keyword searches Google Patents mixes in documents it finds similar to your terms. They have is_similar_document: true. Set skipSimilarDocuments to keep direct matches only; skipped documents are not charged.

Google Patents gives an expected expiry mainly for US patents, and its legal status is an estimate, not a legal conclusion. The actor returns what the page shows and leaves the field out when the page has none.

How long does a run take?

In our Apify tests: 7 seconds for the "Try it" input (20 detailed patents), 80 seconds for 100 detailed patents, 12 seconds for 40 patent numbers plus 300 search rows, 8 seconds for 283 search rows across 3 pages.

Do I need an account, cookies or an API key?

No account, no cookies and no API key. The actor reads public pages over Apify Proxy, which is included in the price. Nothing to set up.

Patent publications are public documents that patent offices publish so anyone can read them, and the actor reads only what patents.google.com shows to every visitor. You are responsible for how you use the data, including Google's terms. This is general information, not legal advice; patentability and freedom to operate calls belong to a patent attorney.

Which formats can I download?

JSON, CSV, Excel, XML, RSS and HTML from the run's Storage tab or through the API. The dataset has two ready views: Patents, and Claims, CPC and citations. In CSV and Excel, lists such as cpc_codes are flattened into columns such as cpc_codes/0.

Can I use it from Claude, ChatGPT or Cursor (MCP)?

Yes, through Apify's MCP server. Connector URL: https://mcp.apify.com/?tools=themineworks/google-patents-scraper

  • Claude: Settings > Connectors > Add custom connector, paste the URL, sign in with Apify.
  • ChatGPT: turn on developer mode, add an MCP connector with the URL, sign in with Apify.
  • Cursor or VS Code: add it as an HTTP MCP server with that URL.
  • Claude Code: claude mcp add -t http google-patents-scraper "https://mcp.apify.com/?tools=themineworks/google-patents-scraper"

Integrations

  • Google Sheets: send each run's patents to a sheet with Apify's Google Sheets integration.
  • Make, Zapier and n8n: start a run and read its dataset with the Apify apps and nodes, for example "new patents of these 5 competitors every Monday to Slack".
  • Webhooks: have Apify call your URL when a run succeeds, then fetch the dataset.
  • API and SDKs: run it from Python or JavaScript with the Apify client, or with a plain HTTP call (see "Copy to your AI assistant" above).
  • MCP clients: Claude, ChatGPT, Cursor and VS Code can run it as a tool through the connector URL in the FAQ.

If this actor saved you time, a short rating on the Store helps other buyers find it.

More from The Mine Works

Company and business data

Social media and video

Leads and business directories

Marketing, SEO and reviews

LinkedIn

Real estate

Science, health and government data

Jobs and hiring

E-commerce and marketplaces

Food and local services

Developer and AI tools

More tools

Support

Open an issue on the actor's Issues tab with the run link and the input you used, and we will look at it.