Google Patents Intelligence

Scrapes patents from Google Patents with global coverage across the USPTO, EPO, WIPO, JPO, China, Korea, and 100+ other patent offices. Returns underwriting-grade factual records — patent ID, title, abstract, all inventors, current and original assignees, CPC classifications, backward + forward citation counts, claims count, legal status, PDF URL, and a deterministic summary built from the extracted facts.

Five modes: keyword search, by assignee (company), by inventor, patent details (for a specific ID list), and incremental monitoring for scheduled alerts on new filings.

Why use this actor?

• IP attorneys — monitor client portfolios, watch competitor filings, track legal status changes.
• Competitive intelligence — sweep all patents assigned to a competitor, bucket by CPC class, surface forward-citation leaders (the most-cited = most foundational).
• M&A analysts — audit a target's patent portfolio size, inventor concentration, and citation quality.
• Investor research — map pharma pipelines, semiconductor IP, or AI-model patents across a watchlist of companies.
• Academic + journalism — extract structured citations and classifications for research without manual copy-paste.
• AI / LLM training pipelines — clean, structured patent metadata ready for ingestion.

How to use it

1. Pick a mode — keyword search (most common), by_assignee (company sweep), by_inventor, details (specific IDs), or monitor (incremental, for schedules).
2. Set filters — countries (e.g. ["US", "EP"]), date range, legal status (any / granted / application / expired).
3. Pick enrichment depth — basic returns search-card fields (faster, cheaper); deep follows each result to its Google Patents detail page for the full ~20-field record (recommended).
4. Run. Export as JSON / CSV / Excel, or point a downstream pipeline at the Apify dataset API.

Input

Keyword search — simple:

{
    "mode": "search",
    "query": "quantum computing",
    "countries": ["US", "EP"],
    "enrichmentDepth": "deep",
    "maxResults": 100
}

By assignee — company sweep:

{
    "mode": "by_assignee",
    "assignees": ["Apple Inc", "NVIDIA Corp"],
    "countries": ["US"],
    "statusFilter": "granted",
    "enrichmentDepth": "deep",
    "maxResults": 500
}

By inventor:

{
    "mode": "by_inventor",
    "inventors": ["Yann LeCun"],
    "enrichmentDepth": "deep",
    "maxResults": 50
}

Patent details — specific IDs:

{
    "mode": "details",
    "patentIds": ["US10000000B2", "EP3456789A1", "WO2021123456A1"]
}

Monitor — scheduled alerts on new filings:

{
    "mode": "monitor",
    "query": "(LLM OR \"large language model\") AND attention",
    "countries": ["US", "EP", "WO"],
    "incrementalMode": true,
    "maxResults": 500
}

Output

Each row is one patent with the full factual field set:

{
    "patentId": "US8064700B2",
    "url": "https://patents.google.com/patent/US8064700B2/en",
    "scrapedAt": "2026-04-23T17:51:34.126Z",
    "title": "Method and system for character recognition",
    "abstract": "Character recognition is described. In one embodiment, it may use matched sequences rather than character shape to determine a computer-legible result.",
    "countryCode": "US",
    "applicationNumber": "US:12/721,456",
    "filingDate": "2010-03-10",
    "publicationDate": "2011-11-22",
    "priorityDate": "2004-02-15",
    "inventors": ["Martin T. King", "Dale L. Grover", "Clifford A. Kushler", "James Q. Stafford-Fraser"],
    "assigneeCurrent": "Google LLC",
    "legalStatus": "Expired - Lifetime",
    "isGranted": true,
    "cpcClassifications": ["G06F16/951", "G06F16/9538", "G06V10/10", "G06V30/10", "G06Q30/0207", "..."],
    "backwardCitationsCount": 185,
    "forwardCitationsCount": 27,
    "nonPatentCitationsCount": 136,
    "claimsCount": 18,
    "pdfUrl": "https://patentimages.storage.googleapis.com/ec/04/0e/f4e7ccb0271700/US8064700.pdf",
    "summaryText": "US8064700B2, granted 2011-11-22. Assigned to Google LLC. Filed 2010-03-10. Inventors: Martin T. King, Dale L. Grover, Clifford A. Kushler (+1 more). 18 claims, 185 backward citations, 27 forward citations.",
    "enrichmentDepth": "deep"
}

