Google Patents & Assignee Portfolio Scraper

Google Patents Scraper — Extract Patents, Portfolios & Citations

Google Patents & Assignee Portfolio Scraper pulls a company's or inventor's entire patent portfolio from Google Patents in one run, returning typed JSON for every patent, plus a per-container portfolio summary and a whole-corpus search summary. No HTML, no selectors — every response is normalized JSON with stable field names, ready to drop into a spreadsheet, database, or LLM pipeline. After a run, you'll have a full list of a company's or inventor's patents, their legal status and ownership history, and aggregate stats on filing activity and classification codes.

What is Google Patents & Assignee Portfolio Scraper?

Google Patents & Assignee Portfolio Scraper is an Apify Actor that queries patents.google.com for a named company, a named inventor, keywords, publication numbers, or direct patent/search links, and returns structured records for every matching patent. It requires no Google account and no login — Google Patents itself is a public index. Beyond a standard keyword search, this variant adds a dedicated portfolio-container mode that pages through every result for a given assignee or inventor instead of stopping at a small default page count.

• Scrape a company's or inventor's full patent portfolio, not just a capped keyword search
• Collect per-patent details: title, abstract, inventors, dates, classifications, citations, patent family, and full claims/description text on request
• Track ownership history with originalAssignee / currentAssignee / ownershipChanged per patent
• Get one portfolio-level summary row per run (filings by year, active-vs-expired ratio, top CPC codes)
• Export results as JSON, CSV, Excel, or any format Apify's dataset supports — no proxy setup required

What data does Google Patents & Assignee Portfolio Scraper collect?

The Actor returns three distinct row types in the same dataset: individual patent records, one portfolio-level summary row per run, and one whole-corpus search-summary row per run.

Data Type	Key Fields	JSON Field Names
Patents	patent number, title, abstract, inventors, dates, legal status	patentNumber, title, abstract, inventors, filingDate, publicationDate, legalStatus, isActive
Ownership & ownership history	original vs. current assignee, ownership-change flag	originalAssignee, currentAssignee, ownershipChanged
Citations, family & classifications	backward/forward citations, patent family, CPC/IPC codes	citations.citedBy, citations.references, patentFamily, classifications.cpc
Portfolio summary (one row per run)	patents by year, active/expired ratio, top CPC codes	patentCountByYear, activeVsExpiredRatio, topCpcCodes
Search summary (one row per run)	whole-result-set facets: top assignees, inventors, related landscapes	topAssignees, topInventors, relatedLandscapes

Need more Google Patents data?

Google Patents & Assignee Portfolio Scraper is currently the only Google Patents Actor published under this account. If you need a different slice of Google Patents data — a lighter, keyword-only scraper without the portfolio and ownership features — check the Apify Store for other Google Patents listings rather than assuming one exists here.

Why not build this yourself?

Google doesn't publish a simple, free, general-purpose API for arbitrary Google Patents lookups. Google Patents Public Datasets exist on BigQuery for bulk analytical queries, and USPTO and EPO each publish their own APIs — but those only cover their own jurisdiction's filings, not a unified live lookup across assignees, inventors, and countries the way patents.google.com's own search does. Building that yourself means reverse-engineering Google's internal query and detail endpoints, maintaining HTML parsers as markup shifts, and running a proxy ladder to stay online — all before you write a single line of analysis code. Google Patents & Assignee Portfolio Scraper already does this: it handles the query building, pagination, per-patent enrichment, and proxy fallback, and returns a stable JSON schema on the other end.

Why do developers and teams scrape Google Patents?

For IP and legal teams

Patent attorneys, paralegals, and licensing teams use this data for prior-art searches, freedom-to-operate checks, and IP due diligence ahead of an acquisition or investment. A common workflow: set portfolioAssignee to the target company, enable includeOwnershipSplit, and filter by jurisdiction, then review legalStatus and ownershipChanged across the full portfolio to see how many patents are still active and whether any have already changed hands — a signal of past licensing or M&A activity.

For R&D and competitive intelligence teams

R&D and competitive-intelligence teams track a competitor's filing cadence and technology focus over time. Setting portfolioInventor or portfolioAssignee with fetchClassifications on returns CPC/IPC codes per patent, and the run's portfolioSummary row aggregates topCpcCodes and patentCountByYear — enough to see whether a competitor's R&D investment in a technology area is growing, shrinking, or shifting, without manually reading hundreds of individual filings.

For patent analytics and data teams

Teams building internal patent-analytics tools or dashboards use the structured patentCountByYear, activeVsExpiredRatio, and topCpcCodes fields directly as pipeline inputs, skipping the parsing step entirely. Because every run also returns a searchSummary row with whole-result-set facets (topAssignees, topInventors, relatedLandscapes), analysts can layer portfolio-level and corpus-level views from a single dataset rather than stitching together separate queries.

