# Google Patents Scraper — New Patent Alerts (`magnova/google-patents-scraper`) Actor

Search Google Patents by keyword, assignee, inventor, CPC class and office — publication number, title, abstract excerpt, assignee, inventor, priority/filing/publication/grant dates and Google's family legal stage where computed. Monitoring mode: only-new patents. $0.004 per patent, no start fee.

- **URL**: https://apify.com/magnova/google-patents-scraper.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 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 — New Patent Alerts

**Every new patent publication worldwide, as clean structured records — search the whole Google Patents corpus by keyword, assignee, inventor, CPC class or office, with a monitoring mode that delivers only what's newly published.**

Google Patents indexes patent publications from more than 100 patent offices — tens of thousands of new documents publish every week, and the firms that watch them (competitors filing, technologies emerging, portfolios moving) pay hundreds of dollars a month for watch services. This Actor reads Google Patents through the same public search endpoint its own search page uses (no API key, no login) and turns it into flat, analysis-ready records: publication number, title, abstract excerpt, assignee, inventor, the priority / filing / publication / grant dates, and Google's family legal stage for the patent's office.

It is built scraper-first, with monitoring as a mode: your first run pulls the current corpus for your slice (a keyword, a competitor's assignee name, a CPC class), and scheduled runs after that deliver **only the patents you haven't seen** — the new-publication alerts that snapshot patent scrapers never offer.

### Sample output

A real record, as delivered:

```json
{
  "recordType": "PATENT",
  "publicationNumber": "AU2026208139A1",
  "patentUrl": "https://patents.google.com/patent/AU2026208139A1/en",
  "patentTitle": "Selective extraction of lithium from clay minerals",
  "abstractSnippet": "SELECTIVE EXTRACTION OF LITHIUM FROM CLAY MINERALS Processes for extracting lithium from a clay mineral and compositions thereof are described. The extraction process includes providing a clay mineral comprising lithium, mixing a cation source with the clay mineral, performing a high-energy mill …",
  "office": "AU",
  "kindCode": "A1",
  "isGrant": false,
  "language": "en",
  "priorityDate": "2020-01-03",
  "filingDate": "2026-07-27",
  "publicationDate": "2026-08-13",
  "inventor": "Turner Boris CALDWELL",
  "assignee": "Tesla, Inc.",
  "familyLegalStage": "ACTIVE",
  "familyCountryStatus": [
    { "countryCode": "WO", "stage": "NOT_ACTIVE" },
    { "countryCode": "US", "stage": "ACTIVE" },
    { "countryCode": "CN", "stage": "ACTIVE" },
    { "countryCode": "AU", "stage": "ACTIVE" },
    { "countryCode": "MX", "stage": "UNKNOWN" }
  ],
  "matchedQueries": ["solid state battery"]
}
```

### What you get

Each delivered record (`recordType: "PATENT"`, charged) carries:

| Field | What it is |
|---|---|
| `publicationNumber` | The publication's stable number as published by its office (e.g. `US12438891B1`, `EP4270591A1`) — the dedupe key |
| `patentUrl` | The publication's page on Google Patents |
| `patentTitle` | The patent title, cleaned of search highlight markup (on at least 95% of records) |
| `abstractSnippet` | The abstract excerpt exactly as indexed by Google Patents — a search snippet that can end mid-sentence; the full abstract lives on the patent page (on at least 85% of records) |
| `office` / `kindCode` | The publishing office's two-letter code, and the publication number's WIPO kind-code suffix (`B1`, `A1`, `S1`, …) shipped raw — kind-code meanings are office-specific, so no label is invented for them |
| `isGrant` | `true` when the publication is a granted patent (it carries a grant date), `false` for application publications |
| `priorityDate` / `filingDate` / `publicationDate` / `grantDate` | The register dates (filing date on at least 95% of records; priority date where the publication claims priority — first filings claim none) — grant date only on grants |
| `inventor` | The **first-listed** inventor, exactly as published (on at least 90% of records) — a publication can name more inventors; the search index returns the first |
| `assignee` | The primary assignee, exactly as published (on at least 90% of records) |
| `familyLegalStage` | Google's family-level legal stage for this patent's office — `ACTIVE`, `NOT_ACTIVE` or `UNKNOWN`. Present where Google has computed the family's status: usual for grants and multi-office families, often absent on brand-new first filings. It is a family indicator — a pending application reads `ACTIVE` — not the document's precise legal status |
| `familyCountryStatus` | That family stage for every office in the family: a list of `{countryCode, stage}` |
| `matchedQueries` | Keyword runs only: the query that surfaced this patent |
| `language` | The document's language code as indexed |

Every run ends with one `SUMMARY` record (never charged): how many publications matched, how many were read, delivered, skipped as duplicates or out of window, and whether the run stopped at a cap. If Google Patents cannot be read, the run writes one `ERROR` record plus the summary instead of pretending there were no new patents — and in monitoring mode the state is not advanced, so the next run catches up.

**What is never in a record:** contact data. Patent registers publish inventor and assignee names, and those ship exactly as published — but the source carries no emails, phone numbers or addresses, and if an email address ever appeared inside a text value it would be stripped before the record ships.

### Three ways to run it

**1. Corpus (default).** A run delivers the matching publications for its publication window — the last `backfillDays` complete publication days (default 7), or an explicit `dateFrom`/`dateTo` range (up to 366 days). This is the first-run sale: pull a month of a competitor's publications, a quarter of a technology class, and analyse them offline.

**2. Monitoring mode.** Select one of your key-value stores in the *Monitor state store* input and schedule the run (daily or weekly — patent offices publish on weekly cycles). The first run delivers the window's patents as a charged baseline; every later run delivers only patents the store hasn't seen. Set *Start monitoring silently* (`monitorOnlyNew`) to skip the baseline: the first run just remembers the current patents, and you receive only what appears afterwards. Patents a run couldn't deliver (cap reached, timeout) stay unseen and are delivered by the next run.

**3. Cursor mode.** Hold your own state in Make, Zapier or your scheduler: pass `publishedSince` (an ISO date) and each run delivers patents published on or after that date — stateless incremental, no store needed. Publication dates are day-granular, so the cursor compares by day, boundary-inclusive, and the window is enforced on every record's own publication date: nothing older than the cursor is ever delivered or charged. (Google assembles its result sets per search, so a cursor run can surface in-window patents that a different, broader search's own capped result set didn't happen to include — the cursor is exact about dates, Google is approximate about sets.)

**One source limit, honestly:** Google serves at most about 1,000 results per search. A very broad search (say, "machine learning" over a quarter) tops out near that cap per query — the SUMMARY flags it (`queryCapReached`). Narrower filters, several keyword queries (each is its own search), or split date windows reach deeper corpora.

### Inputs

| Input | What it does |
|---|---|
| `queries` | Keyword searches, one search per entry (up to 10); every other filter applies to each |
| `assignees` | Assignee name filter (OR) — organisation names as published |
| `inventors` | Inventor name filter (OR) — Google's inventor name search |
| `cpcCodes` | CPC class filter (`G06N`, `G06N20/00`, `H04L9/00`, …) |
| `offices` | Patent-office filter (`US`, `EP`, `WO`, `CN`, `JP`, …) |
| `backfillDays` | Publication days back from yesterday (default 7, max 92) |
| `dateFrom` / `dateTo` | Explicit window (overrides `backfillDays`; max 366 days) |
| `publishedSince` | Stateless cursor: patents published on/after this date |
| `monitorStore` | Your key-value store for only-new delivery |
| `monitorOnlyNew` | Skip the charged baseline; start silently |
| `maxResults` | Cap on delivered (charged) patents per run (prefilled 250, max 5,000) |
| `maxTotalChargeUsd` | Hard stop for the run's charges |

Filters within one field combine with OR, fields combine with AND — Google's own search semantics. CPC codes work as a *filter*; a record does not list the patent's CPC classifications (the search index doesn't return them — they live on the patent page), and this listing doesn't pretend otherwise.

### Pricing

**$0.004 per patent delivered** — that's **$4.00 per 1,000 patents** (SILVER $0.0034, GOLD+ $0.0028), **no start fee**.

**Not charged:** duplicates and already-seen patents, results outside your window, results with no usable publication date, silently seeded patents (`monitorOnlyNew` first runs), `ERROR` records and the `SUMMARY`. A scheduled monitoring run on a day with nothing new costs nothing.

**Worked example:** watching four competitors' assignee names on a weekly schedule, surfacing roughly 800 new publications a month, costs about **$3.20 a month**. A one-off 1,000-patent landscape pull costs **$4.00** once.

### Examples

New machine-learning publications from the last 7 days (a typical corpus pull):

```json
{ "queries": ["machine learning"], "backfillDays": 7, "maxResults": 250 }
```

Daily monitoring of one assignee's new publications, started silently, with your store attached:

```json
{ "assignees": ["Toyota"], "backfillDays": 3, "monitorOnlyNew": true, "monitorStore": "<your key-value store>" }
```

A technology-class corpus for one quarter:

```json
{ "cpcCodes": ["G06N20/00"], "dateFrom": "2026-05-01", "dateTo": "2026-07-31", "maxResults": 5000 }
```

### Google Patents API

This Actor is the no-code way to work with Google Patents' public search index: it handles the query syntax, the 100-per-page pagination up to Google's per-search cap, cross-search and cross-run dedupe, window and cursor enforcement, and family-status flattening for you. Compared with snapshot patent scrapers, you get the same index data — plus the delta: only-new delivery and a cursor mode the website tools don't offer.

### Searching trademarks instead?

Patents and trademarks are different registers. If your watch is brand-side — new trademark filings, owners, classes — use Magnova's [USPTO Trademark Search](https://apify.com/magnova/uspto-trademark-search), which reads the official USPTO trademark register. Honest trade-off: that one covers US trademarks only, from the register itself; this one covers patent publications from 100+ offices via Google's index. Invention-side, you're home here; brand-side, that's your actor.

### Use cases

- **Competitive intelligence:** watch rivals' assignee names and get only their new filings and grants — never the same corpus twice.
- **Patent-watch services & agents:** build client alerts on the monitoring mode instead of re-pulling whole searches weekly.
- **Technology scouting:** follow a CPC class or keyword field; a weekly digest of what just published.
- **Portfolio & freedom-to-operate triage:** corpus pulls by assignee, office and window, with family stage per office for first-pass screening.
- **AI agents:** structured, deduped patent data with stable IDs, ready for pipelines and RAG — call it via the Apify API or MCP like any other Actor.

### Using this Actor with AI agents (MCP)

The Actor is agent-ready: every input and output field is described, the example input runs as-is, and a single call with the prefill works zero-shot. Typical agent flow: run once with your filters for the corpus, then schedule runs with a monitor store and consume only the new PATENT records; stop conditions are explicit (`stoppedByMaxCharge`, `stoppedByResultCap`, `streamComplete`, `queryCapReached` in the SUMMARY).

### FAQ

**Is this official patent data?** The publications are official patent-office documents; Google Patents is Google's public index of them. Legal-stage fields are Google's own computed family indicators — useful for triage, not a legal conclusion (Google says the same about its status data).

**Does it need an API key or account?** No. The search index is public and logged-out, and the Actor needs no Google account, login or key — and neither do you.

**Why did my first monitoring run deliver so much?** That's the baseline: the current window delivered once, so later runs can deliver only what's new. Prefer to start from zero? Turn on *Start monitoring silently*.

**Why did a broad search stop around 1,000 results?** That's Google's per-search serving cap, not this Actor's — the SUMMARY's `queryCapReached` flag tells you when it happened. Split the window or narrow the filters to go deeper.

**Why is a patent's CPC classification not in its record?** The search index filters by CPC but doesn't return a document's classifications; those live on the patent page (one click from `patentUrl`). Rather than fetch a multi-megabyte page per patent, the record ships what the index genuinely returns.

**How fresh is it?** A run covers complete publication days up to yesterday by default, so a daily schedule is the natural cadence — but Google adds new publications to its search index on its own schedule, and a document can publish days to weeks before the index serves it. What a run returns is what the index currently serves for your window; the monitoring mode is built for exactly this, since a patent the index adds late is still delivered the first run that can see it.

### Legal

Google Patents is Google's public index of published patent documents from over 100 patent offices — patent publications are public records by design. This Actor reads only that public, logged-out search index: no login, no API key, no CAPTCHA bypass. Records carry inventor and assignee names exactly as published in the official registers, and no personal contact data. Legal-stage fields are Google's own family-level indicators, provided for triage — not legal advice.

# Actor input Schema

## `assignees` (type: `array`):

Optional assignee filter: only patents whose assignee matches one of these names (Google's assignee name search — organisation names as published, e.g. "Toyota", "Samsung Electronics"). Several names are combined with OR. Leave empty for all assignees.

## `backfillDays` (type: `integer`):

How many publication days back the run covers, counting back from yesterday (the last complete publication day — a closed window keeps repeat runs over it identical). The window is ignored when Date from / Date to are set. Scheduled monitoring runs typically use 2-3 days of lookback plus a monitor store, so a missed day never loses patents.

## `cpcCodes` (type: `array`):

Optional filter: only patents classified under one of these CPC (Cooperative Patent Classification) symbols, e.g. "G06N" (computer systems based on specific computational models), "G06N20/00" (machine learning), "H04L9/00" (cryptographic mechanisms). A class or subclass symbol matches everything under it. Leave empty for all classes.

## `dateFrom` (type: `string`):

Optional explicit window start (ISO date, e.g. "2026-10-01"). Must be given together with Date to, and overrides Publication days back. Useful for one-off corpus pulls (e.g. a quarter of publications).

## `dateTo` (type: `string`):

Optional explicit window end (ISO date, e.g. "2026-10-31"). Must be given together with Date from. Maximum window: 366 days.

## `inventors` (type: `array`):

Optional inventor filter: only patents whose inventor names match one of these names (Google's inventor name search). Several names are combined with OR. Leave empty for all inventors.

## `maxResults` (type: `integer`):

Hard cap on patents delivered (and charged) in one run, across all searches in the run. Google serves at most about 1,000 results per search, so a single broad search tops out near 1,000; several keyword queries (or narrower filters / split windows) reach deeper. Patents a capped run could not deliver stay unseen in monitoring mode and are delivered by the next run if they still fall in its window.

## `maxTotalChargeUsd` (type: `number`):

Optional hard stop for this run's charges: delivery stops as soon as the charged patents reach this amount (checked conservatively at the highest per-patent price, so the run may stop slightly early on discounted tiers), and the SUMMARY record reports stoppedByMaxCharge. Undelivered new patents stay unseen, so the next run delivers them. Leave empty for no cap. The run-level maximum charge in the run options is also honoured exactly.

## `monitorOnlyNew` (type: `boolean`):

Off (default): the first run delivers the window's current patents as a baseline batch (charged), later runs deliver only new ones. On: the first run silently remembers the current patents without delivering or charging anything, and only patents published afterwards are ever delivered. Only applies when a monitor store is selected; without a store every run is a baseline run.

## `monitorStore` (type: `string`):

A key-value store this Actor may read and write to remember which patents it has already seen — this is what makes only-new delivery work across runs. Pick any store you own; the Actor keeps one small state record in it. Without a store, every run delivers the window's patents as a baseline and remembers nothing. If the store is missing or cannot be opened, the run continues in baseline mode and the SUMMARY record says so — it never crashes. The Actor remembers every patent it processed (including ones outside the window), so widening the window later does not re-deliver old patents.

## `offices` (type: `array`):

Optional filter: only patents published by these patent offices — two-letter office codes, e.g. "US", "EP" (European Patent Office), "WO" (PCT publications), "CN", "JP", "KR", "GB", "DE". Leave empty for all 100+ offices.

## `publishedSince` (type: `string`):

Optional stateless cursor for workflow tools (Make, Zapier, your own scheduler) that hold state themselves: only patents published on this ISO date or later are delivered — for example "2026-11-01" or "2026-11-01T00:00:00Z". Publication dates are day-granular, so the cursor compares by day, boundary-inclusive. The cursor raises the window start; it does not extend the window end. Leave empty for the normal window behavior.

## `queries` (type: `array`):

Keyword searches, one search per entry (e.g. "machine learning", "solid state battery electrolyte"). Every other filter in the run (assignees, inventors, CPC codes, offices, window) applies to each search. A patent found by several searches is delivered — and charged — once. Leave empty to search by filters alone (e.g. one assignee's whole output). At least the publication window always bounds the run.

## Actor input object example

```json
{
  "assignees": [
    "Toyota"
  ],
  "backfillDays": 7,
  "cpcCodes": [
    "G06N20/00"
  ],
  "dateFrom": "2026-10-01",
  "dateTo": "2026-10-31",
  "inventors": [
    "Goodenough"
  ],
  "maxResults": 1000,
  "maxTotalChargeUsd": 1,
  "monitorOnlyNew": false,
  "offices": [
    "US",
    "EP"
  ],
  "publishedSince": "2026-11-01",
  "queries": [
    "machine learning"
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "backfillDays": 7,
    "maxResults": 250,
    "monitorOnlyNew": false,
    "queries": [
        "machine learning"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "backfillDays": 7,
    "maxResults": 250,
    "monitorOnlyNew": False,
    "queries": ["machine learning"],
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/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 '{
  "backfillDays": 7,
  "maxResults": 250,
  "monitorOnlyNew": false,
  "queries": [
    "machine learning"
  ]
}' |
apify call magnova/google-patents-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,magnova/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 <APIFY_API_TOKEN>` 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/Lf9fIUbc9GsIEXaSR/builds/6OKPo7wYK7YuxZiba/openapi.json