Data fields

Field	Type	Notes
patentId	string	Publication number, e.g. US10000000B2 (dedup key)
url	string	Canonical Google Patents URL
title	string	Patent title
abstract	string	Short abstract / meta description
countryCode	string	2-letter patent-office code (US/EP/WO/JP/CN/...)
applicationNumber	string	Official application number
filingDate, publicationDate, priorityDate, grantDate	YYYY-MM-DD	Key patent-lifecycle dates
inventors	string[]	All named inventors
assigneeCurrent, assigneeOriginal	string	Current owner(s) and original (filing) assignee, from the patent page's Current / Original Assignee fields. Several current co-owners are joined with ; (deep mode; basic mode has the search-card assignee in assigneeCurrent)
legalStatus	string	"Active" / "Expired - Lifetime" / "Application" / etc.
isGranted	bool	Heuristic from publication-number suffix
cpcClassifications	string[]	CPC codes (most-specific "leaf" codes preferred)
backwardCitationsCount	number	Prior patents cited by this patent
forwardCitationsCount	number	Later patents citing this patent
nonPatentCitationsCount	number	Cited non-patent literature
claimsCount	number	Number of claims
pdfUrl	string	Direct PDF link from Google Patents storage
summaryText	string	Deterministic template built from factual fields — not a copy of any Google Patents text

How much does it cost?

Pay-per-event — you pay only for records written to the dataset:

Event	Price	When it fires
Patent (basic)	$0.002	Search-card fields only (mode: basic)
Patent (deep)	$0.008	Detail-page enriched (mode: deep)
New filing alert	$0.001	Incremental/monitor mode only, when a patent is newly seen since the last run — charged at most once per run

Actor start fee: every run is charged one $0.01 start event per GB of memory (default 4 GB → $0.04 per run).

Free trial: the first 20 deep records OR 200 basic records per run are free (deep records count 10× toward the same per-run allowance; in monitor mode the new-filing alerts count toward it too).

Typical run costs (record charges after the per-run free allowance, plus the $0.04 start fee at default memory):

Scenario	Records	Start fee	Total
100 deep records	$0.64	$0.04	$0.68
100 basic records	$0 (within trial)	$0.04	$0.04
500 deep records	$3.84	$0.04	$3.88
1,000 deep records	$7.84	$0.04	$7.88
Scheduled monitor w/ 20 new deep hits/run (after the first, baseline run)	≈ $0.02	$0.04	≈ $0.06/run
First monitor run (baseline, nothing emitted)	$0	$0.04	$0.04

A run that finds nothing is charged only the start fee, and its status message says why (Google returned 0 matches for your filters, nothing new since the last monitor run, or Google blocked every attempt).

Tips

• Deep vs. basic — deep follows each search result to its detail page for ~15 additional fields (full abstract, CPC codes, citation counts, claims count, legal status, PDF URL, full inventor list). Worth 4× the price for any serious analytics workflow.
• Country filter — Google Patents indexes 100+ patent offices. Use ["US"] to limit to USPTO, ["US", "EP"] for US + Europe, etc.
• Date windows — dateFrom and dateTo filter by filing date. Useful for time-bounded competitive-intel sweeps.
• Monitor mode — set up a schedule (e.g. nightly) with incrementalMode: true (or mode: "monitor"). Results are read newest filing first. The first run for a given input records a baseline of what already exists — nothing is emitted or charged, and the status message says so; every later run emits only patents not seen before and stops reading as soon as a page has nothing new. Each run checks patents published in the last 120 days (before the newest publication Google has for your query), at most 2,000 of them; if a query exceeds that, the status message says so — narrow it with keywords or filters so new publications are not missed. With several companies, every one of them is baselined. Turn on monitorBackfill if you want the first run to emit (and pay for) the existing patents instead. On top of the record events, a run that finds new patents is charged one new-filing-alert event.
• Several companies / inventors — in by_assignee / by_inventor each name is queried separately and maxResults is shared between them; the status message lists how many records each produced. In search / monitor mode all names are sent together (any of them matches). A patent co-assigned to two of your companies is emitted and charged once.
• Expired patents — Google Patents has no "expired" filter. statusFilter: "expired" requests granted patents and keeps those whose legal status on the detail page starts with "Expired", so it requires enrichmentDepth: "deep". EP and national records reported as "Ceased" count as expired. At most 2 × maxResults + 20 non-expired patents are checked per query.
• Search operators — query accepts Google Patents' own operators: quotes for phrases, AND / OR / NOT, parentheses. Example: "generative AI" AND (transformer OR attention).
• Company and inventor filters — to restrict results to one company or inventor, use by_assignee / by_inventor (or the assignees / inventors fields together with a query). These use Google Patents' own Assignee / Inventor filters, exactly like the fields on patents.google.com. Typing assignee:"Company" inside query is a loose text match and can return other companies' patents.
• Pagination cap — Google Patents returns at most 100 pages × 100 results = 10,000 hits per query. For broader sweeps, narrow with filters (country, date, status).

