# Patent Filing Monitor (`zinin/patent-monitor`) Actor

Watch keywords or technologies for newly granted US patents. Bring your own free PatentsView API key — get patent id, title, grant date, assignee and a direct Google Patents link for every match, sorted by most recent. Official PatentsView Search API (USPTO-backed).

- **URL**: https://apify.com/zinin/patent-monitor.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Categories:** News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 result founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Patent Monitor — Track New Patents by Keyword

Give this Actor a keyword or technology and get back the patents that were just published matching it, worldwide, newest first. It reads the keyless Google Patents search endpoint by default — no key, no browser, no LLM — and switches to the official USPTO-backed PatentsView API if you supply your own free key.

### What you get

- **A patent feed with zero setup.** Works with no key at all, worldwide coverage, right out of the box.
- **Bring your own free PatentsView key** to switch to the official USPTO-backed source: US patents only, but more results per query and a more stable feed.
- `patentId`, title, grant/publication date, assignee, an abstract snippet, and a direct Google Patents link — per matching patent.
- Query by technology or keyword (`"quantum computing"`, `"mRNA vaccine"`) — several per run, most-recent-first.
- Runs on Apify: schedule it, monitor it, call it from the API or the MCP server, export to JSON, CSV or Excel, or push results straight into your own pipeline.

### How to run it

1. Click **Try for free** — no card needed on the free plan, no key required either.
2. Paste keywords or technologies into **Queries**, one per line — e.g. `quantum computing`, `mRNA vaccine`.
3. Hit **Start** and pull the patents from the dataset (UI, API or webhook). Optionally paste a free PatentsView key into **PatentsView API key** first to use the US-only official source.

### Pricing

Pay-per-event: **$0.005 per run start + $0.005 per patent row**. No monthly seat, no PatentsView key required to run it. 100 patent rows cost about **$0.51**; 1,000 rows about **$5.01**.

The keyless Google Patents source occasionally blocks or rate-limits an automated request and returns HTML instead of JSON. That query still returns a row explaining the source error, and it is **not** charged — you pay for patents found, not for attempts. If you see this often, supply your own free PatentsView key (see FAQ) for a more stable feed.

### Input

| Field | Required | What it does |
|---|---|---|
| `queries` | yes | Tech keywords or technologies to watch. Up to 25 per run. |
| `sinceDays` | no | Only include patents granted/published within N days (1–3650, default 365). |
| `patentsviewApiKey` | no | Your own free PatentsView key. Leave empty for the keyless, worldwide Google Patents source; supply a key to switch to the official USPTO-backed source (US only, more results per query). Sent only in the request header, never logged. |
| `limit` | no | Patents returned per query, most recent first (1–100, default 20). |
| `maxConcurrency` | no | How many queries to process at once (1–8, default 3). |

```json
{
    "queries": ["quantum computing", "mRNA vaccine"]
}
```

### Output

One row per matching patent. This is a real row from a real run:

```json
{
    "sourceQuery": "quantum computing",
    "found": true,
    "patentId": "AU2026202728A1",
    "title": "Wind-powered computing buoy",
    "patentDate": "2026-04-30",
    "assignee": "Lone Gull Holdings, Ltd.",
    "abstractSnippet": "Disclosed is a novel type of computing apparatus which is integrated within a buoy that obtains the energy required to power its computing operations from winds that travel across the surface of the body of water on which the buoy floats. Additionally, these self-powered computing buoys utilize …",
    "url": "https://patents.google.com/patent/AU2026202728A1/en",
    "summary": "Wind-powered computing buoy (Lone Gull Holdings, Ltd.) — published 2026-04-30.",
    "checkedAt": "2026-07-26T14:01:37.925Z"
}
```

| Field | What it means |
|---|---|
| `patentId` | Publication number (keyless source covers US, EP, CN, KR, AU and more — not US-only) |
| `title` | Patent title |
| `patentDate` | Grant date (PatentsView source) or publication date (Google Patents source) |
| `assignee` | Owning company, organization or, for some jurisdictions, the named inventor |
| `abstractSnippet` | First part of the patent abstract |
| `url` | Direct Google Patents link |
| `found` | `false` means no match, or the source could not be reached — the row explains why and is not billed |

A query the source could not answer (blocked, rate-limited, temporarily down) still returns one row with `found: false` and an `error` field explaining what happened.

#### Need the rest of the picture?

These run on the same account, take the same shape of input and bill the same way, so they slot into an existing pipeline without new plumbing.