For AI engineers and agent builders

AI and RAG builders index patent text — title, abstract, and, when fetchFullDescription/fetchClaims are enabled, the full fullText.description and fullText.claims — into a vector store for patent-search copilots or due-diligence agents. Because every field is typed JSON with stable names, an agent can call this Actor as a tool, receive a company's portfolio, and reason over legalStatus, citations, and patentFamily without a parsing step between the scrape and the LLM context window.

How to scrape Google Patents (step by step)

1. Open Google Patents & Assignee Portfolio Scraper on the Apify Store or in the Apify Console and start a new run — no Google account is required.
2. Enter a portfolioAssignee (company name) or portfolioInventor (inventor name) to pull a full portfolio, or use keywordSearch, publicationIds, or patentLinks for a plain search instead.
3. Narrow the results with jurisdiction, publishedAfter/publishedBefore, and documentKind, and toggle the per-patent enrichment fields (fetchClaims, fetchCitations, fetchPatentFamily, fetchClassifications, fetchFullDescription) you need.
4. Click Start to run the Actor.
5. Download results as JSON, CSV, or Excel from the dataset, or pull them programmatically via the Apify API.

What to do when Google Patents changes its structure

The Actor is actively maintained, and its output schema is kept stable — field names and types stay the same on your end even when Google Patents changes its markup internally, so downstream integrations keep working without changes.

⬇️ Input

No single field is strictly required by the schema, but the run needs at least one of portfolioAssignee, portfolioInventor, keywordSearch, publicationIds, or patentLinks to resolve to a real query — otherwise the run stops immediately with an error instead of returning results.

Parameter	Required	Type	Description	Example Value
portfolioAssignee	No	string	Company/organization name; pulls every patent assigned to it (legacy key: assignee)	"Splunk"
portfolioInventor	No	string	Inventor name; pulls every patent listing them (legacy key: inventor)	""
fullPortfolioMode	No	boolean	When on (default), pages through every result for the container above instead of stopping at a small default	true
maxPortfolioSize	No	integer	Safety cap on patents collected; 0 = entire portfolio (legacy key: maxResults)	40
patentLinks	No	array	Patent URLs, search URLs, or plain keyword lines, one per entry (legacy key: urls)	[]
keywordSearch	No	string	Keyword search, OR-merged with the portfolio container and any links (legacy key: searchQuery)	""
publicationIds	No	array	Specific patent publication numbers to include (legacy key: patentNumbers)	[]
jurisdiction	No	string (enum)	Patent office/country filter; also the reference country for legalStatus (legacy key: country)	"US"
publishedAfter	No	string	Absolute date (YYYY-MM-DD) or relative range (e.g. 30 days) (legacy key: dateFrom)	"2020-01-01"
publishedBefore	No	string	Absolute or relative date, same format as above (legacy key: dateTo)	""
documentKind	No	string (enum)	Limit to granted patents, applications, designs, or any (legacy key: patentType)	"PATENT"
fetchFullDescription	No	boolean	Add the full written description	false
fetchClaims	No	boolean	Add the patent claims text	true
fetchCitations	No	boolean	Add backward/forward citation lists	true
fetchPatentFamily	No	boolean	Add related publications in the same patent family	true
fetchClassifications	No	boolean	Add CPC/IPC classification codes; also feeds the portfolio's top CPC stat	true
includeOwnershipSplit	No	boolean	Add originalAssignee/currentAssignee/ownershipChanged per patent (default on)	true
includePortfolioStats	No	boolean	Add the one-row-per-run portfolio summary (default on)	true
connectionSettings	No	object	Apify Proxy configuration (legacy key: proxyConfiguration)	{"useApifyProxy": true}

Example JSON input:

{
  "portfolioAssignee": "Splunk",
  "portfolioInventor": "",
  "fullPortfolioMode": true,
  "maxPortfolioSize": 40,
  "patentLinks": [],
  "keywordSearch": "",
  "publicationIds": [],
  "jurisdiction": "US",
  "publishedAfter": "2020-01-01",
  "publishedBefore": "",
  "documentKind": "PATENT",
  "fetchFullDescription": false,
  "fetchClaims": true,
  "fetchCitations": true,
  "fetchPatentFamily": true,
  "fetchClassifications": true,
  "includeOwnershipSplit": true,
  "includePortfolioStats": true,
  "connectionSettings": { "useApifyProxy": true }
}

The most common input mistake is leaving portfolioAssignee, portfolioInventor, keywordSearch, publicationIds, and patentLinks all blank — the run has no query to resolve and exits immediately rather than returning an empty dataset.

⬆️ Output