Changelog

• 2026-10 (fixes, round 3) — A first monitor run with several companies now baselines every one of them (later companies used to be skipped and then billed as "new"). Monitor runs report when a query has more recent publications than they can check. "Ceased" counts as expired.
• 2026-10 (fixes, round 2) — Monitor / incremental runs read newest filings first, record a baseline on their first run instead of selling the existing back catalogue as "new" (opt back in with monitorBackfill), and stop paging once nothing new appears. by_assignee / by_inventor share maxResults across all names and report per-name counts; search / monitor use every assignee and inventor you list. Commas inside a company name no longer split it into two names. statusFilter: "expired" is now actually applied. A patent is emitted and charged once per run. assigneeCurrent is now the current owner (it used to be the original assignee). After an Apify platform restart, records delivered before the restart are not delivered or charged again. Deep runs use much less memory (they could run out of memory at 1 GB).
• 2026-10 (fixes) — by_assignee and by_inventor now use Google Patents' Assignee / Inventor filters instead of a free-text match. Previously a company sweep could return other companies' patents (e.g. Schering patents for "Vertex Pharmaceuticals Incorporated"), and combining it with dateFrom / dateTo could return 0 rows. Search-card assignee and inventor names no longer carry Google's highlight markup. A run that ends with 0 records now says why in its status message instead of finishing silently.

Legal

This actor extracts factual metadata (patent IDs, bibliographic dates, inventor/assignee names, CPC codes, citation counts) from Google Patents. These are public facts from official patent offices (USPTO, EPO, WIPO, etc.) — factual data not subject to copyright. The summaryText field is a deterministic template built from the extracted factual fields, not a paraphrase or copy of any Google Patents text.

Google Patents is a public search interface over patent-office data. Users are responsible for ensuring their usage complies with Google's Terms of Service and any data-protection obligations that apply to their workflows.

FAQ

Q: What patent offices are covered? A: All offices indexed by Google Patents — USPTO (US), EPO (EP), WIPO (WO), JPO (JP), SIPO/CNIPA (CN), KIPO (KR), DPMA (DE), UKIPO (GB), INPI (FR), and 90+ more. Use the countries filter to restrict to specific offices.

Q: Can I get the full patent claims text or drawings? A: This actor returns the claims count (number of claims) but not the full claims text. For full claims text, use the PDF URL in the output to download the patent PDF, or build a follow-up workflow that fetches claims from a patent-office bulk-data service.

Q: How current is the data? A: Google Patents typically indexes new filings within ~1 week of publication. Incremental/monitor mode picks up new filings as they appear.

Q: What's the difference between assigneeCurrent and assigneeOriginal? A: Patents can be reassigned over time (acquisitions, license transfers). assigneeOriginal is the first assignee recorded in the patent filing; assigneeCurrent reflects the latest recorded owner.

Q: Are trademarks supported? A: Not in v1 — this actor is patents-only. A trademark-specific actor is on the roadmap.

Support: file issues or feature requests via the actor's Apify Console page.