| Actor | What it does |
|---|---|
| [Clinical Trials Monitor](https://apify.com/zinin/clinical-trials-monitor) | Watch conditions, drugs or sponsors for new and updated clinical trials |
| [FDA Approval Feed](https://apify.com/zinin/fda-approval-feed) | Watch drugs or companies for new FDA approvals and recalls |
| [AI Crawler Access Checker](https://apify.com/zinin/ai-crawler-access-checker) | Check which AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended & more) can access your website |
| [B2B Lead Enricher](https://apify.com/zinin/b2b-lead-enricher) | Turn a list of company websites into sales-qualified lead cards: detected tech stack, a rough revenue… |
| [Company Hiring Radar](https://apify.com/zinin/company-hiring-radar) | Pull every open role a company is hiring for from its public job board (Greenhouse, Lever, Ashby) and turn… |

### FAQ / Limitations

**Do I need an API key?** No — the default source (Google Patents) is keyless and worldwide. A free PatentsView key is optional; it switches you to the official USPTO-backed source for US patents with deeper results per query. Get one at [patentsview.org/query-builder](https://patentsview.org/query-builder).

**Which patents does the keyless source cover?** Whatever Google Patents itself indexes worldwide — patents from major patent offices (US, EP, CN, KR, AU and more), matched on title text and sorted newest-published-first.

**Why did I get a row with an error instead of patents?** The keyless Google Patents endpoint occasionally blocks or rate-limits automated requests and returns an HTML page instead of JSON. That row is returned so you know what happened, and it is not charged. A PatentsView key avoids this entirely for US patents.

**Can I call it from an AI agent?** Yes — standard Apify Actor, callable via the Apify API or the Apify MCP server.

**What this is NOT.** It is not a legal or novelty-search tool — it's a keyword feed of what's new. For a freedom-to-operate or prior-art search, use a patent attorney or a dedicated search tool.

Found a wrong result, or need a check we don't run? Open an issue on this Actor's page.

***

Built by [zinin](https://apify.com/zinin). Questions? Telegram [@timzinin](https://t.me/timzinin).

# Actor input Schema

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

Tech keywords or technologies to watch (e.g. `quantum computing`, `mRNA vaccine`). One or more matching patent rows per query.

## `sinceDays` (type: `integer`):

Only include patents granted within N days.

## `patentsviewApiKey` (type: `string`):

Optional. Leave empty to use the keyless Google Patents source (worldwide). Provide your own free PatentsView key (https://patentsview.org/query-builder) to use the official USPTO-backed source (US patents, more results/query). Sent only in the X-Api-Key header — never logged or stored.

## `limit` (type: `integer`):

How many patents to fetch per query, most recently granted first.

## `maxConcurrency` (type: `integer`):

How many queries to process in parallel.

## Actor input object example

```json
{
  "queries": [
    "quantum computing",
    "mRNA vaccine"
  ],
  "sinceDays": 365,
  "limit": 20,
  "maxConcurrency": 3
}
```

# 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 = {
    "queries": [
        "quantum computing",
        "mRNA vaccine"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/patent-monitor").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 = { "queries": [
        "quantum computing",
        "mRNA vaccine",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("zinin/patent-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "quantum computing",
    "mRNA vaccine"
  ]
}' |
apify call zinin/patent-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zinin/patent-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Patent Filing Monitor",
        "description": "Watch keywords or technologies for newly granted US patents. Bring your own free PatentsView API key — get patent id, title, grant date, assignee and a direct Google Patents link for every match, sorted by most recent. Official PatentsView Search API (USPTO-backed).",
        "version": "0.1",
        "x-build-id": "keC1AMrfPVnMmVN6h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zinin~patent-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zinin-patent-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/zinin~patent-monitor/runs": {
            "post": {
                "operationId": "runs-sync-zinin-patent-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/zinin~patent-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-zinin-patent-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Queries",
                        "maxItems": 25,
                        "type": "array",
                        "description": "Tech keywords or technologies to watch (e.g. `quantum computing`, `mRNA vaccine`). One or more matching patent rows per query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sinceDays": {
                        "title": "Since (days)",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Only include patents granted within N days.",
                        "default": 365
                    },
                    "patentsviewApiKey": {
                        "title": "PatentsView API key (optional)",
                        "type": "string",
                        "description": "Optional. Leave empty to use the keyless Google Patents source (worldwide). Provide your own free PatentsView key (https://patentsview.org/query-builder) to use the official USPTO-backed source (US patents, more results/query). Sent only in the X-Api-Key header — never logged or stored."
                    },
                    "limit": {
                        "title": "Limit per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many patents to fetch per query, most recently granted first.",
                        "default": 20
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many queries to process in parallel.",
                        "default": 3
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
