# Google Patents Scraper (`scrapier/google-patents-scraper`) Actor Google Patents Scraper: Extract patent titles, inventors, assignees, filing dates, publication numbers, classifications, abstracts, claims, citations, and patent URLs. Build structured datasets for patent research, technology analysis, competitor monitoring, and intellectual property intelligence. - **URL**: https://apify.com/scrapier/google-patents-scraper.md - **Developed by:** [Scrapier](https://apify.com/scrapier) (community) - **Categories:** Developer tools, Automation, Other - **Stats:** 25 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $5.99 / 1,000 results This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. 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. Actors are written with capital "A". ## 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. The best way to integrate Actors is as follows. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ### Google Patents Scraper — Patents, Citations and Landscape Summary Google Patents Scraper extracts structured patent data from Google Patents by keyword, publication number, assignee, or inventor. Each run returns patent records — titles, abstracts, inventors, assignees, dates, classifications, PDFs, figures — plus optional full text, claims, citations, and patent family, alongside a free per-run landscape summary of top assignees, inventors, and CPC codes. Every response is structured JSON, ready to pass to an LLM, index into a vector store, or feed a monitoring pipeline. No Google login is required. ### What is Google Patents Scraper? Google Patents Scraper queries patents.google.com by keyword, publication number, assignee, inventor, country, date range, or document type, and returns normalized JSON patent records. It also surfaces a search-summary landscape row — the top assignees, inventors, and CPC classification codes across the result set, plus Google's own related-topic clustering — computed by Google itself and returned in the same response most scrapers discard. No Google account, API key, or login is required; patents.google.com is a public search tool. - Extract core bibliographic data: title, abstract, inventors, assignee, filing/publication/grant dates, and links - Pull optional deep fields: full description text, claims, citations, patent family, CPC/IPC classifications - Get a free per-run landscape summary: top assignees, top inventors, top CPC codes, related topic clusters - Filter by assignee, inventor, country/patent office (39 offices or any), publication date range, and document kind - Batch multiple specific patent numbers or search terms into a single run - Receive thumbnails, figure images, and PDF links for every patent ### What data can you get with Google Patents Scraper? Google Patents Scraper returns four types of patent data plus one aggregate landscape row, all in the same dataset. | Result Type | Extracted Fields | Primary Use Case | | --- | --- | --- | | Patent record | `patentNumber`, `title`, `abstract`, `inventors`, `assignee`, `filingDate`, `publicationDate`, `grantDate`, `url`, `pdfUrl`, `priorityDate`, `language`, `docId`, `rank`, `thumbnailUrl`, `figures`, `totalNumResults`, `resultPage`, `scrapedAt` | Core bibliographic dataset for prior-art search and portfolio tracking | | Full text & claims (optional) | `fullText.description`, `fullText.claims` | Deep prior-art reading and claim-scope analysis | | Citations & patent family (optional) | `citations.citedBy`, `citations.references`, `patentFamily` | Citation-network mapping and freedom-to-operate checks | | Classifications (optional) | `classifications.cpc`, `classifications.ipc` | Technology-area filtering and analytics | | Search-summary landscape row (once per run) | `type`, `totalNumResults`, `summarySampleSize`, `topAssignees`, `topAssigneesText`, `topInventors`, `topInventorsText`, `topCpcCodes`, `topCpcCodesText`, `relatedLandscapes`, `relatedLandscapesText`, `scrapedAt` | Competitive landscape snapshot without running a separate analysis job | #### Search-summary landscape data Most Google Patents scrapers return one row per patent and stop there. Google's own search response, however, carries a `summary` object (assignee, inventor, and CPC frequency counts sampled across the whole result set) and a `landscape` object (related topic clusters) on the first page — data most scrapers simply discard. Google Patents Scraper captures both and pushes them as a single labeled `type: "searchSummary"` row per run, at no extra request cost. This gives you a competitive snapshot — who holds the most patents in a space, which inventors are most active, and which CPC codes dominate — without writing your own aggregation code. ```json { "type": "searchSummary", "totalNumResults": 15234, "summarySampleSize": 1000, "topAssignees": [{ "name": "Google LLC", "count": 84 }], "topInventors": [{ "name": "Jane Doe", "count": 12 }], "topCpcCodes": [{ "name": "G06N 20/00", "count": 210 }], "relatedLandscapes": [{ "name": "Neural network training", "type": "topic" }] } ``` The row is absent when Google doesn't return summary facets for a query — for example, a lookup of a single explicit publication number with no broader result set. #### Citations and patent family network When `includeCitations` and `includePatentFamily` are enabled, each patent record carries `citations.references` (backward citations — prior art this patent cites), `citations.citedBy` (forward citations — later patents that cite this one), and `patentFamily` (related publication numbers in the same patent family across jurisdictions). Together these let you trace prior-art chains and see which markets an invention was filed in, without opening each patent page manually. ### Why not build this yourself? Google Patents doesn't expose a simple REST API for casual developers. Google publishes the underlying data as **Google Patents Public Datasets on BigQuery** — a bulk, SQL-queryable dataset meant for warehouse-scale analysis, not for pulling a live, filtered result set for a handful of keywords on demand. To get that instead you'd need to reverse-engineer patents.google.com's internal `xhr/query` and `xhr/result` endpoints, handle pagination and HTML parsing for claims and citations, and build a proxy fallback ladder for when direct requests get blocked. Google Patents Scraper does all of that already and hands back normalized JSON. ### How to scrape Google Patents with Google Patents Scraper? 1. Open Google Patents Scraper on the Scrapier Apify Store listing 2. Enter your query — `searchQuery` (keywords), `patentNumbers` (specific IDs), or `urls` (patent/search links); at least one must resolve to a query 3. Set the query controls you need — `assignee`, `inventor`, `country`, `dateFrom`/`dateTo`, `patentType` 4. Start the run 5. Download or stream results as JSON or CSV from the dataset Example request via the Apify API: ```bash curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "searchQuery": "machine learning", "country": "US", "patentType": "PATENT", "maxResults": 25 }' ``` #### How to run multiple queries in one job List several entries in `patentNumbers` (array) or one link/keyword per line in `urls` (stringList) — each publication number is resolved individually into its own row in the same run, in addition to any keyword-based results. `searchQuery`, extra `q=` terms from search URLs, and `patentNumbers` are OR-merged, so combining them broadens the result set rather than narrowing it to an intersection. ### ⬇️ Input | Parameter | Required | Type | Description | Example Value | | --- | --- | --- | --- | --- | | `urls` | No | array | One entry per line: patent URLs, search URLs (`?q=`), or plain keywords. Plain lines are treated as search phrases and OR-merged with `searchQuery`. | `["https://patents.google.com/patent/US12438891B1", "machine learning"]` | | `searchQuery` | No | string | Main keyword search. OR-merged with any `q=` terms from search URLs and with publication numbers. Default `""`. | `"machine learning"` | | `patentNumbers` | No | array | Specific patent publication IDs, each resolved individually. OR-merged with keywords. Default `[]`. | `["US12438891B1", "EP4012345A1"]` | | `assignee` | No | string | Focus on patents owned by a particular organization. Default `""`. | `"Google LLC"` | | `inventor` | No | string | Find patents listing a specific inventor. Default `""`. | `"Jane Doe"` | | `country` | No | string | Patent office or country filter, or `ANY` for no filter. 39 offices supported (US, EP, WO, CN, JP, KR, DE, GB, FR, CA, AU, IN, BR, TW, RU, IT, ES, NL, SE, CH, AT, HK, SG, MX, NO, DK, FI, PL, IL, NZ, ZA, SA, AR, TH, MY, PH, ID, VN). Default `"ANY"`. | `"US"` | | `dateFrom` | No | string | Published-after date — absolute `YYYY-MM-DD` or relative (`"30 days"`, `"6 months"`). Empty means no lower bound. Default `""`. | `"2023-01-01"` | | `dateTo` | No | string | Published-before date — absolute or relative, same format as `dateFrom`. Default `""`. | `"6 months"` | | `patentType` | No | string | Document kind: `ANY`, `PATENT` (granted), `APPLICATION`, or `DESIGN`. Default `"ANY"`. | `"PATENT"` | | `maxResults` | No | integer | Cap on patents collected. `0` means no limit (be mindful of run time). Default `10`. | `25` | | `includeFullText` | No | boolean | Adds the full written description text. Default `false`. | `true` | | `includeClaims` | No | boolean | Adds the patent claims text. Default `true`. | `true` | | `includeCitations` | No | boolean | Adds backward and forward citation lists where available. Default `true`. | `true` | | `includePatentFamily` | No | boolean | Adds related publications in the same patent family. Default `true`. | `true` | | `includeClassifications` | No | boolean | Adds CPC/IPC classification codes. Default `true`. | `true` | | `proxyConfiguration` | No | object | Optional Apify Proxy settings, used automatically as a fallback if direct requests get blocked. | `{"useApifyProxy": true}` | None of these parameters are schema-required, but the run needs at least one of `searchQuery`, `patentNumbers`, or `urls` to resolve to an actual query — otherwise it logs an error and finishes with zero results. Example input: ```json { "searchQuery": "machine learning", "patentNumbers": ["US12438891B1"], "assignee": "", "inventor": "", "country": "US", "dateFrom": "1 year", "dateTo": "", "patentType": "ANY", "maxResults": 25, "includeFullText": false, "includeClaims": true, "includeCitations": true, "includePatentFamily": true, "includeClassifications": true, "proxyConfiguration": { "useApifyProxy": true } } ``` Common pitfall: setting both `patentNumbers` and `searchQuery` doesn't intersect them — it unions them with OR, so you get keyword matches *and* your explicit publication numbers, not just patents that match both. If you only want the exact publication numbers, leave `searchQuery` and `urls` keyword lines empty. ### ⬆️ Output Google Patents Scraper writes typed, normalized JSON to the Actor's dataset with a consistent schema across runs, exportable as JSON, CSV, Excel, or XML directly from the Apify platform. #### Scraped results ```json [ { "patentNumber": "US12438891B1", "title": "Machine learning model for anomaly detection in time-series data", "abstract": "A system and method for detecting anomalies in streaming time-series data using a trained neural network...", "inventors": ["Jane Doe", "John Smith"], "assignee": "Google LLC", "filingDate": "2022-03-14", "publicationDate": "2025-09-02", "grantDate": "2025-09-02", "classifications": { "cpc": ["G06N 20/00"], "ipc": ["G06N 20/00"] }, "url": "https://patents.google.com/patent/US12438891B1", "pdfUrl": "https://patentimages.storage.googleapis.com/US12438891B1.pdf", "scrapedAt": "2026-07-26T09:12:44Z", "citations": { "citedBy": ["US11987654B2"], "references": ["US10456789B1"] }, "priorityDate": "2022-03-14", "language": "en", "docId": "patent/US12438891B1/en", "rank": 0, "thumbnailUrl": "https://patentimages.storage.googleapis.com/thumb1.png", "figures": [{ "thumbnailUrl": "https://patentimages.storage.googleapis.com/fig1_thumb.png", "fullUrl": "https://patentimages.storage.googleapis.com/fig1_full.png" }], "totalNumResults": 15234, "resultPage": 0, "patentFamily": ["EP4012345A1", "WO2023012345A1"] }, { "patentNumber": "US11987654B2", "title": "Distributed training system for large-scale neural networks", "abstract": "A distributed computing architecture for training neural networks across multiple nodes...", "inventors": ["Alice Chen"], "assignee": "OpenAI OpCo, LLC", "filingDate": "2021-11-02", "publicationDate": "2024-05-14", "grantDate": "2024-05-14", "classifications": { "cpc": ["G06N 3/08"], "ipc": ["G06N 3/08"] }, "url": "https://patents.google.com/patent/US11987654B2", "pdfUrl": "https://patentimages.storage.googleapis.com/US11987654B2.pdf", "scrapedAt": "2026-07-26T09:12:47Z", "citations": { "citedBy": [], "references": ["US12438891B1"] }, "priorityDate": "2021-11-02", "language": "en", "docId": "patent/US11987654B2/en", "rank": 1, "thumbnailUrl": "https://patentimages.storage.googleapis.com/thumb2.png", "figures": [], "totalNumResults": 15234, "resultPage": 0, "patentFamily": [] }, { "patentNumber": "EP4012345A1", "title": "Method for real-time anomaly scoring using edge inference", "abstract": "Systems and methods for performing anomaly scoring on edge devices with limited compute...", "inventors": ["Jane Doe"], "assignee": "Google LLC", "filingDate": "2022-06-01", "publicationDate": "2023-12-20", "grantDate": "", "classifications": { "cpc": ["G06N 20/00"], "ipc": ["G06N 20/00"] }, "url": "https://patents.google.com/patent/EP4012345A1", "pdfUrl": "https://patentimages.storage.googleapis.com/EP4012345A1.pdf", "scrapedAt": "2026-07-26T09:12:51Z", "citations": { "citedBy": [], "references": [] }, "priorityDate": "2022-03-14", "language": "en", "docId": "patent/EP4012345A1/en", "rank": 2, "thumbnailUrl": "https://patentimages.storage.googleapis.com/thumb3.png", "figures": [], "totalNumResults": 15234, "resultPage": 0, "patentFamily": ["US12438891B1"] }, { "type": "searchSummary", "patentNumber": null, "totalNumResults": 15234, "summarySampleSize": 1000, "topAssignees": [{ "name": "Google LLC", "count": 84 }, { "name": "OpenAI OpCo, LLC", "count": 31 }], "topAssigneesText": "Google LLC (84), OpenAI OpCo, LLC (31)", "topInventors": [{ "name": "Jane Doe", "count": 12 }], "topInventorsText": "Jane Doe (12)", "topCpcCodes": [{ "name": "G06N 20/00", "count": 210 }, { "name": "G06N 3/08", "count": 145 }], "topCpcCodesText": "G06N 20/00 (210), G06N 3/08 (145)", "relatedLandscapes": [{ "name": "Neural network training", "type": "topic" }], "relatedLandscapesText": "Neural network training", "scrapedAt": "2026-07-26T09:13:02Z" } ] ``` Each patent row is pushed as a charged `row_result` event. The single per-run `searchSummary` row is pushed uncharged — filter it out of billing-sensitive counts with `type != "searchSummary"`, or simply check that `patentNumber` is not null. ### How can I use the data extracted with Google Patents Scraper? - **Patent attorneys and IP researchers:** run prior-art searches by keyword or CPC area, pull `citations.references` and `patentFamily` for freedom-to-operate checks, and export `fullText.claims` for claim-scope comparison across a candidate's filings. - **R\&D and competitive intelligence teams:** track a competitor's `assignee` filings over time, use the `searchSummary` row's `topCpcCodes` to see which technology areas they're concentrating R\&D in, and diff `topAssignees` across runs to spot new entrants. - **AI engineers and LLM developers:** issue a query, receive structured JSON back, and pass `title`, `abstract`, and `fullText.description` directly into an LLM as grounding context for a patent-research or invention-disclosure assistant. - **Market researchers:** use `totalNumResults` and `topCpcCodes` as a proxy for filing volume and technology concentration in a space, and `relatedLandscapes` to discover adjacent topic clusters worth a follow-up search. ### How do you monitor patent filings and landscape shifts over time? Patent monitoring means re-running the same query on a schedule and comparing what changed between runs — new publications, a new top assignee, or a shift in which CPC codes dominate. Because each run's patent records include `publicationDate` and `patentNumber`, a new run's patent list can be diffed against the previous run's `patentNumber` set to isolate newly published filings for a keyword, assignee, or inventor. The `searchSummary` row makes broader shifts checkable without diffing every patent individually: compare `topAssignees` and `topCpcCodes` between runs to see if a competitor has moved up the ranking or a new technology cluster has entered `relatedLandscapes`. A practical workflow: schedule a run of the same `assignee` or `searchQuery` weekly or monthly, store each run's dataset, then compare the new run's patent-number list against the prior run's to flag newly published patents, and compare `topAssigneesText` and `topCpcCodesText` to flag ranking changes worth a closer look. If a competitor's `topCpcCodes` suddenly includes a code that wasn't in the previous run, that's a signal they've started filing in a new technology area worth investigating in detail. Google Patents Scraper has no built-in diffing — pair it with the Apify platform's Scheduler to trigger repeated runs, and do the comparison in your own pipeline or a downstream script that reads the last two dataset exports. ### Integrate Google Patents Scraper and automate your workflow Google Patents Scraper works with any language or tool that can send an HTTP request. #### REST API with Python ```python import requests TOKEN = "YOUR_API_TOKEN" ACTOR_ID = "YOUR_ACTOR_ID" url = f"https://api.apify.com/v2/acts/%7BACTOR_ID%7D/run-sync-get-dataset-items" payload = { "searchQuery": "machine learning", "country": "US", "maxResults": 25, } resp = requests.post(url, params={"token": TOKEN}, json=payload) patents = [row for row in resp.json() if row.get("patentNumber")] print(f"Retrieved {len(patents)} patents") ``` #### MCP for query-grounded AI agents Google Patents Scraper can be exposed to MCP-compatible clients through Apify's generic Actors MCP Server: run `npx @apify/actors-mcp-server --actors YOUR_USERNAME/google-patents-scraper` with your `APIFY_TOKEN` set, and register it with Claude Desktop, Cursor, or any other MCP client. The agent flow: a user asks a patent question, the agent calls the tool with a query, receives structured JSON back, and grounds its answer in real patent records instead of guessing. #### Scheduled monitoring and delivery Use the Apify platform's built-in Scheduler to trigger runs on a recurring interval (daily, weekly, custom cron) without managing your own job runner. Results land in each run's dataset, which you pull via the API or Apify's dataset export formats after each scheduled run completes. ### Is it legal to scrape Google Patents? Yes — Google Patents Scraper only retrieves data that patents.google.com already serves publicly, with no login or paywall involved. Patents and patent applications are public legal records published by national and regional patent offices (USPTO, EPO, WIPO, and others); Google Patents republishes that public record data for free search. Because the underlying content is bibliographic and technical rather than personal data, typical consumer-privacy regimes like GDPR or CCPA are not the primary concern here — the relevant framework is Google's own Terms of Service for patents.google.com, which governs automated access. Scraping for one-off research carries a different risk profile than bulk storage or redistribution. Consult your legal team before using extracted data for large-scale commercial reuse or redistribution. ### Frequently asked questions #### Can I filter results by country or patent office? Yes — the `country` parameter accepts `ANY` or a specific office code (US, EP, WO, CN, JP, KR, DE, GB, FR, CA, AU, IN, BR, and 26 others). Leaving it at the default `ANY` searches across all offices Google Patents indexes. #### What's the difference between the `patentType` options? `patentType` filters by document kind: `PATENT` returns granted patents only, `APPLICATION` returns published applications that haven't necessarily granted, and `DESIGN` returns design patents. `ANY` (the default) returns all three kinds. #### How does Google Patents Scraper handle Google Patents' anti-bot measures? By default, requests go direct to Google Patents with no proxy. If a request gets blocked, the Actor automatically retries through Apify datacenter proxy, then residential proxy (up to three attempts), and sticks with whichever tier last succeeded for subsequent requests in the same run. You can also supply your own `proxyConfiguration` up front. #### Does Google Patents Scraper extract a patent landscape summary? Yes — once per run, it pushes a `type: "searchSummary"` row containing `topAssignees`, `topInventors`, and `topCpcCodes` (each with name and count) plus `relatedLandscapes`, Google's own topical clustering for the query. This row is omitted when Google doesn't return summary facets for that particular query, such as a lookup of a single explicit publication number. #### How many results does Google Patents Scraper return per query? Up to `maxResults`, which defaults to 10. Set it to `0` to remove the cap and collect all matching patents Google Patents returns for the query — be mindful this can mean a long-running job for broad keyword searches. #### How do I use Google Patents Scraper to monitor new filings over time? Schedule a run of the same `searchQuery` or `assignee` on a recurring interval, compare the new run's `patentNumber` list against the previous run's to isolate newly published patents, and check `topAssigneesText`/`topCpcCodesText` for ranking shifts. Trigger the recurring runs with the Apify platform's Scheduler. #### Does Google Patents Scraper work with Claude, ChatGPT, and AI agent frameworks? Yes, two ways: it's reachable through Apify's generic Actors MCP Server (`npx @apify/actors-mcp-server --actors YOUR_USERNAME/google-patents-scraper`) for MCP clients like Claude Desktop and Cursor, and it's callable as a plain HTTP endpoint by any agent framework that can send a request — enabling grounded agents that retrieve live patent data before answering. #### How does Google Patents Scraper compare to other Google Patents scrapers? As observed on their Apify Store listings on 2026-07-26, competing Google Patents scrapers (including scrape.badger's and scrapemint's) return one row per patent — bibliographic fields, claims, citations, and classifications — but none document an aggregate landscape row surfacing top assignees, top inventors, or CPC-code frequency across the result set. Google Patents Scraper returns both the per-patent rows and that aggregate `searchSummary` row in the same run. #### Can I use Google Patents Scraper without managing proxies or Google credentials? Yes — no Google account or API key is needed since patents.google.com is a public search tool, and proxy fallback (datacenter, then residential) is handled automatically when a direct request gets blocked. You only need to supply your own `proxyConfiguration` if you want to override that default behavior. ### Your feedback Found a bug or a field that doesn't match what's documented here? Let the Scrapier team know through the Actor's issue tracker on its Apify Store listing. Reports like these help keep this README and the underlying scraper accurate as Google Patents changes. # Actor input Schema ## `urls` (type: `array`): ✅ One entry per line: patent URLs, search URLs (q=), or plain keywords (e.g. machine learning). Plain lines are search phrases. All entries OR-merge with the Keywords field. ## `searchQuery` (type: `string`): 💡 Main keyword search. Works together with URLs: your text is OR-merged with any q= from search URLs and with publication numbers from patent URLs so you get a broad combined result. ## `patentNumbers` (type: `array`): 📋 Specific patent IDs. Combined with keywords using OR so you still get broad results when both are set. ## `assignee` (type: `string`): 🏭 Focus on patents owned by a particular organization. ## `inventor` (type: `string`): 🧑‍🔬 Find patents listing a specific inventor. ## `country` (type: `string`): 🗺️ Pick a country or office — or **Any** to search everywhere. ## `dateFrom` (type: `string`): ⏳ Pick a **calendar date** or a **relative** range (e.g. *30 days*, *6 months*). Leave empty for no lower bound. ## `dateTo` (type: `string`): ⏳ Same as above — absolute or relative. Leave empty for no upper bound. ## `patentType` (type: `string`): 📑 Limit to grants, applications, or designs — or **Any** for all types. ## `maxResults` (type: `integer`): 🎚️ Cap how many patents to collect. Use **0** for no limit (be mindful of run time). ## `includeFullText` (type: `boolean`): 📜 Adds the full written description (large text). ## `includeClaims` (type: `boolean`): 📋 Adds the patent claims text. ## `includeCitations` (type: `boolean`): ↩️ Adds backward and forward citation lists where available. ## `includePatentFamily` (type: `boolean`): 🌍 Adds related publications in the same family. ## `includeClassifications` (type: `boolean`): 🧮 Adds classification codes for analytics and filtering. ## `proxyConfiguration` (type: `object`): 🛟 Optional Apify Proxy settings. Leave default off if you don’t need it. ## Actor input object example ```json { "urls": [ "https://patents.google.com/patent/US12438891B1", "machine learning" ], "searchQuery": "", "patentNumbers": [], "assignee": "", "inventor": "", "country": "ANY", "dateFrom": "", "dateTo": "", "patentType": "ANY", "maxResults": 10, "includeFullText": false, "includeClaims": true, "includeCitations": true, "includePatentFamily": true, "includeClassifications": true, "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `results` (type: `string`): All scraped items in the Actor's default dataset. # 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 = { "urls": [ "https://patents.google.com/patent/US12438891B1", "machine learning" ], "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("scrapier/google-patents-scraper").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 = { "urls": [ "https://patents.google.com/patent/US12438891B1", "machine learning", ], "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("scrapier/google-patents-scraper").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 '{ "urls": [ "https://patents.google.com/patent/US12438891B1", "machine learning" ], "proxyConfiguration": { "useApifyProxy": true } }' | apify call scrapier/google-patents-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapier/google-patents-scraper" } } } ``` 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/I7bXTArvOJJcantrk/builds/4B9RwGObeSrvjq2Nm/openapi.json