# USPTO Patent Assignments Scraper (`parseforge/uspto-patent-assignments-scraper`) Actor

Export patent ownership records from the USPTO Patent Assignment Search. Pull assignor, assignee, conveyance type, properties affected, execution dates, and recorded reel/frame entries. Search by patent number, application number, assignee, or assignor name.

- **URL**: https://apify.com/parseforge/uspto-patent-assignments-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## ⚖️ USPTO Patent Assignments Scraper

> 🚀 **Export patent ownership records from the USPTO Assignment Center in seconds.** Search by assignee, assignor, patent number, application number, publication number, PCT number, or reel/frame reference and download the full chain-of-title history as CSV, Excel, JSON, or XML.

> 🕒 **Last updated:** 2026-05-21 · **📊 19 fields** per record · Millions of assignments · Full USPTO coverage since 1980

The USPTO Patent Assignments Scraper pulls ownership transfer records directly from the **USPTO Assignment Center** (`assignmentcenter.uspto.gov`), the official replacement for the retired Assignment Search portal. Every assignment record includes assignor names, assignee names, conveyance type, patent and application numbers, invention titles, filing and issue dates, reel/frame reference, correspondent details, and the execution and recordation dates - everything needed to reconstruct the chain of title for any U.S. patent.

The dataset covers more than 40 years of assignment activity - millions of records from individual inventors transferring rights to corporations, through mergers and acquisitions, security agreements, government licenses, and more. All data is scraped in real time directly from the official USPTO source, never from a cached mirror.

**Target Audience / Use Cases**

| Who | Why |
|---|---|
| IP attorneys & paralegals | Verify chain of title, draft assignment agreements, due diligence |
| Competitive intelligence teams | Track technology acquisitions and patent portfolio movements |
| Investors & M&A analysts | Identify patent-rich acquisition targets, map IP ownership changes |
| Academic researchers | Study patent market dynamics, technology transfer trends |
| Journalists & journalists | Investigate IP deals and corporate patent strategies |
| Patent licensing professionals | Find current patent owners for licensing negotiations |

---

### 📋 What the USPTO Patent Assignments Scraper does

- **Searches** the USPTO Assignment Center by assignee name, assignor name, patent number, application number, publication number, PCT number, or reel/frame number
- **Paginates** automatically through all result pages until `maxItems` is reached
- **Extracts** all 19 fields per assignment record including full assignee/assignor arrays, all associated patent numbers, invention titles, filing dates, and correspondent details
- **Exports** to CSV, Excel, JSON, or XML via the Apify dataset
- **Supports** partial (contains) and exact match modes for name-based searches
- **Filters** by date range (recorded date from/to) to narrow results

> 💡 **Why it matters:** Patent ownership determines who can license, enforce, or sell a technology. A single acquisition can transfer thousands of patents at once. Having a programmatic way to query this data - without navigating the web UI manually - saves hours of research per case.

---

### 🎬 Full Demo

_🚧 Coming soon_

---

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Default</th><th>Description</th></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>10</td><td>Maximum number of records to return. Free users are capped at 10.</td></tr>
<tr><td><code>searchField</code></td><td>select</td><td>assigneeName</td><td>Which field to search: assigneeName, assignorName, patentNumber, applicationNumber, publicationNumber, pctNumber, or reelFrame.</td></tr>
<tr><td><code>searchQuery</code></td><td>string</td><td>Apple</td><td>The value to search for. Use a company or person name for assignee/assignor. Use a number for patent/application. Use format <code>28725/607</code> for reel/frame.</td></tr>
<tr><td><code>matchType</code></td><td>select</td><td>Contains</td><td>Whether to use a partial (contains) or exact match. Applies to name-based searches.</td></tr>
<tr><td><code>dateFrom</code></td><td>string</td><td></td><td>Optional. Limit to assignments recorded on or after this date (MM/DD/YYYY).</td></tr>
<tr><td><code>dateTo</code></td><td>string</td><td></td><td>Optional. Limit to assignments recorded on or before this date (MM/DD/YYYY).</td></tr>
</table>

