# Google Patents Scraper - Claims, Citations & Legal Status (`sweet_stickball/google-patents-scraper`) Actor Google Patents scraper: look up patents by publication number (US, EP, WO, CN, JP, DE and more) and get title, abstract, assignees, inventors, priority, filing and grant dates, legal status, CPC codes, claims, citations, family ID and PDF link. Flat JSON, no login or API key. - **URL**: https://apify.com/sweet_stickball/google-patents-scraper.md - **Developed by:** [CrawlKit](https://apify.com/sweet_stickball) (community) - **Categories:** Business, Other - **Security:** Limited permissions - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.84 / 1,000 patents This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. 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 Scraper - Claims, Citations & Legal Status Patent details from Google Patents by publication number: title, abstract, assignees, inventors, priority, filing, publication and grant dates, legal status, CPC codes, claims, citations, family ID and PDF link. One flat JSON record per patent. ### What it does - Takes a list of patent publication numbers (any patent office covered by Google Patents: US, EP, WO, CN, JP, DE, KR, GB, FR...) and returns one record per patent. - Reads only the public patent page `https://patents.google.com/patent//`, one request per patent. - Accepts numbers with or without kind code (`US7650331B1`, `US7650331`), with spaces or punctuation (`US 7,650,331 B1`, `US2004/0267807 A1`), or full Google Patents URLs. - Returns the claim count and the first claim for every patent; the full claims, the full description and the list of cited patent numbers are optional. - English text by default (Google machine translation for non-English patents), or the original language, or another language supported by Google Patents. - Duplicate inputs are fetched once. Numbers that do not exist on Google Patents (HTTP 404) are reported in the run status and not charged. Typical uses: enriching a patent portfolio or a list of numbers exported from another tool, prior-art and citation analysis from known patents, monitoring legal status and assignees. ### Input | Parameter | Type | Required | Default | Description | |-----------|------|----------|---------|-------------| | `patentNumbers` | array of strings | Yes | — | Publication numbers or `patents.google.com/patent/...` URLs | | `includeClaims` | boolean | No | `false` | Add the text of every claim (`claims`) | | `includeDescription` | boolean | No | `false` | Add the full description (`description`), often several hundred KB | | `includeCitations` | boolean | No | `true` | Add the publication numbers cited by the patent (`citations`) | | `language` | string | No | `en` | `en`, `original`, `de`, `fr`, `es`, `it`, `pt`, `nl`, `ja`, `zh`, `ko`, `ru` | Example: ```json { "patentNumbers": ["US7650331B1", "EP1234567B1", "WO2020123456A1"], "includeClaims": false, "includeCitations": true, "language": "en" } ``` ### Output One dataset item per patent (real output, abstract and first claim shortened): ```json { "publicationNumber": "US7650331B1", "countryCode": "US", "kindCode": "B1", "title": "System and method for efficient large-scale data processing", "abstract": "A large-scale data processing system and method includes one or more application-independent map modules ...", "assignees": ["Google LLC"], "currentAssignees": ["Google LLC"], "inventors": ["Jeffrey Dean", "Sanjay Ghemawat"], "applicationNumber": "US10/871,244", "priorityDate": "2004-06-18", "filingDate": "2004-06-18", "publicationDate": "2010-01-19", "grantDate": "2010-01-19", "status": "Active", "expirationDate": "2026-12-23", "cpcCodes": ["G06F9/5066", "G06F9/544"], "claimsCount": 16, "firstClaim": "1. A system for large-scale processing of data, comprising: ...", "claims": null, "description": null, "citations": ["US3905023A", "US6192359B1", "US6182061B1"], "citationsCount": 18, "citedByCount": 323, "familyCitationsCount": 0, "familyCitedByCount": 0, "nonPatentCitationsCount": 6, "familyId": "41509957", "pdfUrl": "https://patentimages.storage.googleapis.com/7c/97/eb/f084e6ce6281d8/US7650331.pdf", "inputNumber": "US7650331B1", "language": "en", "url": "https://patents.google.com/patent/US7650331B1/en", "scrapedAt": "2026-11-02T10:00:00+00:00" } ``` Field notes: - `grantDate` is the grant date of the same application (also filled for an `A1` publication whose application was later granted); `null` if not granted. - `status` and `expirationDate` are Google's estimate, shown on the page with Google's own disclaimer that they are not a legal conclusion. - `citationsCount` / `citedByCount` count patent-to-patent citations of this publication. Some offices (often EP) only have family-level citations: see `familyCitationsCount` and `familyCitedByCount`. - A field is `null` (or an empty list) when Google Patents does not show it for that document. On a 50-patent sample across 21 offices, title, dates, application number and family ID were always present; the abstract was missing on 14 of 50 (mostly older or JP/GB/Nordic documents), the claims on 8 of 50 and the legal status on 13 of 50. ### Pricing Pay-per-event, no start fee: **$1.40 per 1,000 patents** (event `PATENT`) on the Apify Free plan, lower on paid plans. You only pay for results pushed to the dataset. | Apify plan | Price per 1,000 patents | |---|---| | Free | $1.40 | | Starter | $1.20 | | Scale | $1.00 | | Business | $0.84 | Set a maximum cost per run in the run options: the Actor stops cleanly when it is reached. ### Limitations - **No search.** The robots.txt of patents.google.com is `Disallow: /*` followed by `Allow: /patent/` (checked on 2026-11-02). Only patent pages are allowed to crawlers, so this Actor does not query the Google Patents search (`/?q=`, `/xhr/query`) and never sends a request to it. Input is a list of patent numbers you already have. - One request per patent: a patent's citations are returned as numbers; to get their details, run the Actor again with those numbers. - Text in English is Google's machine translation for non-English documents. - Data is what Google Patents displays; it is not an official register. Legal status, assignees and dates may differ from the patent office's register. - Inventor names are part of the public bibliographic record and are returned as published. ### Related Actors # Actor input Schema ## `patentNumbers` (type: `array`): Publication numbers with country code, optionally with kind code (US7650331B1, EP1234567B1, WO2020123456A1, US20040267807A1), or patents.google.com/patent/... URLs. Spaces, commas and slashes are ignored. Without a kind code, Google Patents picks the publication. ## `includeClaims` (type: `boolean`): Add the full text of every claim (array 'claims'). The claim count and the first claim are always returned. ## `includeDescription` (type: `boolean`): Add the full description text (field 'description'). It can be several hundred kilobytes per patent. ## `includeCitations` (type: `boolean`): Add the list of patent publication numbers cited by this patent (field 'citations'). Citation counts are always returned. ## `language` (type: `string`): Language of title, abstract and claims. 'en' returns English (Google machine translation for non-English patents); 'original' returns the text as filed. ## Actor input object example ```json { "patentNumbers": [ "US7650331B1", "EP1234567B1", "WO2020123456A1" ], "includeClaims": false, "includeDescription": false, "includeCitations": true, "language": "en" } ``` # Actor output Schema ## `patents` (type: `string`): One record per patent, shown with the 'patents' view. # 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 = { "patentNumbers": [ "US7650331B1", "EP1234567B1", "WO2020123456A1" ] }; // Run the Actor and wait for it to finish const run = await client.actor("sweet_stickball/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 = { "patentNumbers": [ "US7650331B1", "EP1234567B1", "WO2020123456A1", ] } # Run the Actor and wait for it to finish run = client.actor("sweet_stickball/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 '{ "patentNumbers": [ "US7650331B1", "EP1234567B1", "WO2020123456A1" ] }' | apify call sweet_stickball/google-patents-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,sweet_stickball/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/5N2aWuLp0Fz55O2Sh/builds/whg94KACPBKzmQm3R/openapi.json