# USPTO Scraper \[$5/1K💰] | US Patents | Prior Art Search (`ahmed_jasarevic/uspto-scraper`) Actor

Search USPTO patents and published applications by keyword, inventor, assignee or field code — keyless. Get titles, dates, classifications, family IDs and optional abstract and claims text. Built for prior-art research, patent landscapes and competitor monitoring. $5 per 1,000 patents.

- **URL**: https://apify.com/ahmed_jasarevic/uspto-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.85 / 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

## USPTO Patent Scraper

Search USPTO patents and published applications by keyword, inventor, assignee or field-coded query — without a login or API key — and get structured patent records with dates, parties, classifications and family IDs, plus optional abstract, claims and description text.

**Built for:**

- Patent landscape and prior-art research
- Competitor and technology monitoring by assignee or keyword
- Building patent databases for analytics, search or ML
- Tracking newly published applications and grants in a technology area
- Enriching R\&D and legal workflows with structured patent metadata

### Search US Patents & Prior Art Without an API Key

The actor queries three USPTO collections in one run — granted patents (`USPAT`), published applications (`US-PGPUB`) and OCR patents (`USOCR`) — using the same fast JSON interface as the official Patent Public Search web app. Queries accept plain keywords and USPTO field codes (`7557042.pn.`, `microsoft.as.`, `black.in.`, `lithium battery AND @pd>=20240101`). Each result row carries the patent number and GUID, title, database, kind code, publication/filing/priority dates, application number, assignee, applicants, inventors, CPC/IPC/USPC classifications and the USPTO family ID. With details enabled, the actor also fetches the full document record: abstract, claims and/or description as plain text, examiner and attorney names, government-interest statement, priority country and claim counts. Results page through up to 20,000 documents per query — the Patent Public Search limit.

### How It Works

![How the USPTO Scraper works: patent queries become rows with numbers, assignees, CPC classes, abstracts, claims and USPTO links.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-uspto-scraper)

The Actor sends each query to the same internal JSON endpoint used by Patent Public Search, 500 results per request. With details enabled it fetches the full document and selected text sections; request starts are serialized and HTTP 429 responses trigger a global cooldown.

Each row covers one patent document with number, title, database, dates, assignee, inventors, CPC and IPC classes, and optional abstract, claims and description.

1. The search runs in batches of 500 results per request against the same internal JSON endpoint the official Patent Public Search application calls.
2. Each result row is pushed according to your `pushMode` (`incremental`, `page` or `end`), so you can watch results appear or collect them in bulk.
3. If `fetchDetails` is enabled, one extra request per patent retrieves the full document record and selected text sections.
4. Request starts are serialized with a configurable minimum delay (default 200 ms), network errors and 5xx responses are retried, and the USPTO session is rotated automatically; on HTTP 429 the actor applies a global cooldown.
5. A 100-patent run takes roughly 30–40 seconds with details enabled; with `fetchDetails: false` only one request per 500 results is needed.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `searchQuery` | string | Yes | — | USPTO Patent Public Search query. Plain keywords or field suffixes: `litium battery`, `7557042.pn.`, `microsoft.as.`, `lithium battery AND @pd>=20240101`. |
| `maxItems` | integer | No | `100` | Patents written to the dataset (1–20,000; Patent Public Search caps any query at 20,000). |
| `sort` | enum | No | `newest` | `newest`, `oldest` or `relevance`. |
| `databases` | array | No | all three | `US-PGPUB` (published applications), `USPAT` (granted patents), `USOCR` (OCR patents). |
| `defaultOperator` | enum | No | `OR` | How words combine when no explicit operator: `OR` (broader) or `AND` (all words). |
| `fetchDetails` | boolean | No | `true` | Fetch the full document record per patent — adds inventors, examiners, attorney and selected text sections; one extra request (and one detail charge) per successfully fetched document. |
| `pushMode` | enum | No | `incremental` | `incremental` (row by row), `page` (per 500-result page), `end` (single batch at the end; more memory). |
| `textSections` | array | No | `["abstract"]` | Which text sections to include when details are fetched: `abstract`, `claims`, `description` (description can be very large). |
| `concurrency` | integer | No | `8` | Parallel detail requests (1–20); the minimum request delay is still enforced. |
| `requestDelayMs` | integer | No | `200` | Minimum delay between USPTO request starts, 100–10,000 ms. The default is tuned for reliable detail runs. |