**Example 1 - Search by assignee name (partial match):**
```json
{
    "maxItems": 100,
    "searchField": "assigneeName",
    "searchQuery": "Qualcomm",
    "matchType": "Contains"
}
````

**Example 2 - Look up a specific patent number:**

```json
{
    "maxItems": 10,
    "searchField": "patentNumber",
    "searchQuery": "10000000"
}
```

> ⚠️ **Good to Know:** The `reelFrame` search expects the format `REEL/FRAME` (e.g. `028725/607`). Date filters use MM/DD/YYYY format (e.g. `01/01/2020`). Free users are limited to 10 records per run regardless of `maxItems`.

***

### 📊 Output

Each record contains up to 19 fields:

| Field | Type | Description |
|---|---|---|
| 🗂️ `reelFrame` | string | Reel/frame identifier (e.g. `028725/0607`) |
| 📋 `conveyanceText` | string | Type of transfer (e.g. `ASSIGNMENT OF ASSIGNOR'S INTEREST`) |
| 📅 `recordedDate` | string | Date the assignment was recorded at USPTO |
| 📅 `executionDate` | string | Date the assignment document was executed |
| 🏢 `assignees` | array | List of assignee names (new patent owners) |
| 👤 `assignors` | array | List of assignors with names and execution dates |
| 🔢 `patentNumbers` | array | Patent numbers covered by this assignment |
| 📝 `applicationNumbers` | array | Application numbers covered |
| 📄 `publicationNumbers` | array | Pre-grant publication numbers |
| 💡 `inventionTitles` | array | Titles of the inventions being assigned |
| 📅 `filingDates` | array | Filing dates of the applications |
| 📅 `issueDates` | array | Issue dates of the patents |
| 🧑‍🔬 `inventors` | string | Inventor names |
| 📬 `correspondentName` | string | Name of the filing correspondent |
| 📍 `correspondentAddress` | string | Address of the correspondent |
| 📁 `attorneyDocketNumber` | string | Attorney docket number |
| 🔢 `noOfProperties` | integer | Number of patents/applications in the assignment |
| 🔗 `sourceUrl` | string | Link to the record on USPTO Assignment Center |
| 🕒 `scrapedAt` | string | ISO 8601 timestamp when the record was collected |

**Sample records:**

```json
[
  {
    "reelFrame": "028725/0607",
    "conveyanceText": "ASSIGNMENT OF ASSIGNOR'S INTEREST",
    "recordedDate": "05/11/2012",
    "executionDate": "05/11/2012",
    "assignees": ["APPLE"],
    "assignors": [{"name": "ROCKSTAR BIDCO, LP", "executionDate": "05/11/2012"}],
    "patentNumbers": ["7110785"],
    "applicationNumbers": ["09696491"],
    "publicationNumbers": [],
    "inventionTitles": ["PERFORMING POWER CONTROL IN A MOBILE COMMUNICATIONS SYSTEM"],
    "filingDates": ["10/25/2000"],
    "issueDates": ["09/19/2006"],
    "inventors": "David Paranchych W., Yiping Wang, Ashvin Chheda H.",
    "correspondentName": "MEYERTONS HOOD KIVLIN KOWERT & GOETZEL",
    "correspondentAddress": null,
    "attorneyDocketNumber": null,
    "noOfProperties": 1,
    "sourceUrl": "https://assignmentcenter.uspto.gov/search/patent?reelNumber=28725&frameNumber=607",
    "scrapedAt": "2026-05-21T17:05:13.660Z"
  },
  {
    "reelFrame": "028667/0677",
    "conveyanceText": "ASSIGNMENT OF ASSIGNOR'S INTEREST",
    "recordedDate": "05/11/2012",
    "executionDate": "05/11/2012",
    "assignees": ["APPLE"],
    "assignors": [{"name": "ROCKSTAR BIDCO, LP", "executionDate": "05/11/2012"}],
    "patentNumbers": ["5826181"],
    "applicationNumbers": ["08731035"],
    "publicationNumbers": [],
    "inventionTitles": ["RADIO FREQUENCY NOISE REDUCTION ARRANGEMENT"],
    "filingDates": ["10/10/1996"],
    "issueDates": ["10/20/1998"],
    "inventors": "CHRISTOPHER REED J.",
    "correspondentName": "MEYERTONS HOOD KIVLIN KOWERT & GOETZEL",
    "correspondentAddress": null,
    "attorneyDocketNumber": null,
    "noOfProperties": 1,
    "sourceUrl": "https://assignmentcenter.uspto.gov/search/patent?reelNumber=28667&frameNumber=677",
    "scrapedAt": "2026-05-21T17:05:13.661Z"
  },
  {
    "reelFrame": "028750/0088",
    "conveyanceText": "ASSIGNMENT OF ASSIGNOR'S INTEREST",
    "recordedDate": "05/11/2012",
    "executionDate": "05/11/2012",
    "assignees": ["APPLE"],
    "assignors": [{"name": "ROCKSTAR BIDCO, LP", "executionDate": "05/11/2012"}],
    "patentNumbers": ["7180871"],
    "applicationNumbers": ["10173093"],
    "publicationNumbers": [],
    "inventionTitles": ["ROUND TRIP TIMEOUT ADJUSTMENT IN A CELLULAR WIRELESS COMMUNICATION SYSTEM"],
    "filingDates": ["06/15/2002"],
    "issueDates": ["02/20/2007"],
    "inventors": "Farid Khafizov T., Mehmet Yavuz, Nanping Ding",
    "correspondentName": "MEYERTONS HOOD KIVLIN KOWERT & GOETZEL",
    "correspondentAddress": null,
    "attorneyDocketNumber": null,
    "noOfProperties": 1,
    "sourceUrl": "https://assignmentcenter.uspto.gov/search/patent?reelNumber=28750&frameNumber=88",
    "scrapedAt": "2026-05-21T17:05:13.661Z"
  }
]
```

