# Google Patents Intelligence (`constructive_calm/google-patents-intelligence`) Actor Scrapes patents from Google Patents (USPTO, EPO, WIPO, JPO, CN, KR, and 100+ offices) with rich factual output: citations, classifications, assignees, inventors, claims count. Modes: keyword search, by-assignee, by-inventor, patent details, and incremental monitoring for scheduled alerts. - **URL**: https://apify.com/constructive_calm/google-patents-intelligence.md - **Developed by:** [Omar Eldeeb](https://apify.com/constructive_calm) (community) - **Categories:** News, SEO tools, Jobs - **Features:** Limited permissions - **Stats:** 28 total users, 6 monthly users, 100.0% runs succeeded, 2 bookmarks - **User rating**: 5.00 out of 5 stars ## Pricing from $8.00 / 1,000 patent (deep) records This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. 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. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## 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. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## Google Patents Intelligence Scrapes patents from [Google Patents](https://patents.google.com) 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:** ```json { "mode": "search", "query": "quantum computing", "countries": ["US", "EP"], "enrichmentDepth": "deep", "maxResults": 100 } ``` **By assignee — company sweep:** ```json { "mode": "by_assignee", "assignees": ["Apple Inc", "NVIDIA Corp"], "countries": ["US"], "statusFilter": "granted", "enrichmentDepth": "deep", "maxResults": 500 } ``` **By inventor:** ```json { "mode": "by_inventor", "inventors": ["Yann LeCun"], "enrichmentDepth": "deep", "maxResults": 50 } ``` **Patent details — specific IDs:** ```json { "mode": "details", "patentIds": ["US10000000B2", "EP3456789A1", "WO2021123456A1"] } ``` **Monitor — scheduled alerts on new filings:** ```json { "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: ```json { "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. # Actor input Schema ## `mode` (type: `string`): 'search' runs a keyword query. 'by_assignee' pulls all patents owned by one or more companies. 'by_inventor' pulls all patents by an inventor. 'details' fetches full data for specific patent numbers. 'monitor' runs any of the search modes in incremental mode (emits only new hits since the last run). ## `query` (type: `string`): Keyword or phrase to search. Supports Google Patents operators: quotes for exact phrases, AND/OR, minus for exclusion, parenthesized groups. Used in 'search' and 'monitor' modes. Example: "quantum computing" AND (qubit OR superconducting). ## `assignees` (type: `array`): List of assignee (company) names. In by_assignee mode each company is queried separately and maxResults is shared between them. In search / monitor mode all names are sent together (any of them). Google normalizes these (e.g., 'Apple Inc' matches 'Apple Inc.'); commas inside a name are ignored. ## `inventors` (type: `array`): List of inventor names. In by_inventor mode each name is queried separately and maxResults is shared between them; in search / monitor mode all names are sent together (any of them). ## `patentIds` (type: `array`): List of patent publication numbers to fetch in 'details' mode (e.g., US10000000B2, EP1234567A1, WO2021123456A1). ## `countries` (type: `array`): Restrict results to patent offices by 2-letter country code. Examples: US (USPTO), EP (EPO), WO (WIPO), JP (Japan), CN (China), KR (Korea), DE, GB, FR. Empty = all. ## `statusFilter` (type: `string`): Filter by legal status. Granted / Application use Google Patents' own filter. Expired only works with enrichmentDepth "deep": Google has no expired filter, so the actor requests granted patents and keeps those whose legal status on the detail page is Expired. ## `dateFrom` (type: `string`): Only include patents filed on or after this date (YYYY-MM-DD). Leave empty for no floor. ## `dateTo` (type: `string`): Only include patents filed on or before this date (YYYY-MM-DD). Leave empty for no ceiling. ## `enrichmentDepth` (type: `string`): 'basic' uses only the search-result fields (title, abstract snippet, patent ID, publication date, assignee). 'deep' follows each result to its Google Patents detail page for the full field set: full abstract, claims count, all inventors, backward/forward citations, CPC classifications, legal status, family ID, PDF URL. Deep is 4x the price but 5x the data value. ## `incrementalMode` (type: `boolean`): If enabled, remember seen patent IDs and only emit new ones on subsequent runs. Ideal for scheduled daily/weekly alerts. Results are taken newest-filing first. The FIRST run for a given input records what already exists as a baseline (nothing emitted or charged) unless "Backfill on first run" is on. ## `monitorBackfill` (type: `boolean`): Incremental / monitor mode only. Off (default): the first run records existing patents as a baseline and emits nothing; later runs emit only new filings. On: the first run emits (and charges for) up to maxResults existing patents. ## `maxResults` (type: `integer`): Hard cap on patents emitted in one run. Google Patents caps search at 10,000 results per query. ## `proxyConfiguration` (type: `object`): Google Patents rate-limits Apify cloud egress IPs on filtered/complex search queries (returns HTTP 500 'Sorry...'). Enable Apify Proxy to rotate IPs and dodge the block. Default is enabled with the user's auto-selected datacenter group (cheap, fast, usually enough). Add 'RESIDENTIAL' to apifyProxyGroups for higher reliability at ~10x bandwidth cost. If you only run simple search or details mode, you can disable this. ## Actor input object example ```json { "mode": "search", "query": "artificial intelligence", "assignees": [ "Apple Inc" ], "inventors": [], "patentIds": [ "US10000000B2" ], "countries": [ "US", "EP" ], "statusFilter": "any", "dateFrom": "", "dateTo": "", "enrichmentDepth": "deep", "incrementalMode": false, "monitorBackfill": false, "maxResults": 10, "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `dataset` (type: `string`): Dataset of patent records. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "query": "artificial intelligence", "assignees": [ "Apple Inc" ], "patentIds": [ "US10000000B2" ], "countries": [ "US", "EP" ], "maxResults": 10, "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("constructive_calm/google-patents-intelligence").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "query": "artificial intelligence", "assignees": ["Apple Inc"], "patentIds": ["US10000000B2"], "countries": [ "US", "EP", ], "maxResults": 10, "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("constructive_calm/google-patents-intelligence").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "query": "artificial intelligence", "assignees": [ "Apple Inc" ], "patentIds": [ "US10000000B2" ], "countries": [ "US", "EP" ], "maxResults": 10, "proxyConfiguration": { "useApifyProxy": true } }' | apify call constructive_calm/google-patents-intelligence --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,constructive_calm/google-patents-intelligence" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/AJNts4kceXDyjKicl/builds/iBwodkp8eGpoMqSkl/openapi.json