### Output Fields

One dataset item per patent document — 34 fields:

- **Identity:** `guid`, `patentNumber`, `documentId`, `title`, `database`, `documentType`, `kindCode`, `applicationNumber`, `familyId`, `detailsFetched`
- **Dates:** `publicationDate`, `filingDate`, `priorityDate`, `priorityCountryCode`\*
- **Parties:** `assignee`, `assigneeCity`*, `assigneeState`*, `assigneeCountry`*, `applicants`, `inventors`*, `inventorsShort`, `primaryExaminer`*, `assistantExaminer`*, `attorneyName`\*
- **Classifications:** `cpcCodes`, `cpcAdditionalCodes`, `ipcCodes`, `uspcCodes`
- **Text (when the section is selected):** `abstract`, `claims`, `description`
- **Other:** `governmentInterest`*, `numberOfClaims`*, `exemplaryClaimNumber`\*

\* Requires `fetchDetails: true`.

### Example Input

```json
{
  "searchQuery": "lithium battery AND @pd>=20240101",
  "maxItems": 100,
  "sort": "newest",
  "databases": ["US-PGPUB", "USPAT"],
  "fetchDetails": true,
  "textSections": ["abstract"],
  "concurrency": 8,
  "requestDelayMs": 200
}
```

Fast metadata-only variant:

```json
{ "searchQuery": "solid state battery", "maxItems": 1000, "fetchDetails": false, "pushMode": "page" }
```

### Example Output

```json
{
  "guid": "US-20260316516-A1",
  "patentNumber": "20260316516",
  "documentId": "US 20260316516 A1",
  "title": "Solid-State Battery Cell With Ceramic Separator",
  "database": "US-PGPUB",
  "documentType": "Utility Patent Application",
  "kindCode": "A1",
  "publicationDate": "2026-10-15",
  "filingDate": "2025-04-11",
  "priorityDate": "2024-04-12",
  "applicationNumber": "18/634,210",
  "assignee": "Example Energy Corp.",
  "applicants": ["Example Energy Corp."],
  "inventors": ["Jane Q. Example"],
  "cpcCodes": ["H01M 50/403", "H01M 10/0562"],
  "familyId": 81234567,
  "abstract": "A solid-state battery cell includes a ceramic separator ...",
  "numberOfClaims": 18,
  "detailsFetched": true
}
```

### Automate Patent Monitoring With Schedules & Webhooks

- **Weekly new-publications feed:** schedule a query such as `microsoft.as. AND @pd>=20260101` (adjust the date each run) and keep rows whose `patentNumber` has not appeared before — a lightweight new-patent alert system.
- **Competitor tracking:** one scheduled run per assignee, with a dataset webhook pushing matches to Slack, email or your warehouse.
- **Landscape snapshots:** run broad keyword searches monthly with `fetchDetails: false` and `pushMode: "page"` for cheap, fast classification data (`cpcCodes`) to chart technology trends.
- Scheduled runs are the intended pattern and improve this actor's Store recommendation signals.

### Related Actors

