Patent Semantic Monitor

Monitor newly published patents that match your keywords. Use it to track competitive IP — what your rivals (or a whole technology area) are filing and getting granted — and feed the results into alerts, dashboards, or downstream analysis.

The actor works out of the box with no API key: it queries the public Google Patents search endpoint. It can optionally use the richer USPTO PatentsView "PatentSearch" API if you supply a (free) key.

Key features

• 🔑 No API key required — runs immediately against the public Google Patents endpoint; add a free USPTO key only if you want richer structured fields.
• 🆕 Newest-first monitoring — results are date-sorted, so the actor behaves as a "latest filings" watcher, not a static search.
• 🌐 Two data sources, automatic fallback — Google Patents by default; USPTO PatentsView when a key is supplied, with auto-fallback to Google Patents if the USPTO path errors.
• 🛡️ Proxy IP rotation built in — requests route through Apify Proxy on the platform to dodge Google's per-IP rate limiting; nothing to configure.
• ✅ Never hard-fails — no matches simply finishes with an empty dataset (exit 0), so scheduled runs stay green.
• 📦 Flat, stable schema — one clean record per patent, ready for sheets, dashboards, webhooks, or downstream actors.
• ⏰ Schedule-friendly — pair with Apify Schedules + the dateFrom/lookbackDays window to get a recurring "new patents since last run" feed.

Use cases

• Competitive IP monitoring — track everything a named competitor (or a technology area) files and gets granted, newest-first, on a weekly schedule.
• Freedom-to-operate (FTO) scouting — surface recently published patents around a product concept before you commit engineering resources.
• R&D & technology-trend tracking — watch a fast-moving field (e.g. "quantum computing", "solid-state battery") and feed counts/titles into a trend dashboard.
• M&A / investment diligence — pull a target company's recent patent activity as a quick signal of where their R&D dollars are going.
• Patent-landscape alerts — wire the dataset into a webhook or Slack/email integration to get pinged when new matches appear.

What it does

