Google Patents & Citation Network Scraper

Google Patents Scraper — Citation Network, Assignee and Filing Data

Google Patents & Citation Network Scraper pulls patent bibliographic data — patentNumber, title, assignee, filingDate — plus a fully expanded citation network (backward references, forward citations, similar documents) from Google Patents, returned as structured JSON with no HTML parsing required. Search by keyword, patent link, publication number, assignee, or inventor. Run it on Apify to get your first citation-mapped patent dataset in minutes.

What is Google Patents & Citation Network Scraper?

Google Patents & Citation Network Scraper is an Apify Actor that searches Google Patents and pulls each matching patent's bibliographic data, full text, classification codes, and citation network — every backward reference and forward citation expanded into a full record (title, dates, assignee) rather than a bare publication-number string. It fetches Google Patents' own public search and detail endpoints directly, so no Google account, login, or session cookie is used or required. It's built for patent attorneys, IP researchers, and R&D/competitive-intelligence teams who need citation-linked patent data without manually clicking through Google Patents pages or a BigQuery pipeline.

What Google Patents data is publicly available to scrape?

Anyone who opens a patent's page on patents.google.com — no account required — can see its full bibliographic record, description, claims, classifications, and citation lists. A few adjacent categories of patent information simply aren't published on Google Patents at all, at any access level.

Data Category	Publicly Available on Google Patents	Restricted (not on Google Patents)
Bibliographic data (number, title, dates, assignee, inventors)	Yes	—
Full description and claims text	Yes	—
Backward/forward citation lists	Yes	—
Patent family members	Yes	—
CPC/IPC classification codes	Yes	—
Similar documents / prior-art suggestions	Yes	—
Legal status and prosecution history (office actions)	No	Requires USPTO Public PAIR or the relevant national patent office system
Litigation, licensing, and ownership-transfer records	No	Requires court dockets (e.g. PACER) or IP transaction databases

Google Patents & Citation Network Scraper only returns publicly visible data — what any visitor sees on patents.google.com. Nothing behind a login wall.

What data can I extract with Google Patents & Citation Network Scraper?

Google Patents & Citation Network Scraper returns one JSON row per patent covering identity/bibliographic data, full text, and a labeled citation network, plus optional child datasets for citations and similar documents.

Field Name	Description
patentNumber	Publication number (e.g. US11234567B2)
title	Cleaned patent title
abstract	Patent abstract/snippet
inventors	Array of inventor names
assignee	Assignee/owning organization
filingDate	Filing date
publicationDate	Publication date
grantDate	Grant date, if granted
priorityDate	Earliest priority date, if available
language	Primary document language
docId	Google Patents internal document ID
rank	Result rank on the search page this patent was found on
url	Canonical patents.google.com URL
pdfUrl	Direct PDF download URL
thumbnailUrl	First-figure thumbnail image URL, if any
figures	Array of {thumbnailUrl, fullUrl} figure images
classifications	{cpc: [...], ipc: [...]} classification codes (populated when includeClassificationCodes is on)
fullText	{description, claims} full text (populated per includeFullDescription / includeClaimsText)
patentFamily	Array of related publication numbers in the same patent family
citations	{citedBy: [...], references: [...]} — bare publication-number strings (base-compatible field)
citationNetwork	{references: {original, familyToFamily}, citedBy: {original, familyToFamily}} — each entry a full record: publicationNumber, title, assignee, priorityDate, publicationDate, url, citedBySource ("examiner" or "applicant")
citationCounts	{referencesOriginal, referencesFamilyToFamily, citedByOriginal, citedByFamilyToFamily} counts
nonPatentCitations	Array of non-patent-literature citation strings (journal articles, standards docs)
similarDocuments	Array of {publicationNumber, isPatent, title, publicationDate, url} related/prior-art hits
totalNumResults	Total number of results for the search this patent came from
resultPage	Search result page this patent was found on
scrapedAt	ISO-8601 UTC timestamp of when the row was collected
type	Row type — "patent" for regular rows

Patent identity and bibliographic fields

patentNumber, title, abstract, inventors, assignee, filingDate, publicationDate, grantDate, priorityDate, language, docId, url, pdfUrl, thumbnailUrl, figures, classifications.

Citation network and prior-art fields

citations, citationNetwork, citationCounts, nonPatentCitations, similarDocuments, patentFamily.