- [Google Patents Scraper — Search, Citations, Family Graph](https://apify.com/khadinakbar/google-patents-scraper) — the most-used patent actor on the Store, useful for citation and family-graph views.
- [Google Patents Scraper — Search, Citations, Family Graph](https://apify.com/memo23/google-patents-scraper) — same coverage from a different developer, a solid cross-check.
- [Google Patents Scraper](https://apify.com/sbkapelner/google-patents-scraper) — lighter Google Patents alternative.
- [USPTO Patent Search Scraper — No Login](https://apify.com/fortuitous_pirate/uspto-scraper) — direct USPTO-side extraction with a different field set.
- [USPTO Patent Scraper](https://apify.com/devilscrapes/uspto-patents-scraper) — another USPTO-focused option for redundancy.

### Frequently Asked Questions

#### Why use this actor instead of the official API?

USPTO's Open Data Portal (data.uspto.gov) does offer official APIs, but access has become heavyweight: since June 18, 2026 you need a signed-in USPTO.gov account with multi-factor authentication, and API keys for accounts missing the required profile fields were deactivated on October 8, 2026. The PatentsView APIs have been interrupted since their March 20, 2026 migration with no published relaunch date. This actor sidesteps all of that: it uses the same JSON interface as the official Patent Public Search web app, needs no account, key or registration, and returns structured metadata with optional abstract/claims/description — with keyless access being the point.

#### Is there a USPTO API?

Yes — the Open Data Portal provides patent search and bulk dataset APIs, but they require a USPTO.gov account, MFA and an API key. PatentsView's legacy APIs are in transition (interrupted since March 20, 2026, relaunch unannounced). Third-party PatentsView-compatible gateways also exist (e.g. patentgrep). This actor offers the keyless route through the public search interface the official web app itself uses.

#### How can I search patents without an API key?

Run this actor with a query — that is all that is required. It talks to the same public endpoint the official Patent Public Search application uses, rotates its session, and paces requests so large detail runs stay under USPTO's HTTP 429 limit.

#### What are the alternatives to this data source?

- **USPTO Open Data Portal** — official APIs and bulk datasets, with account/MFA/key requirements.
- **Google Patents** — broad coverage (actors linked above) including citations and family graphs.
- **PatentsView-compatible gateways** — third-party services that mirror PatentsView's API shape.
- **Espacenet / EPO** — international coverage beyond US documents.

#### Can I get patent abstracts, claims and full descriptions?

Yes — keep `fetchDetails: true` and pick sections in `textSections` (`abstract`, `claims`, `description`). The description section can be very large, so it is excluded by default; each successfully fetched detail adds one extra request and, with pay-per-event pricing, one detail charge.

#### Does it require a USPTO login?

Not currently — the actor uses the anonymous session endpoint of Patent Public Search. USPTO has announced a sign-in requirement for the Patent Public Search web app from November 7, 2026 (per the actor's documentation); if the anonymous endpoint begins returning 401, the actor reports a clear error instead of failing silently.

### For AI Agents & LLM Apps

**Purpose:** returns USPTO patent records (identity, dates, parties, classifications, family ID) with optional abstract/claims/description text for a given search query — keyless.

**Minimal input:**

```json
{ "searchQuery": "lithium battery", "maxItems": 5 }
```

**Metadata-only (fast/cheap) variant:**

```json
{ "searchQuery": "microsoft.as.", "maxItems": 100, "fetchDetails": false }
```

**Output fields:** guid, patentNumber, documentId, title, database, documentType, kindCode, publicationDate, filingDate, priorityDate, priorityCountryCode, applicationNumber, assignee, assigneeCity, assigneeState, assigneeCountry, applicants, inventors, inventorsShort, cpcCodes, cpcAdditionalCodes, ipcCodes, uspcCodes, familyId, abstract, claims, description, primaryExaminer, assistantExaminer, attorneyName, governmentInterest, numberOfClaims, exemplaryClaimNumber, detailsFetched.

**Behaviors an agent should know:**

- `searchQuery` is the only required input; `maxItems` defaults to 100 and can never exceed 20,000 (Patent Public Search's per-query ceiling).
- `fetchDetails` defaults to `true` — each detail adds one request and a `Patent detail` charge; set it to `false` for metadata-only runs at one request per 500 results.
- Detail-only fields (inventors, examiners, attorney, text sections, city/state/country) are populated only when `fetchDetails` is on; check `detailsFetched` to confirm.
- `pushMode: "end"` buffers everything in memory — prefer `incremental` or `page` for large runs.
- Rate limiting is built in: serialized request starts with a 200 ms default delay, automatic session rotation and a global cooldown on HTTP 429. Lower `requestDelayMs` only if you accept 429 risk.

**Billing:** pay-per-event — `Patent` at $0.005 per patent result and `Patent detail` at $0.001 per successfully fetched document, plus a run-start event.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the United States Patent and Trademark Office (USPTO). It queries only USPTO's public Patent Public Search interface — no account credentials are used — and paces requests to stay under USPTO's rate limits. Patent documents and bibliographic data are public records; users are responsible for their own compliance with USPTO's terms of use and applicable law when storing, republishing or automating access to the data. This actor is a data tool, not legal advice.

### SEO Keywords

uspto scraper, uspto patent scraper, patent scraper, patent search api, uspto api, patentsview alternative, prior art search, patent data api, google patents alternative, patent database, us patent search, patent full text, patent abstract data, patent classification data, cpc codes, patent landscape analysis, freedom to operate data, patent monitoring, newly published patents, patent research tool

# Actor input Schema

## `searchQuery` (type: `string`):

USPTO Patent Public Search query. Plain keywords work, and field suffixes are supported too, for example: "lithium battery", "7557042.pn.", "microsoft.as.", "black.in." or "lithium battery AND @pd>=20240101".

## `maxItems` (type: `integer`):

Maximum number of patents to write to the dataset. USPTO Patent Public Search allows at most 20,000 results per query.

## `sort` (type: `string`):

Order of the results.

## `databases` (type: `array`):

USPTO collections to search. By default all three are used: granted patents, published applications and OCR patents.

## `defaultOperator` (type: `string`):

How multiple words in the query are combined when no explicit operator is used.

## `fetchDetails` (type: `boolean`):

Fetch the full document record for every patent. This adds inventors, examiners, attorney and selected text sections (abstract/claims/description). It costs one extra request per patent and, when pay-per-event pricing is enabled, one patent-detail charge per successfully fetched document. Disable it for maximum speed.

## `pushMode` (type: `string`):

How results are written to the dataset. Incremental shows each patent as soon as it is ready. Page writes one batch per 500-result page. End collects everything and writes one batch at the end (uses more memory, so prefer it for smaller runs).

## `textSections` (type: `array`):

Text sections to include when Fetch patent details is enabled. Abstract is recommended. Description can be very large.

## `concurrency` (type: `integer`):

Number of patent detail requests that may run in parallel. The Actor also enforces the minimum delay between requests and rotates the USPTO session automatically.

## `requestDelayMs` (type: `integer`):

Minimum delay between USPTO API request starts. Lower values are faster but increase the risk of HTTP 429. The default 200 ms is tuned for reliable detail runs.

## Actor input object example

```json
{
  "searchQuery": "lithium battery",
  "maxItems": 100,
  "sort": "newest",
  "databases": [
    "US-PGPUB",
    "USPAT",
    "USOCR"
  ],
  "defaultOperator": "OR",
  "fetchDetails": true,
  "pushMode": "incremental",
  "textSections": [
    "abstract"
  ],
  "concurrency": 8,
  "requestDelayMs": 200
}
```

# Actor output Schema

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

One dataset item per patent or published application, with optional full document details.

# 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 = {
    "searchQuery": "lithium battery"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/uspto-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 = { "searchQuery": "lithium battery" }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/uspto-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 '{
  "searchQuery": "lithium battery"
}' |
apify call ahmed_jasarevic/uspto-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/uspto-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/1ryExbqMGWOrh0CcI/builds/iroUAI0ozfVxS4ASu/openapi.json