Every run writes to one Apify dataset containing typed, normalized JSON — exportable as JSON, CSV, or Excel. Three row shapes can appear, distinguished by their type field: "patent" (one per matched patent, billed per row), "portfolioSummary" (one per run, free), and "searchSummary" (one per run, free). Only "patent" rows are charged under the row_result event; filter a downloaded dataset on item.type === "patent" if you want to isolate billable records from the two summary rows.

Scraped patent

{
  "type": "patent",
  "patentNumber": "US10110617B2",
  "title": "Systems and methods for detecting anomalous network activity",
  "abstract": "A system for identifying anomalous network activity based on baseline traffic patterns...",
  "inventors": ["Jane Doe", "John Smith"],
  "assignee": "Splunk Inc",
  "filingDate": "2016-03-14",
  "publicationDate": "2018-10-23",
  "grantDate": "2018-10-23",
  "classifications": { "cpc": ["H04L63/1425"], "ipc": ["H04L 63/1425"] },
  "url": "https://patents.google.com/patent/US10110617B2",
  "pdfUrl": "https://patentimages.storage.googleapis.com/pdfs/US10110617B2.pdf",
  "scrapedAt": "2026-07-25T09:12:03Z",
  "citations": { "citedBy": ["US10999999B2"], "references": ["US8990888B2"] },
  "priorityDate": "2016-03-14",
  "language": "en",
  "docId": "abcdef123456",
  "rank": 3,
  "thumbnailUrl": "https://patentimages.storage.googleapis.com/thumbs/US10110617B2-thumb.png",
  "figures": [{ "thumbnailUrl": "https://patentimages.storage.googleapis.com/thumbs/fig1.png", "fullUrl": "https://patentimages.storage.googleapis.com/full/fig1.png" }],
  "totalNumResults": 214,
  "resultPage": 0,
  "legalStatus": { "countryCode": "US", "state": "ACTIVE", "isActive": true },
  "isActive": true,
  "originalAssignee": "Splunk Inc",
  "currentAssignee": "Cisco Technology Inc",
  "ownershipChanged": true,
  "fullText": { "description": "The present disclosure relates to...", "claims": "1. A method comprising..." },
  "patentFamily": ["US10110617B2", "WO2017160823A1"]
}

Portfolio summary

One row per run, added when a portfolioAssignee/portfolioInventor container is set and includePortfolioStats is on:

{
  "type": "portfolioSummary",
  "portfolioAssignee": "Splunk",
  "portfolioInventor": null,
  "scrapedAt": "2026-07-25T09:14:41Z",
  "totalPortfolioSize": 214,
  "collectedCount": 214,
  "portfolioCoverageNote": null,
  "patentCountByYear": { "2018": 12, "2019": 18, "2020": 21 },
  "activeCount": 178,
  "expiredCount": 22,
  "unknownLegalStatusCount": 14,
  "activeVsExpiredRatio": 0.89,
  "topCpcCodes": [{ "code": "H04L63/1425", "count": 34 }, { "code": "G06F21/55", "count": 21 }]
}

Search summary

One free row per run, built from Google's own whole-result-set facets on the first results page:

{
  "type": "searchSummary",
  "patentNumber": null,
  "totalNumResults": 214,
  "summarySampleSize": 214,
  "topAssignees": [{ "name": "Splunk Inc", "count": 214 }, { "name": "Cisco Technology Inc", "count": 46 }],
  "topAssigneesText": "Splunk Inc (214), Cisco Technology Inc (46)",
  "topInventors": [{ "name": "Jane Doe", "count": 9 }],
  "topInventorsText": "Jane Doe (9)",
  "topCpcCodes": [{ "code": "H04L63/1425", "count": 34 }],
  "topCpcCodesText": "H04L63/1425 (34)",
  "relatedLandscapes": [{ "name": "Network security", "type": "technology" }],
  "relatedLandscapesText": "Network security",
  "scrapedAt": "2026-07-25T09:12:00Z"
}

How many results can you scrape with Google Patents & Assignee Portfolio Scraper?

There's no hard cap coded into the Actor itself — maxPortfolioSize sets the ceiling, and 0 means collect the entire portfolio. When a company or inventor container is set with fullPortfolioMode on and no explicit cap given, the Actor defaults internally to unlimited (0); a plain keyword search with no container defaults to 10 unless you raise it. Pagination continues page by page until either your cap is hit or Google Patents stops returning results for that query.

Google Patents' own search index still limits how many results any single query can page through before it plateaus — very large portfolios (thousands of patents) may not be fully retrievable in one query. When that happens, the portfolioSummary row's portfolioCoverageNote reports the shortfall honestly (collected vs. total indexed), and narrowing by date range or jurisdiction pages deeper into a large portfolio.