Full text and search-context fields

fullText, rank, totalNumResults, resultPage, scrapedAt, type.

🤖 Add-on: Need additional research data?

Scraper-Engine doesn't currently have another patent-, IP-, or citation-network-specific scraper to pair this one with — this is the only Actor in the catalog covering Google Patents. If your research also touches other Google properties, Google Trends Scraper and Google Hotels Scraper are available in the same account for trend and travel-pricing data respectively.

How does Google Patents & Citation Network Scraper differ from the official Google Patents API?

Google doesn't publish a keyword-in, JSON-out REST API for Google Patents — the closest official surface is Google Patents Public Data, distributed as bulk tables on Google Cloud BigQuery, which means a Google Cloud project with billing enabled and working SQL/BigQuery knowledge before you can run a single query.

Feature	Google Patents Public Data (BigQuery)	Google Patents & Citation Network Scraper
Access method	SQL queries against BigQuery tables	Apify Actor run, structured JSON out
Setup required	GCP account, billing enabled, BigQuery/SQL skills	Apify account, fill in the input form
Update cadence	Periodic bulk snapshot exports	Live scrape of patents.google.com at run time
Citation format	Publication-number references in relational tables, joins needed to expand them	Citations pre-expanded into full records, labeled examiner vs applicant, original vs family-to-family
Filtering	Custom SQL you write yourself	Built-in assignee, inventor, date-range, country, and document-kind filters — no SQL
Output format	BigQuery result table	Structured JSON, exportable as CSV/Excel

Use BigQuery if you need bulk, warehouse-scale historical analysis and already have GCP/SQL infrastructure. Use Google Patents & Citation Network Scraper when you want current, citation-expanded JSON for a specific search, patent list, or ongoing monitoring run without setting up a data warehouse.

How to use Google Patents & Citation Network Scraper

Google Patents & Citation Network Scraper runs as an Apify Actor — no separate signup or API onboarding beyond an Apify account.

1. Open the Actor's page on the Apify Store or in your Apify Console.
2. Provide at least one of keywordQuery, patentLinksOrSearchLinks, or publicationNumbers — the Actor needs one of these to know what to search for (nothing is returned if all three are empty).
3. Optionally narrow with assigneeFilter, inventorFilter, patentOffice, publishedAfter/publishedBefore, or documentKind, and toggle which enrichment fields you want (citation network, claims, family, classifications, similar documents).
4. Start the run.
5. Download the dataset as JSON or CSV, or stream it via the Apify API — the citation and similar-documents child datasets appear on the run's Storage tab when their toggles are on.

How to scale to bulk Google Patents extraction

Both patentLinksOrSearchLinks and publicationNumbers accept multiple lines in a single run — paste as many patent links or publication numbers as you need, and they're deduplicated and OR-merged automatically. maxPatents caps how many patents a single keyword/filter search expands into (set it to 0 for no cap). For genuinely separate keyword searches, run the Actor once per query rather than trying to combine unrelated searches in one keywordQuery value.

What can you do with Google Patents data?

• A patent attorney doing freedom-to-operate work uses citationNetwork and patentFamily to map blocking prior art around a target technology before filing.
• An R&D or competitive-intelligence analyst uses assignee and classifications to track which competitors are filing in a given CPC/IPC technology area.
• An IP due-diligence analyst valuing a portfolio uses citationCounts.citedByOriginal and citedByFamilyToFamily as a signal of how influential a given patent is.
• A prior-art searcher uses similarDocuments and nonPatentCitations to surface related patents and non-patent literature the examiner already considered.
• An AI engineer builds a patent-research assistant by feeding title, abstract, and fullText.claims into a vector store, letting an LLM agent answer prior-art questions grounded in real patent text instead of hallucinating citations.

How does Google Patents & Citation Network Scraper handle rate limits and blocking?

Requests go out through a proxy ladder: direct first, then Apify's Datacenter proxy group, then Residential proxy, retrying up to three times per stage; once a stage succeeds, the run sticks with that proxy tier for subsequent requests. Concurrent HTTP connections are capped at 8, and a short randomized 1–2 second delay is added between sequential requests. The Actor does not solve CAPTCHAs. If a specific patent's detail page can't be fetched after the proxy ladder is exhausted, that patent is still saved with whatever bibliographic fields came from the search results, logged as having "limited detail," rather than failing the whole run.