***

### ✨ Why choose this Actor

- 🔄 **Real-time data** - scraped live from the official USPTO Assignment Center on every run
- 🆕 **New API** - uses the `assignmentcenter.uspto.gov` endpoint that replaced the retired legacy assignment API in September 2025
- 🔍 **7 search modes** - find records by assignee, assignor, patent number, application, publication, PCT, or reel/frame
- 📑 **19 fields per record** - full chain-of-title details including all parties, dates, docket numbers, and source links
- 📦 **Batch export** - download CSV, Excel, JSON, or XML directly from the Apify dataset
- 💰 **Pay-per-result** - you only pay for items actually collected
- 🚫 **No login required** - all data is public and accessible without a USPTO account

***

### 📈 How it compares to alternatives

| Feature | This Actor | Manual USPTO UI | Legacy Assignment API | PatentsView |
|---|---|---|---|---|
| Data source | Assignment Center (live) | Assignment Center (live) | Retired (2025) | Historical bulk only |
| Programmatic access | Yes | No | Retired | Deprecated |
| Search by assignee | Yes | Yes | Yes | Limited |
| Search by patent ## | Yes | Yes | Yes | Yes |
| Bulk export (CSV/JSON) | Yes | 1 page at a time | Yes | Bulk download only |
| Pagination | Automatic | Manual | Manual | N/A |
| Pay-per-result pricing | Yes | Free | Free | Free |

***

### 🚀 How to use

1. **Create a free account** at [Apify](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 in free credit)
2. Open the **USPTO Patent Assignments Scraper** actor page and click **Try for free**
3. Choose your **search field** (e.g. Assignee Name) and enter your **search query** (e.g. `Tesla`)
4. Optionally set **maxItems** and a **date range**
5. Click **Start** and wait for the run to finish (typically seconds to minutes)
6. Download your dataset as **CSV, Excel, JSON, or XML**

***

### 💼 Business use cases

#### Due Diligence and M\&A

Before acquiring a company, legal and M\&A teams need to verify the company actually owns the patents it claims. This scraper lets you pull the full chain-of-title for any patent portfolio - checking every assignment from the original inventor filing through to current ownership. Gaps or undisclosed transfers can surface IP encumbrances that affect deal value.

#### Patent Portfolio Monitoring

Technology companies and law firms track competitor patent activity over time. By scheduling this actor to run weekly with a competitor's name as the assignee, you can receive automated alerts whenever a new patent assignment is recorded - surfacing acquisitions, licensing deals, and security agreements before they become public news.

#### Licensing Negotiation Support

If you want to license a technology, you need to know who currently owns the patent. The USPTO assignment database is the authoritative source. This scraper lets you quickly confirm the current owner and trace the history back to the original inventor - useful for structuring licensing negotiations and understanding the IP's commercial history.

#### Academic Research on Technology Transfer

Researchers studying how technology moves from universities to industry, from startups to large corporations, or across national boundaries can use this data to build quantitative models of patent market dynamics. The scraper's ability to filter by date range and search by any field makes it well-suited for constructing longitudinal datasets.