1. Takes a list of keywords plus an optional date floor.
2. Queries a patent data source, sorted newest-first, and pages through results until it has up to maxResults records.
   • Default (no key): the public Google Patents search XHR endpoint (https://patents.google.com/xhr/query). Free, keyless.
   • Optional (with key): the USPTO PatentsView PatentSearch API (https://search.patentsview.org/api/v1/patent/), which provides cleaner structured fields. If this path errors, the actor automatically falls back to the free Google Patents source.
3. Normalizes every record into a single flat shape and pushes it to the dataset.

On the Apify platform, Google Patents requests are routed through Apify Proxy (auto/datacenter) so requests rotate IPs and avoid the rate-limiting Google applies to a single repeated IP. No proxy configuration is required from you.

Input

All inputs are optional. With an empty input the actor runs with sensible defaults (keywords: ["agent", "optimization"], ~10-year lookback, 100 results).

Field	Type	Default	Description
keywords	array of strings	["agent", "optimization"]	Search terms. Matched against patent title and abstract. Terms are joined into a single query phrase.
apiKey	string (secret)	none	Optional. A free USPTO PatentsView PatentSearch API key. If set, the actor uses the USPTO source instead of Google Patents. Can also be provided via the PATENTSVIEW_API_KEY environment variable. Request one at https://patentsview.org/.
dateFrom	string (YYYY-MM-DD)	none	Only return patents published/granted on or after this date. If omitted, lookbackDays is used.
lookbackDays	integer	3650	Used only when dateFrom is blank: include patents from the last N days. The ~10-year default ensures results out of the box.
maxResults	integer (1–1000)	100	Maximum number of records to return.

Example input

{
  "keywords": ["quantum computing"],
  "dateFrom": "2025-01-01",
  "maxResults": 50
}

To use the USPTO source instead:

{
  "keywords": ["insulin pump"],
  "apiKey": "YOUR_PATENTSVIEW_KEY",
  "lookbackDays": 365,
  "maxResults": 100
}

Output

Each dataset item has this shape:

{
  "patentId": "US11650869B2",
  "title": "Quantum computing service with local edge devices...",
  "applicant": "International Business Machines Corporation",
  "abstract": "A short snippet describing the patent...",
  "filingDate": "2023-05-16",
  "url": "https://patents.google.com/patent/US11650869B2/en"
}

Field	Description
patentId	Publication number (e.g. US11650869B2).
title	Patent title (HTML stripped to clean text).
applicant	Assignee organization. Falls back to the inventor, then "N/A", if no assignee is listed.
abstract	A short snippet/abstract (HTML stripped). May be null when the source provides none.
filingDate	The record's date — publication date when available, otherwise grant/filing date.
url	Link to the patent on Google Patents (may be null if no ID could be resolved).

You can export the dataset as JSON, CSV, Excel, or HTML from the run's Storage tab, pull it via the Apify API, or push it onward with an integration (Make, Zapier, Slack, webhooks, Google Sheets).

Note on field naming: applicant maps to the patent's assignee, and filingDate is the publication/grant date (not strictly the application filing date) on the default Google Patents path. These names are kept for a stable, simple schema.

Behavior and limitations

• Sorted newest-first. Results are ordered by date (sort=new), so the actor behaves as a "newest filings" monitor rather than a relevance-ranked search.
• Keyword matching is broad. On the free Google Patents path, terms are matched loosely against title/abstract; because results are sorted by date rather than relevance, the newest matches can include patents only loosely related to your keywords. Use more specific multi-word keywords to tighten results, or supply an apiKey for the USPTO any-word title/abstract search.
• No results is not an error. If nothing matches, the actor logs a warning and finishes successfully with an empty dataset (exit 0) — it never hard-fails.
• Rate limiting. Google may throttle bursts of requests (HTTP 503/429, or an HTML "Sorry…" block page). The actor retries with exponential backoff and uses Apify Proxy IP rotation on the platform. Running locally without a proxy can hit these limits faster.
• USPTO legacy endpoint. The old keyless api.patentsview.org/patents/query endpoint was decommissioned in 2025, which is why the USPTO path now requires a key.

FAQ

Do I need an API key? No. The actor runs out of the box against the public Google Patents endpoint. A free USPTO PatentsView key is optional and only changes the data source to USPTO's structured API.

Will I get blocked or rate-limited? On the Apify platform, requests route through Apify Proxy with IP rotation and exponential-backoff retries, which avoids Google's per-IP throttling in normal use. Running locally without a proxy can hit limits faster.

How fresh is the data? Results are sorted newest-first by publication/grant date. Combine dateFrom (or lookbackDays) with an Apify Schedule to get a recurring "new patents since last run" feed.

Why are some results only loosely related to my keywords? The default Google Patents path sorts by date rather than relevance, so the newest matches can be broad. Use more specific multi-word keywords, or supply a USPTO apiKey for tighter title/abstract matching.

Can I get alerts when new patents appear? Yes — connect the dataset to a webhook or integration (Slack, email, Make, Zapier) so each scheduled run pushes new matches to your channel of choice.

How do I export the results? Download as JSON/CSV/Excel/HTML from the run's Storage tab, or fetch them programmatically via the Apify API.

Does it cost anything to run? You pay only for the Apify platform compute/proxy the run consumes. The patent data sources themselves are free (Google Patents keyless; USPTO PatentsView free with a key).

Running locally

npm install
# put your input in storage/key_value_stores/default/INPUT.json
npx apify run --purge

Locally there is no Apify Proxy, so requests go direct and may be throttled by Google after several calls. On the Apify platform this is handled automatically.

Data sources

• Google Patents public search — https://patents.google.com/ (keyless, default).
• USPTO PatentsView PatentSearch API — https://search.patentsview.org/ (optional, key required).

This actor reads only public patent data; it does not modify anything.