Integrate Google Patents & Assignee Portfolio Scraper and automate your workflow

Google Patents & Assignee Portfolio Scraper works with any language or tool that can send an HTTP request.

REST API integration

import requests

TOKEN = "YOUR_APIFY_API_TOKEN"
ACTOR_ID = "YOUR_USERNAME~google-patents-and-assignee-portfolio-scraper"

resp = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR_ID}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={"portfolioAssignee": "Splunk", "jurisdiction": "US"},
    timeout=300,
)
resp.raise_for_status()
for row in resp.json():
    if row.get("type") == "patent":
        print(row["patentNumber"], row["title"])

Works in Python, Node.js, Go, Ruby, cURL.

MCP for AI agents

This Actor can be exposed as a callable tool through Apify's own MCP Server, which lets MCP-compatible clients (such as Claude Desktop or Cursor) run any Apify Actor and read its dataset directly inside an agent loop, without a separate scraping or parsing step.

Automation platforms (n8n, Make)

In n8n, the official Apify node's "Run Actor and Get Dataset Items" operation can call this Actor by its Actor ID and pass the same input JSON shown above. In Make, the Apify app's "Run Actor" module does the same — trigger it on a schedule to re-check a company's portfolio for new filings, and route the output straight into a downstream module (a spreadsheet, CRM, or database) without writing any parsing code.

Is it legal to scrape Google Patents?

Yes. Google Patents & Assignee Portfolio Scraper only returns data that is already publicly published — granted patents and published applications are public records that patent offices are legally required to disclose, and Google Patents republishes that same public index. This falls under standard terms-of-service and database-rights considerations rather than GDPR, since the underlying records are official government filings, not incidental personal data collection — even where a patent's inventors field names a real person, that name is part of the patent's own mandated public disclosure. Use the data in line with Google's terms of service, and consult legal counsel before any commercial use involving bulk personal-name data.

Frequently asked questions

Does Google Patents & Assignee Portfolio Scraper work without a Google account?

Yes. Google Patents is a public index with no login wall, so the Actor needs no Google credentials — only an Apify account to run it.

How often is the scraped data updated?

Every run fetches live from patents.google.com at request time; nothing is served from a cache, so each run reflects Google Patents' current index for that query.

What happens if a search or portfolio container returns no patents?

The Actor logs "No patents matched your criteria" and finishes with an empty dataset rather than erroring out — check that the assignee/inventor name is spelled as Google Patents indexes it, or broaden the jurisdiction/date filters.

Can I scrape private or restricted patent content?

No, and there generally isn't any to scrape — Google Patents only indexes granted patents and published applications, which are public by law. The Actor cannot access unpublished or withdrawn applications because Google Patents itself doesn't expose them.

Does Google Patents & Assignee Portfolio Scraper work for AI agent workflows and LLM pipelines?

Yes. It's callable as an HTTP endpoint by any agent framework, and it's also reachable through Apify's MCP Server for MCP-compatible clients. Every response is typed JSON with stable field names, so it can be passed directly into an LLM context window or a vector store without a parsing step.

How does Google Patents & Assignee Portfolio Scraper handle Google Patents' anti-bot system?

Requests go through a proxy ladder — direct first, then an Apify datacenter proxy, then Apify residential proxy — retrying and switching to whichever tier last succeeded. Requests are spaced with small randomized delays, and detail-page enrichment is capped to a handful of concurrent requests at a time to stay under Google Patents' own request tolerance.

Does Google Patents & Assignee Portfolio Scraper return data in a format LLMs can use directly?

Yes. Every row is typed, normalized JSON with stable field names — no HTML, no selectors. You can pass it straight into an LLM context window, index it into a vector store, or route it through an agent tool call.

Can I use Google Patents & Assignee Portfolio Scraper without managing proxies?

Yes. Apify Proxy is used automatically behind the scenes with a built-in retry ladder; the optional connectionSettings input only needs to be touched if you want to customize the default proxy behavior.

What's the difference between the patent, portfolioSummary, and searchSummary rows?

Each type value marks a different row shape in the same dataset: "patent" rows are individual matched patents (the billable rows), "portfolioSummary" is one free aggregate row scoped to the assignee/inventor container you searched, and "searchSummary" is one free aggregate row over the whole result set Google Patents returned for the query.

What happens when Google Patents changes its structure or blocks the scraper?

The Actor is actively maintained, and its output schema stays stable on your end — field names and types don't change even when Google Patents' internal markup does, so downstream integrations keep working without modification.

Your feedback

Found a bug or missing a field? We want to know. Use the Issues tab on this Actor's Apify Store page to report it or request a feature — active issue tracking is how this Actor stays maintained against Google Patents' changes.