***

### 🔌 Automating USPTO Patent Assignments Scraper

Connect this actor to your workflow with no-code tools:

- **Make (Integromat)** - trigger a run and send new assignment records to Google Sheets, Airtable, or Slack
- **Zapier** - automate alerts when specific assignees or patent numbers appear in new assignments
- **n8n** - build IP monitoring pipelines that run on a schedule and push to your data warehouse
- **Webhooks** - get notified immediately when a run completes via Apify's built-in webhook system

***

### 🌟 Beyond business use cases

#### Independent Inventors

Individual inventors can use this scraper to research the historical ownership of patents in their technology area - identifying potential licensing partners or checking whether a company they want to approach has previously acquired similar IP.

#### Journalism and Investigative Research

Journalists covering Big Tech, pharma, or defense can use assignment records to trace how major patent portfolios were assembled. The Nortel/Rockstar transaction that transferred thousands of wireless patents to a consortium including Apple and Microsoft is fully documented in the assignment database.

#### Non-Profit and Policy Research

Policy researchers studying patent concentration, technology transfer from publicly funded research, or the impact of patent assertion entities can build comprehensive datasets from this source to support evidence-based advocacy.

#### Education

Patent assignment data is used in law school clinics and IP courses to teach students how to conduct chain-of-title searches and understand the commercial life of a patent beyond the grant.

***

### 🤖 Ask an AI assistant about this scraper

You can ask your AI assistant (ChatGPT, Claude, Gemini, etc.) questions like:

- "How do I search USPTO patent assignments for a specific company?"
- "What fields are available in USPTO assignment records?"
- "How do I track patent acquisitions for a competitor using Apify?"
- "What is a reel/frame number in USPTO assignments?"

The answers will reference this actor and the USPTO Assignment Center data.

***

### ❓ Frequently Asked Questions

**What is a patent assignment?**
A patent assignment is the legal transfer of ownership rights in a patent from one party (the assignor) to another (the assignee). Assignments must be recorded with the USPTO to be effective against third parties.

**What is the reel/frame number?**
The reel/frame is the USPTO's internal document identifier for each recorded assignment. It uniquely identifies the assignment document and can be used to retrieve the original scanned document image.

**How current is the data?**
Data is fetched live from the USPTO Assignment Center on every run. Assignments are typically visible within 1-3 business days of being recorded at the USPTO.

**Can I search for all patents assigned to a company?**
Yes. Use `searchField: assigneeName` with `matchType: Contains` and the company name as `searchQuery`. The actor paginates automatically.

**What replaced the old assignment-api.uspto.gov endpoint?**
The legacy `assignment-api.uspto.gov` API was retired in September 2025. The replacement is the USPTO Assignment Center at `assignmentcenter.uspto.gov`, which this actor uses.

**Can I filter by date range?**
Yes. Use the `dateFrom` and `dateTo` fields in MM/DD/YYYY format to limit results to assignments recorded within a specific date range.

**What is the difference between Contains and Exact match?**
Contains returns any record where the name field includes your search query as a substring. Exact requires a full-name match. Contains is recommended for company name searches; Exact is useful when you know the precise legal name.

**How many records can I retrieve per run?**
Free users are limited to 10 records. Paid users can retrieve up to 1,000,000 records per run.

**Does this require a USPTO account?**
No. The assignment search is a public service and no login is required.

**Can I search by inventor name?**
The USPTO Assignment Center does not expose a direct inventor search field. You can search by assignee or assignor name and then filter the `inventors` field in the output. For inventor-based searches, consider using the USPTO Patent Center search.

**Are security agreements and licenses included?**
Yes. The conveyanceText field captures all assignment types including security interest, license, merger, name change, and assignment of assignor's interest.

**Can I get the PDF document for a specific assignment?**
Each record includes a `sourceUrl` linking to the Assignment Center page for that reel/frame. The original scanned document image is accessible from there.

***

### 🔌 Integrate with any app

Connect your dataset to 1,500+ apps via Apify integrations:

**Analytics:** Google Sheets, Airtable, Microsoft Excel, Tableau, Power BI
**Databases:** PostgreSQL, MySQL, MongoDB, BigQuery, Snowflake
**Communication:** Slack, Microsoft Teams, email notifications
**Storage:** Google Drive, Dropbox, Amazon S3, Azure Blob
**Automation:** Make, Zapier, n8n, Pipedream

