# USPTO Patents Scraper (`parseforge/uspto-patents-scraper`) Actor

Scrapes patent records from USPTO and other offices by search term, assignee, inventor, country, and date range. Returns each patent as a flat row with title, abstract, assignee, inventor, publication date, and country code.

- **URL**: https://apify.com/parseforge/uspto-patents-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Lead generation
- **Features:** Limited permissions
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### USPTO Patents Scraper

**Scrape USPTO patents by keyword, assignee, inventor, or date range, up to a million per run.** Each patent comes with its title, abstract, assignee, inventor, publication date, and country code. No API key or registration. Export to CSV, JSON, Excel, or XML.

USPTO's official search API needs an API key, rate-limits you, and returns nested XML that is painful to parse. This reads the public patent search directly, filtered by query, assignee, inventor, country, and publication date, and returns each match in one flat row. You can pull US, EP, WO, CN, JP, KR, DE, FR, GB, CA, AU, and IN patents from a single run.

| Who uses it | What they scrape USPTO for |
|---|---|
| Patent analysts | Which companies are filing in a technology area this quarter |
| IP lawyers | Prior art searches for a specific assignee or inventor |
| Market researchers | Patent filing trends by country and date range |
| Startup founders | Competitive patent landscape before building a product |

### What it does

This Actor collects patent records from the USPTO and other patent offices by search term, assignee, inventor, country, and date range, and returns each one as a flat row.

- 🔍 **Keyword search:** free-text query matches title and abstract, e.g. "battery" or "lithium ion".
- 🏢 **Assignee filter:** narrow to a company like "Apple Inc." or "Tesla".
- 👤 **Inventor filter:** find patents by a specific inventor name.
- 🌍 **Country code:** restrict to US, EP, WO, CN, JP, KR, DE, FR, GB, CA, AU, or IN.
- 📅 **Date range:** set publication after and before dates to limit results.
- 🔢 **Max items:** cap the number of patents per run, up to 1,000,000.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with USPTO data

**📈 Track patent filing trends.**

A market researcher runs the Actor with a keyword like "solid state battery" and a date range to see which companies are filing and when.

**🔎 Prior art search.**

An IP lawyer filters by assignee and inventor to find existing patents that could block a client's application.

**🏢 Competitive intelligence.**

A startup founder scrapes all patents assigned to a competitor to understand their technology roadmap.

**🌍 Global landscape.**

A patent analyst sets country to WO or EP to see international filings for a technology area.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key** | No registration or OAuth, run the Actor |
| **Flat rows** | Each patent is one row, ready for CSV or Excel |
| **Multi-office** | US, EP, WO, CN, JP, KR, DE, FR, GB, CA, AU, IN |
| **Scalable** | Up to 1,000,000 patents per run |

### How it compares

This Actor focuses on basic bibliographic patent data from the USPTO search, while the competitors below offer richer data like claims and citations from Google Patents.

| Feature | ParseForge | Google Patents API | Google Patents Intelligence |
|---|---|---|---|
| Search by keyword | Yes | Yes | Yes |
| Filter by assignee | Yes | Yes | Yes |
| Filter by inventor | Yes | Yes | Yes |
| Filter by country code | Yes | Not listed | Not listed |
| Filter by publication date | Yes | Not listed | Not listed |
| Patent claims | Not listed | Yes | Not listed |
| Patent citations | Not listed | Yes | Yes |
| AI patent summaries | Not listed | Yes | Not listed |

### Configure the run

Drive the Actor from a search term, assignee, inventor, country code, and publication date range, alone or together, and filters run as each patent is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10,
 "query": "battery"
}
```

A larger pull:

```json
{
 "maxItems": 200,
 "query": "battery"
}
```

### Pricing

Pay-per-result: **$0.021 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [USPTO Patents Scraper](https://apify.com/parseforge/uspto-patents-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to USPTO through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/uspto-patents-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Your query or filters may be too narrow. Try a broader keyword, remove the assignee or inventor filter, or widen the date range. Also check the country code: if set to US, it will only return US patents.

**Why are results from other countries showing up?**

The country input defaults to US. If you want all countries, set it to Any (empty string). If you want a specific country, select it from the dropdown.

**Why is the run slow?**

Large maxItems values or broad queries can take time. Reduce maxItems or narrow your filters. The Actor processes patents one by one, so a million patents will take a while.

**Why are some fields empty?**

Not all patents have every field. For example, some may lack an assignee or inventor. That is normal and reflects the source data.

**Can I get patent claims or citations?**

No. This Actor returns only the basic bibliographic data. For claims, citations, or family graphs, use a different scraper like Google Patents API.

### FAQ

| Question | Answer |
|---|---|
| Do I need a USPTO API key? | No. This Actor reads the public patent search directly, so no API key or registration is required. |
| Which patent offices does it cover? | It can return patents from US, EP, WO, CN, JP, KR, DE, FR, GB, CA, AU, and IN. Set the country code input to filter. |
| What data do I get for each patent? | Each row includes the patent title, abstract, assignee, inventor, publication date, and country code. The exact fields are shown in the sample record. |
| Can I search by assignee or inventor? | Yes. Use the assignee and inventor inputs to filter results. You can combine them with a keyword query and date range. |
| How many patents can I scrape in one run? | Up to 1,000,000. Set the maxItems input to control the number. |
| What formats can I export to? | CSV, JSON, Excel, and XML. Choose the format when you run the Actor. |
| Does it include patent claims or citations? | No. This Actor returns the basic bibliographic data: title, abstract, assignee, inventor, publication date, and country code. For claims and citations, consider a different scraper. |
| Can I filter by publication date? | Yes. Use the after and before inputs with YYYY-MM-DD dates to set a range. |
| Is this the same as Google Patents? | No. This Actor reads the USPTO search directly. Google Patents is a separate source with different coverage and data. |
| What if I get no results? | Check your query and filters. Try a broader keyword or remove the assignee/inventor filter. See the troubleshooting section for more tips. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by United States Patent and Trademark Office. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

How many patents to collect per run.

## `query` (type: `string`):

Free-text query (matches title and abstract). Example: "battery" or "lithium ion".

## `country` (type: `string`):

Patent office country code (US, EP, WO, CN, JP, KR, DE, FR, GB).

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

Filter by assignee name (e.g. "Apple Inc.")

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

Filter by inventor name.

## `after` (type: `string`):

Earliest publication date YYYY-MM-DD.

## `before` (type: `string`):

Latest publication date YYYY-MM-DD.

## Actor input object example

```json
{
  "maxItems": 10,
  "query": "battery",
  "country": "US"
}
```

# 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 = {
    "maxItems": 10,
    "query": "battery"
};

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

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

```

## MCP server setup

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