⬇️ Input

Parameter	Required	Type	Description	Example Value
patentLinksOrSearchLinks	No	array	One entry per line: patent URLs, search URLs (with q=), or plain keywords. Plain lines are search phrases, OR-merged with keywordQuery.	["https://patents.google.com/patent/US12438891B1", "citation network"]
keywordQuery	No	string	Main keyword search. OR-merged with any q= terms from search URLs and with publication numbers.	"neural network training"
publicationNumbers	No	array	Specific publication numbers to pull the full citation network for. Combined with keywords using OR.	["US11234567B2"]
assigneeFilter	No	string	Focus on patents owned by a particular organization.	"Acme Robotics, Inc."
inventorFilter	No	string	Find patents listing a specific inventor.	"Jane A. Doe"
patentOffice	No	string (enum)	Country/office filter — ANY or one of 38 office codes (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).	"US"
publishedAfter	No	string	Calendar date (YYYY-MM-DD) or relative range (e.g. 30 days, 6 months). Empty = no lower bound.	"2020-01-01"
publishedBefore	No	string	Same format as above. Empty = no upper bound.	""
documentKind	No	string (enum)	ANY, PATENT (granted), APPLICATION, or DESIGN.	"PATENT"
maxPatents	No	integer	Cap on how many patents to build a citation network for. 0 = no limit.	10
includeCitationNetwork	No	boolean	Adds backward/forward citations expanded into full records, labeled examiner- vs applicant-cited and original vs family-to-family; also fills the flat citations field and a <runId>-citations child dataset.	true
maxCitationsPerGroup	No	integer	Safety cap on expanded records built per citation group and per similar-document list. 0 = no cap.	50
includeNonPatentLiteratureCitations	No	boolean	Adds journal articles/standards/other non-patent citations as nonPatentCitations.	true
includeSimilarDocuments	No	boolean	Adds Similar Documents (related patents + Google-Scholar prior-art hits) as similarDocuments and a <runId>-similar-documents child dataset.	true
includeFullDescription	No	boolean	Adds the full written patent description text.	false
includeClaimsText	No	boolean	Adds the patent claims text.	true
includeFamilyMembers	No	boolean	Adds related publications in the same patent family.	true
includeClassificationCodes	No	boolean	Adds CPC/IPC classification codes.	true
proxySettings	No	object	Apify Proxy configuration. Leave the default if you don't need to change it.	{"useApifyProxy": true}

Example input

{
  "patentLinksOrSearchLinks": ["https://patents.google.com/patent/US12438891B1", "autonomous drone navigation"],
  "keywordQuery": "machine learning",
  "publicationNumbers": ["US11234567B2"],
  "assigneeFilter": "Acme Robotics, Inc.",
  "inventorFilter": "",
  "patentOffice": "US",
  "publishedAfter": "2019-01-01",
  "publishedBefore": "",
  "documentKind": "PATENT",
  "maxPatents": 25,
  "includeCitationNetwork": true,
  "maxCitationsPerGroup": 50,
  "includeNonPatentLiteratureCitations": true,
  "includeSimilarDocuments": true,
  "includeFullDescription": false,
  "includeClaimsText": true,
  "includeFamilyMembers": true,
  "includeClassificationCodes": true,
  "proxySettings": { "useApifyProxy": true }
}

⬆️ Output

Each patent is one typed JSON row in the default dataset, with a consistent field set regardless of which patent or search matched. Export the dataset as JSON, CSV, Excel, or the other formats Apify's dataset export supports. Once per run, a single type: "searchSummary" row (whole-result-set assignee/inventor/CPC facets) is also pushed to the default dataset — filter it out with type === "patent" if you only want per-patent rows, since it isn't a citation record. When includeCitationNetwork or includeSimilarDocuments is on, the run also writes to two separate named datasets, <runId>-citations and <runId>-similar-documents, visible on the run's Storage tab.

Example output