***

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [USPTO Office Actions Scraper](https://apify.com/parseforge/uspto-office-actions-scraper) | Extract office action history for patent applications from USPTO PEDS |
| [WIPO Brand Database Scraper](https://apify.com/parseforge/wipo-brand-database-scraper) | Search international trademark registrations via WIPO |
| [FCC Broadband Map Scraper](https://apify.com/parseforge/fcc-broadband-map-scraper) | Pull FCC broadband availability data by location |

> 💡 **Pro Tip:** Browse the complete [ParseForge collection](https://apify.com/parseforge) for more government data, business intelligence, and IP research scrapers.

***

**Disclaimer:** This tool accesses publicly available data from the USPTO Assignment Center in compliance with the USPTO's terms of use. It is intended for legitimate research, legal, and business purposes. ParseForge is not affiliated with the United States Patent and Trademark Office. Users are responsible for ensuring their use of the data complies with applicable laws and regulations.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `searchField` (type: `string`):

Which field to search by.

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

Value to look up. For Assignee/Assignor: company or person name (e.g. 'Apple'). For Patent/Application/Publication: the number. For Reel/Frame: use format '28725/607'.

## `matchType` (type: `string`):

Whether to search for an exact match or allow partial (contains) matches. Applies to Assignee Name, Assignor Name, and Correspondent Name searches.

## `dateFrom` (type: `string`):

Limit assignments recorded on or after this date (MM/DD/YYYY, e.g. 01/01/2020).

## `dateTo` (type: `string`):

Limit assignments recorded on or before this date (MM/DD/YYYY, e.g. 12/31/2024).

## Actor input object example

```json
{
  "maxItems": 10,
  "searchField": "assigneeName",
  "searchQuery": "Apple",
  "matchType": "Contains"
}
```

# Actor output Schema

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

Scraped patent assignment records

# 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,
    "searchField": "assigneeName",
    "searchQuery": "Apple",
    "matchType": "Contains"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/uspto-patent-assignments-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,
    "searchField": "assigneeName",
    "searchQuery": "Apple",
    "matchType": "Contains",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/uspto-patent-assignments-scraper").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 '{
  "maxItems": 10,
  "searchField": "assigneeName",
  "searchQuery": "Apple",
  "matchType": "Contains"
}' |
apify call parseforge/uspto-patent-assignments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USPTO Patent Assignments Scraper",
        "description": "Export patent ownership records from the USPTO Patent Assignment Search. Pull assignor, assignee, conveyance type, properties affected, execution dates, and recorded reel/frame entries. Search by patent number, application number, assignee, or assignor name.",
        "version": "0.1",
        "x-build-id": "JT81sdc8iaprwhkz1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~uspto-patent-assignments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-uspto-patent-assignments-scraper",
                "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/parseforge~uspto-patent-assignments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-uspto-patent-assignments-scraper",
                "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/parseforge~uspto-patent-assignments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-uspto-patent-assignments-scraper",
                "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",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "searchField": {
                        "title": "Search Field",
                        "enum": [
                            "assigneeName",
                            "assignorName",
                            "patentNumber",
                            "applicationNumber",
                            "publicationNumber",
                            "pctNumber",
                            "reelFrame"
                        ],
                        "type": "string",
                        "description": "Which field to search by."
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Value to look up. For Assignee/Assignor: company or person name (e.g. 'Apple'). For Patent/Application/Publication: the number. For Reel/Frame: use format '28725/607'."
                    },
                    "matchType": {
                        "title": "Match Type",
                        "enum": [
                            "Contains",
                            "Exact"
                        ],
                        "type": "string",
                        "description": "Whether to search for an exact match or allow partial (contains) matches. Applies to Assignee Name, Assignor Name, and Correspondent Name searches."
                    },
                    "dateFrom": {
                        "title": "Recorded Date From",
                        "type": "string",
                        "description": "Limit assignments recorded on or after this date (MM/DD/YYYY, e.g. 01/01/2020)."
                    },
                    "dateTo": {
                        "title": "Recorded Date To",
                        "type": "string",
                        "description": "Limit assignments recorded on or before this date (MM/DD/YYYY, e.g. 12/31/2024)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
