# USPTO Patent Search & Changes Feed (`thoob/uspto-patent-feed`) Actor

Clean, flat U.S. patent records from the official USPTO Open Data Portal API. Filter by keyword, CPC class, inventor, assignee, type, status, and grant-date window, with a what-changed-since-last-run mode. Billed only per delivered patent. No API key needed.

- **URL**: https://apify.com/thoob/uspto-patent-feed.md
- **Developed by:** [Pono Data](https://apify.com/thoob) (community)
- **Categories:** Developer tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 patent records

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

## USPTO Patent Search & Changes Feed

Clean, flat U.S. patent records from the official USPTO Open Data Portal API. Filter by keyword, CPC class, inventor, assignee, application type, status, and grant-date window, get one useful row per patent, and run a changes-only mode that returns just what is new, newly granted, status-changed, or updated since your last run.

You pay only for a delivered patent record. Filtered-out rows, unchanged rows in changes mode, and malformed records cost nothing.

### No API key needed

The USPTO Open Data Portal API requires a key. The actor supplies one, so there is nothing to sign up for and nothing to paste. Start a run and you get rows.

If you would rather run under your own USPTO.gov account and its own rate limit, request a key at https://data.uspto.gov and paste it into the `apiKey` input; the run uses yours instead. Either way the key is stored as a secret and is never written to the dataset or the log.

The records themselves are public-domain federal records, and the key is the Office's own free access control, not a paywall.

### What a record is

One flat row per patent, pulled from the USPTO patent file-wrapper record:

- identity: `applicationNumber`, `patentNumber` (null until granted), source URL
- title and type: `title`, `applicationType` (Utility, Design, Plant, Reissue)
- status and timeline: `status`, `statusDate`, `grantDate`, `filingDate`, `publicationNumber`, `publicationDate`
- people: `firstInventor`, `inventors`, `assignee`, `applicants`
- classification: `cpcClasses` (Cooperative Patent Classification), `groupArtUnit`, `examiner`
- other: `publicationCategory`, `entityStatus` (Regular, Small, Micro)
- provenance: `sourceUrl`, `retrievedAt`, `confidence`, `jurisdiction`, `dataSource`, and in changes mode `changeType`

Every value appears verbatim in the USPTO record. Nothing is guessed.

### A note on abstracts

The USPTO search endpoint returns bibliographic front-page data, not the patent abstract or full text. So this feed carries the title, the people, the classification, and the dates, and it does not carry an abstract. The `sourceUrl` on every row links to the patent's own page, where the abstract and full text are available. We would rather link you to the real abstract than synthesize one.

### Sample output

A real record returned by the USPTO API (granted utility patent), flattened:

| patentNumber | title | applicationType | grantDate | entityStatus | sourceUrl |
|---|---|---|---|---|---|
| 12000000 | Antibody formulations | Utility | 2024-06-04 | Regular Undiscounted | patents.google.com/patent/US12000000 |

Each row also carries `applicationNumber`, `filingDate`, inventors, assignee, CPC classes, art unit, and examiner when the record provides them.

### Two modes

- **full**: every patent matching your filter.
- **changes**: only records that are new, newly granted, status-changed, or carry a newer status date since this account's last run. The state is tracked per account in a named store, so it is your timeline. The first changes run has no baseline, so it returns everything matching once, then tracks deltas from there.

### Filters

- **keyword**: free-text across the record (supports AND, OR, NOT, quotes, and `*`).
- **cpcClasses**: keep only patents in these CPC codes (for example A61K, G06N, H04L).
- **inventor**: keep only patents naming this inventor.
- **assignee**: keep only patents whose applicant or owner matches this name.
- **applicationTypes**: Utility, Design, Plant, Reissue.
- **statuses**: application status (for example Patented Case, Abandoned).
- **grantDateFrom / grantDateTo**: bound the grant-date window (YYYY-MM-DD).
- **grantedOnly**: deliver only granted patents (on by default), or include pending applications.
- **sortOrder**: newest or oldest grant date first.
- **maxRecords**: a cap on how many records a run delivers and bills. 0 means no cap; the platform spend cap is honored regardless.

Keyword, CPC, inventor, assignee, type, status, and grant date are applied by the API; granted-only is re-checked on the returned record.

### What to expect

- The USPTO holds millions of patents and applications, refreshed daily. A filter narrows that to the slice you care about.
- The raw API is public and free directly from the USPTO with a key of your own. What this actor sells is the flat, joined record, the filtering, and the per-account change feed, so you do not have to page the API, walk the nested JSON, or diff it yourself.
- The API returns up to 100 records per page and reaches the first 10,000 results of a query; narrow the filter (tighter dates, a CPC class, an assignee) to reach deeper.
- A focused watch is a few dollars; a daily changes feed is pennies a run.

### Source and scope

- Source: the official USPTO Open Data Portal Patent File Wrapper search API (`api.uspto.gov`), the successor to the retired PatentsView API. Public-domain U.S. federal records, accessed with a declared identifying User-Agent and a USPTO API key.
- Scope: United States patent records. Each row is stamped `jurisdiction=US` and `dataSource=USPTO Open Data Portal`.
- This is a data tool, not legal advice. A patent record is a public filing, not a freedom-to-operate opinion.

### See also

More clean, pay-only-for-results data tools from Pono Data:

- [Clinical Trials Feed](https://apify.com/thoob/clinical-trials-feed) - studies, sponsors, and changes from ClinicalTrials.gov
- [Federal Spending Feed](https://apify.com/thoob/federal-spending-feed) - federal awards from USAspending.gov

Full catalog: https://apify.com/thoob

# Actor input Schema

## `apiKey` (type: `string`):

Optional. The actor supplies a working key, so you can leave this blank. Pass your own to run against your own quota. Stored as a secret; never written to the dataset or logs.

## `keyword` (type: `string`):

Free-text search across the patent record (title and other indexed fields). Leave empty to match any. Supports AND, OR, NOT, quotes for a phrase, and \* for a wildcard.

## `cpcClasses` (type: `array`):

Keep only patents in these Cooperative Patent Classification codes (for example A61K, G06N, H04L). Combined into the query. Leave empty for any class.

## `inventor` (type: `string`):

Optional. Keep only patents naming this inventor (matched against the inventor name on the record).

## `assignee` (type: `string`):

Optional. Keep only patents whose applicant or owner matches this name (for example IBM, Genentech).

## `applicationTypes` (type: `array`):

Filter to these application types (for example Utility, Design, Plant, Reissue). Exact match on the record. Leave empty for any type.

## `statuses` (type: `array`):

Filter to these application statuses (for example Patented Case, Abandoned). Exact match on the record. Leave empty for any status.

## `grantDateFrom` (type: `string`):

Optional. Keep only patents granted on or after this date (YYYY-MM-DD). Pair with the to date to bound a window.

## `grantDateTo` (type: `string`):

Optional. Keep only patents granted on or before this date (YYYY-MM-DD).

## `grantedOnly` (type: `boolean`):

When on, deliver only records with a granted patent number (skip pending applications). When off, published-but-not-yet-granted applications are delivered too, with a null patent number.

## `sortOrder` (type: `string`):

Order results by grant date. Newest first is the default.

## `mode` (type: `string`):

full returns every patent matching your filter. changes returns only records that are new, newly granted, status-changed, or updated since this account's last run, tracked per account. The first changes run has no baseline, so it returns everything matching once, then tracks deltas.

## `maxRecords` (type: `integer`):

Safety cap on how many patents this run delivers and bills. Defaults to 1000 so a first run stays quick and cheap; raise it for a full pull, or set 0 for no cap. In changes mode, records beyond the cap are not dropped: they are delivered on a later run, never billed twice. The platform spend cap (ACTOR\_MAX\_TOTAL\_CHARGE\_USD) is honored regardless.

## `pageSize` (type: `integer`):

How many records to request per API page (1 to 100). Larger pages are fewer requests; the default is the API maximum.

## Actor input object example

```json
{
  "cpcClasses": [],
  "applicationTypes": [],
  "statuses": [],
  "grantedOnly": true,
  "sortOrder": "newest",
  "mode": "full",
  "maxRecords": 1000,
  "pageSize": 100
}
```

# Actor output Schema

## `patents` (type: `string`):

One row per patent matching your filter.

# 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 = {
    "cpcClasses": [],
    "applicationTypes": [],
    "statuses": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("thoob/uspto-patent-feed").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 = {
    "cpcClasses": [],
    "applicationTypes": [],
    "statuses": [],
}

# Run the Actor and wait for it to finish
run = client.actor("thoob/uspto-patent-feed").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 '{
  "cpcClasses": [],
  "applicationTypes": [],
  "statuses": []
}' |
apify call thoob/uspto-patent-feed --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/l1NFG5VJgKNcI8aoZ/builds/k9xsgYZoPgy6rbMyh/openapi.json