{
  "patentNumber": "US11234567B2",
  "title": "Machine Learning System for Autonomous Navigation",
  "abstract": "A system and method for training a navigation model using sensor fusion data...",
  "inventors": ["Jane A. Doe", "Wei Chen"],
  "assignee": "Acme Robotics, Inc.",
  "filingDate": "2019-03-14",
  "publicationDate": "2022-02-01",
  "grantDate": "2022-02-01",
  "priorityDate": "2019-03-14",
  "language": "en",
  "docId": "abcdef123456",
  "rank": 1,
  "url": "https://patents.google.com/patent/US11234567B2",
  "pdfUrl": "https://patentimages.storage.googleapis.com/US11234567B2.pdf",
  "thumbnailUrl": "https://patentimages.storage.googleapis.com/thumb/US11234567B2-0.png",
  "figures": [
    { "thumbnailUrl": "https://patentimages.storage.googleapis.com/thumb/US11234567B2-0.png", "fullUrl": "https://patentimages.storage.googleapis.com/full/US11234567B2-0.png" }
  ],
  "classifications": { "cpc": ["G06N 3/08", "G05D 1/0221"], "ipc": ["G06N 3/08"] },
  "fullText": { "claims": "1. A method comprising: receiving sensor data from a plurality of..." },
  "patentFamily": ["EP3712345A1", "WO2020123456A1"],
  "citations": { "citedBy": ["US10987654B2"], "references": ["US9876543B1"] },
  "citationNetwork": {
    "references": {
      "original": [
        { "publicationNumber": "US9876543B1", "title": "Sensor Fusion for Robotics", "assignee": "Robotics Labs Inc.", "priorityDate": "2016-05-02", "publicationDate": "2018-01-09", "url": "https://patents.google.com/patent/US9876543B1", "citedBySource": "examiner" }
      ],
      "familyToFamily": []
    },
    "citedBy": {
      "original": [
        { "publicationNumber": "US10987654B2", "title": "Autonomous Drone Path Planning", "assignee": "SkyNet Dynamics", "priorityDate": "2020-06-11", "publicationDate": "2023-04-18", "url": "https://patents.google.com/patent/US10987654B2", "citedBySource": "applicant" }
      ],
      "familyToFamily": []
    }
  },
  "citationCounts": { "referencesOriginal": 1, "referencesFamilyToFamily": 0, "citedByOriginal": 1, "citedByFamilyToFamily": 0 },
  "nonPatentCitations": ["Smith et al., \"Deep Learning for Robotic Navigation\", IEEE Trans. Robotics, 2019"],
  "similarDocuments": [
    { "publicationNumber": "US20210123456A1", "isPatent": true, "title": "Vision-Based Obstacle Avoidance System", "publicationDate": "2021-05-06", "url": "https://patents.google.com/patent/US20210123456A1" }
  ],
  "totalNumResults": 4820,
  "resultPage": 0,
  "scrapedAt": "2026-07-25T14:02:11Z",
  "type": "patent"
}

How does it work?

Google Patents & Citation Network Scraper calls the same internal search and result endpoints (xhr/query, xhr/result) that the patents.google.com web app itself uses, so it sees exactly what a visitor's browser sees. Requests start direct and automatically escalate through Apify's Datacenter and then Residential proxy groups if blocked, with small randomized delays between requests. Citation, similar-document, classification, and family data are all extracted from the same detail-page HTML already fetched for the base record, so enabling them adds no extra HTTP requests. Only publicly visible page content is ever returned — no login, cookies, or session state are used — and the output field names stay the same regardless of how Google redesigns the patents.google.com page layout.

Integrations

Google Patents & Citation Network Scraper works wherever you can make an HTTP call or run an Apify Actor — no Google-specific SDK required.

