Google Patents Scraper: Search, Claims, Citations, Family
Pricing
from $1.08 / 1,000 patent from searches
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
Maintained by CommunityActor stats
0
Bookmarked
2
Total users
1
Monthly active users
9 days ago
Last modified
Categories
Features
Share
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 incpc_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
includeDetailsfor 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.
How it compares
| Actor | Search rows per 1,000 (Free plan) | Detailed rows per 1,000 (Free plan) | Start fee | Legal events and expiry | Litigation cases |
|---|---|---|---|---|---|
| This actor | $1.80 | $4.50 | $0.003 per run | Yes | Yes |
| Google Patents Scraper: Search, Citations, Family Graph | $2.00 | $5.00 | $0.00005 | Grant status only (stated) | not stated |
| Google Patents Intelligence | $2.00 | $8.00 | $0.01 | Legal status (stated) | not stated |
| Google Patents Search, Portfolio & Citation Scraper | $2.00 | $5.00 | $0.005 | Yes (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.
assigneesandinventorsrun 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.
cpcCodesnarrows any search to classes such asH01M10/0562(solid electrolytes), or on its own lists every patent in those classes. - Citations both ways.
citationsandcited_bylist each patent with its assignee, dates, title and whether the examiner added it;cited_patent_idsandcited_by_patent_idsgive 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
Prior art or landscape search
{"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
| Parameter | Type | Default | What it does |
|---|---|---|---|
searchQueries | array of strings | empty | Keywords, one search each, in Google Patents syntax. |
assignees | array of strings | empty | Company or owner names, one search each. |
inventors | array of strings | empty | Inventor names, one search each. |
patentIds | array of strings | empty | Publication numbers to look up directly, with details. |
startUrls | array of strings | empty | patents.google.com search links (kept with their own filters) or patent links. |
maxItems | integer | 50 | Most patents per search, 1 to 1,000. |
includeDetails | boolean | false | Opens each patent page for abstract, claims, CPC, citations, family, legal status and legal events. |
includeFullText | boolean | false | With details, adds every claim and the full description. |
countries | array of strings | empty | Office codes to keep, for example US, EP, WO, CN. |
cpcCodes | array of strings | empty | CPC classes to keep (joined with OR). |
status | string | ANY | GRANT or APPLICATION. |
patentType | string | ANY | PATENT (utility) or DESIGN. |
dateType | string | priority | Which date the range filters on: priority, filing or publication. |
dateFrom, dateTo | string | empty | Date range, YYYY-MM-DD. |
sortBy | string | relevance | new or old for date order. |
onlyLitigated | boolean | false | Only patents Google Patents marks as litigated. |
skipSimilarDocuments | boolean | false | Drops documents Google Patents adds as similar to your terms rather than direct matches. |
detailLanguage | string | en | Language 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.
| Field | What it is |
|---|---|
patent_id | Publication number, e.g. US10000000B2, the key to join on |
title, snippet, abstract | Title (shortened in search data, full with details), the result text, the abstract (details) |
country_code, country_name, kind_code, publication_type | Office, kind code and what it means |
application_number, priority_applications | Application and priority application numbers (details) |
priority_date, filing_date, publication_date, grant_date, expiration_date | Dates, YYYY-MM-DD |
legal_status | Active, Expired, Pending, Ceased and so on (details) |
inventors, assignee, assignees_current, assignees_original | People and owners |
cpc, cpc_codes, cpc_main | CPC leaf classes with descriptions, the plain codes, and the first code (details) |
prior_art_keywords | Keywords Google Patents lists (details) |
claims_count, independent_claims_count, first_claim | Claims (details); claims and description with includeFullText |
family_id, family_members, family_members_count, family_countries, family_applications | The family across offices (details) |
family_country_status | Family status per office from search data |
citations, cited_by, citations_count, cited_by_count, cited_patent_ids, cited_by_patent_ids | Patent 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_count | More citation counts (details) |
similar_documents | Similar documents Google Patents lists (details, first 20) |
events, legal_events, legal_events_count, last_legal_event | Timeline and office legal events with codes (details) |
litigation_cases, litigation_cases_count | Litigation listed on the page (details) |
pdf_url, thumbnail_url, url | PDF, first drawing, Google Patents page |
is_similar_document | Added by Google Patents as similar, not a direct match |
details_scraped, details_error | Whether the patent page was read, and why not |
search, search_type, search_url, total_results, page, position, source, requested_id | Where the row came from |
scraped_at | When 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.
| Event | When it is charged | Free plan | Bronze (Starter) | Silver (Scale) | Gold (Business) |
|---|---|---|---|---|---|
patent-found | Once 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-detailed | Once 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-start | Once 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
- Open the actor in Apify Console, set your input (for example a competitor in
assignees,sortBynew) and click Save as a new task. - In the task, open Schedules, click Add schedule and pick how often (every Monday at 08:00 and so on).
- Compare runs on
patent_idto see new filings, and onlegal_statusorlast_legal_eventto see status changes. - 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.
Why is the legal status or expiry missing on some patents?
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.
Is it legal to scrape Google Patents?
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
- Company Domain Finder
- GST Taxpayer Lookup
- Company KYB Resolver
- SEC EDGAR Filings Scraper
- EU VAT Checker (VIES)
- Tech Stack Detector
- Bundesanzeiger Scraper
- Domain to LinkedIn URL Resolver
- World Bank Trade Scraper
- US Import Records
- Y Combinator Scraper
- Norway Company Register
Social media and video
Leads and business directories
Marketing, SEO and reviews
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.