Calling Google Patents & Citation Network Scraper programmatically

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("google-patents-and-citation-network-scraper").call(run_input={
    "keywordQuery": "autonomous navigation",
    "maxPatents": 25,
    "includeCitationNetwork": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

MCP integration for AI agents

Google Patents & Citation Network Scraper is reachable through Apify's Actors MCP Server, which exposes any Apify Actor as a callable MCP tool. Register it by running npx -y @apify/actors-mcp-server --actors google-patents-and-citation-network-scraper (with your APIFY_TOKEN set) and connect it as an MCP server in Claude Desktop, Claude Code, or any other MCP-compatible client — the Actor then appears as a tool the agent can call with keywordQuery or publicationNumbers directly.

No-code tools (n8n, Make, LangChain)

In n8n, use the HTTP Request node pointed at Apify's run-sync-get-dataset-items endpoint for this Actor, passing your search input as the request body. In Make, use the Apify app's "Run Actor and get dataset items" module and map your keyword or patent-number input into its input field. In LangChain, load results through the Apify dataset loader after a run completes, and pass each row's abstract and fullText.claims into your chain as document content.

Is it legal to scrape Google Patents?

Yes — scraping publicly available Google Patents data, the kind visible to any visitor without logging in, is generally permissible, though Google's own Terms of Service place restrictions on automated access, so use is at your own discretion. Google Patents & Citation Network Scraper only returns publicly available data: patent numbers, titles, claims, assignees, inventors, and citations, all of which are part of the public patent record filed with a patent office — comparable to any other public legal or business filing rather than personal data scraped from a private profile, even though inventor names are technically personal names, because they appear as part of a public statutory record. Consult legal counsel if your use case involves bulk storage or redistribution of this data at scale.

Frequently asked questions

What Google Patents fields does Google Patents & Citation Network Scraper return?

It returns patentNumber, title, assignee, citationNetwork, and similarDocuments per patent, along with full bibliographic, classification, and full-text fields. See What data can I extract above for the full field list.

Does Google Patents & Citation Network Scraper require a Google account or login?

No. It fetches Google Patents' own public search and detail-page endpoints over plain HTTP with no cookies or session — no Google account, password, or login of any kind is used.

How many patents can I extract in one run?

There's no hard ceiling in the input schema — maxPatents defaults to 10 and accepts any number, with 0 meaning no limit (be mindful of run time on very broad, uncapped searches, since each enriched patent requires its own detail-page fetch).

What happens if a patent number doesn't exist?

If a publication number in publicationNumbers doesn't resolve to a real patent, that entry is silently skipped and the run continues with any other numbers, keywords, or filters you provided. If none of your search criteria match anything at all, the run finishes with zero rows and logs "No patents matched your criteria" rather than erroring out.

Can I scrape multiple Google Patents at once?

Yes. patentLinksOrSearchLinks and publicationNumbers both accept multiple lines per run — every entry is deduplicated and OR-merged into a single search, so you don't need to loop runs for a batch of known patents.

How does the citation network actually work?

It's a real, one-hop citation extraction, not just a label: for each patent in your results, the Actor reads the backward-reference and forward-citation rows already present in that same patent's detail-page HTML (the same page the base fields come from), expands each cited/citing publication number into a full record (title, dates, assignee), and labels it examiner- vs applicant-cited and original vs family-to-family — all with zero extra HTTP requests. It does not recursively crawl citations-of-citations into a multi-hop graph; each patent's citationNetwork covers its own direct references and citers only. To follow the network further, run the Actor again against a specific citation's publicationNumber.

Does Google Patents & Citation Network Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes. It's callable as a standard HTTP API by any agent framework, and reachable through Apify's Actors MCP Server for MCP-compatible clients such as Claude.

Does Google Patents & Citation Network Scraper return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with consistent field names across runs — no HTML parsing or CSS selectors needed. Pass it directly to an LLM, index it in a vector store, or feed it to an agent tool.

What happens when Google Patents changes its layout or anti-bot system?

The Actor is maintained and its output schema is designed to stay stable across Google Patents layout changes. No specific fix turnaround time is promised.

Can I use Google Patents & Citation Network Scraper without managing proxies or browser infrastructure?

Yes. The Actor tries a direct request first and automatically escalates through Apify's Datacenter and Residential proxy groups on its own if blocked — you don't need to configure or rotate proxies yourself, though the proxySettings input lets you tune this if you want to.

Which Google Patents fields work best for AI training data and RAG indexing?

abstract and fullText.claims are the highest-information text fields for RAG indexing. patentNumber, assignee, classifications, and citationCounts are consistently structured across every record, making them well suited to training-data pipelines — all fields return as typed primitives (strings, arrays, and objects), with no HTML to strip.

Related scrapers

Scraper Name	What it extracts
Google Trends Scraper	Search-interest trend data from Google Trends
Google Hotels Scraper	Hotel listings and pricing data from Google Hotels

Scraper-Engine doesn't currently have another patent- or IP-research-specific scraper — these are the account's other Google-platform data Actors.

Your feedback

Found a bug or missing a field? Let us know through this Actor's Issues tab on Apify so we can take a look. Feedback like this directly shapes what gets fixed and added next.