# USPTO PAIR Scraper | US Patent and Application Records (`parseforge/uspto-pair-scraper`) Actor

Search and export US patents and applications by keyword, assignee, inventor, status, and priority date. Pull title, abstract, dates, inventors, assignees and PDF links from millions of USPTO records. CSV, Excel, JSON or XML for IP research, FTO and prior-art workflows.

- **URL**: https://apify.com/parseforge/uspto-pair-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, Lead generation
- **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 PAIR Scraper

> 🚀 **Search and export US patents and applications in seconds.** Find patents by keyword, assignee, inventor, status, or date and pull the full bibliographic record as CSV, Excel, JSON, or XML.

> 🕒 **Last updated:** 2026-05-26 · **📊 15 fields** per record · **Millions of US patents** · **USPTO coverage 1790-present**

The USPTO PAIR Scraper pulls US patent and application records by querying the public USPTO bibliographic index. Each record includes publication number, title, abstract snippet, assignee, inventor, priority/filing/publication/grant dates, language, PDF link, and a direct USPTO source link.

The index covers granted patents back to 1790 and published applications since 2001. The scraper supports the same query syntax used by professional patent search tools - free-text terms, assignee filters, inventor filters, status filters, and date ranges.

**Target Audience / Use Cases**

| Who | Why |
|---|---|
| IP attorneys & paralegals | Prior art searches, freedom-to-operate, due diligence |
| Competitive intelligence | Track competitor patent filings |
| R&D teams | Discover technology trends in your field |
| Investors & M&A analysts | Map patent portfolios for acquisition targets |
| Academic researchers | Quantitative patent landscape analysis |
| Patent licensing professionals | Find licensable technologies and current owners |

---

### 📋 What the USPTO PAIR Scraper does

- Searches USPTO bibliographic data by free-text query, assignee, inventor, or status
- Paginates automatically until maxItems is reached
- Extracts up to 15 fields per record including title, abstract snippet, dates, parties, and PDF link
- Exports to CSV, Excel, JSON, or XML
- Filters by priority date range, language, and grant vs application status
- Returns a clean USPTO source URL for every record

> 💡 **Why it matters:** US patents are the single most-cited form of technical disclosure. Programmatic access to USPTO records lets you build patent landscapes, monitor competitors, and run prior-art searches at scale.

---

### 🎬 Full Demo

_🚧 Coming soon_

---

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Default</th><th>Description</th></tr>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Maximum number of records to return. Free users are capped at 10.</td></tr>
<tr><td>query</td><td>string</td><td>solar panel</td><td>Free-text keywords. Use quotes for exact phrases.</td></tr>
<tr><td>country</td><td>select</td><td>US</td><td>ISO country code - leave US for USPTO patents.</td></tr>
<tr><td>assignee</td><td>string</td><td></td><td>Filter by patent assignee name</td></tr>
<tr><td>inventor</td><td>string</td><td></td><td>Filter by inventor name</td></tr>
<tr><td>status</td><td>select</td><td></td><td>GRANT, APPLICATION, or empty for both</td></tr>
<tr><td>dateFrom</td><td>string</td><td></td><td>Priority date from (YYYY-MM-DD)</td></tr>
<tr><td>dateTo</td><td>string</td><td></td><td>Priority date to (YYYY-MM-DD)</td></tr>
<tr><td>language</td><td>select</td><td></td><td>Filter by language code</td></tr>
<tr><td>sort</td><td>select</td><td>new</td><td>Sort order</td></tr>
</table>

**Example 1 - Search by keyword:**
```json
{
    "maxItems": 100,
    "query": "solid state battery",
    "country": "US"
}
````

**Example 2 - Find Apple patents granted since 2023:**

```json
{
    "maxItems": 50,
    "query": "",
    "country": "US",
    "assignee": "Apple Inc.",
    "status": "GRANT",
    "dateFrom": "2023-01-01"
}
```

> ⚠️ **Good to Know:** Use quotes around exact phrases. The country filter accepts standard ISO country codes. Free users are limited to 10 records per run regardless of maxItems.

***

### 📊 Output

Each record contains up to 15 fields:

| Field | Type | Description |
|---|---|---|
| 🔢 `publicationNumber` | string | USPTO publication number (e.g. US10000000B2) |
| 📋 `title` | string | Patent title |
| 📝 `snippet` | string | Abstract snippet from the patent |
| 🏢 `assignee` | string | Patent assignee |
| 🧑‍🔬 `inventor` | string | Inventor names |
| 📅 `priorityDate` | string | Priority filing date |
| 📅 `filingDate` | string | Filing date |
| 📅 `publicationDate` | string | Publication date |
| 📅 `grantDate` | string | Grant date (granted patents only) |
| 🌐 `language` | string | Patent language |
| 🇺🇸 `countryCode` | string | Country code |
| 📄 `pdfUrl` | string | Direct link to the patent PDF |
| 🖼️ `thumbnailUrl` | string | First-figure thumbnail |
| 🔗 `sourceUrl` | string | USPTO source URL |
| 🕒 `scrapedAt` | string | ISO 8601 timestamp |

**Sample record:**

```json
{
  "publicationNumber": "US20100307564A1",
  "title": "Apparatus for two-way tracing and condensing sunlight of roof installation type",
  "assignee": "Young Hwan Park",
  "inventor": "Young Hwan Park",
  "priorityDate": "2009-06-03",
  "filingDate": "2009-09-22",
  "publicationDate": "2010-12-09",
  "countryCode": "US",
  "sourceUrl": "https://patents.google.com/patent/US20100307564A1/en",
  "scrapedAt": "2026-05-26T12:00:00.000Z"
}
```

***

### ✨ Why choose this Actor

- 🔄 **Real-time data** scraped live on every run
- 🆕 **Modern source** - uses the public USPTO bibliographic index
- 🔍 **6 filter modes** - query, assignee, inventor, status, date range, language
- 📑 **15 fields per record**
- 📦 **Batch export** - CSV, Excel, JSON, XML
- 💰 **Pay-per-result** pricing
- 🚫 **No login required**

***

### 📈 How it compares to alternatives

| Feature | This Actor | Manual USPTO Patent Center | USPTO Open Data Portal |
|---|---|---|---|
| Search by keyword | Yes | Yes | API key required |
| Bulk export | Yes | One page at a time | Yes (with key) |
| Pagination | Automatic | Manual | Cursor-based |
| No login required | Yes | No | API key needed |
| Pay per result | Yes | Free | Free |

***

### 🚀 How to use

1. **Create a free account** at [Apify](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 free credit)
2. Open the **USPTO PAIR Scraper** actor page and click **Try for free**
3. Enter your query, assignee, or inventor name
4. Optionally set **maxItems** and other filters
5. Click **Start** and wait for the run to finish
6. Download your dataset as **CSV, Excel, JSON, or XML**

***

### 💼 Business use cases

#### Patent Landscape Analysis

Build comprehensive maps of patent activity in your technology area. Filter by date range and aggregate by assignee to identify the most active competitors.

#### Competitive Monitoring

Schedule the actor to run weekly with a competitor name as the assignee filter. Get alerted when new USPTO patents appear.

#### Prior Art Searches

IP attorneys can run keyword searches to find prior art for freedom-to-operate analyses and patentability opinions.

#### M\&A Due Diligence

Map a target companys patent portfolio in minutes - filings, grants, dates, and bibliographic data ready for analysis.

***

### 🔌 Automating USPTO PAIR Scraper

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

- **Make (Integromat)** - send new records to Google Sheets, Airtable, or Slack
- **Zapier** - automate alerts when new records are found
- **n8n** - build pipelines that run on a schedule and push to your warehouse
- **Webhooks** - get notified when a run completes via Apify webhooks

***

### 🌟 Beyond business use cases

#### Independent Researchers

Independent inventors can research existing patents in their field before drafting their own applications.

#### Journalism and Investigations

Journalists covering Big Tech, pharma, or defense can quantify R\&D spending by mapping patent activity.

#### Non-Profit and Policy Research

Policy researchers studying patent concentration or technology transfer can build longitudinal datasets.

#### Education

Law schools use USPTO data in IP clinics and patent law courses to teach search techniques.

***

### 🤖 Ask an AI assistant about this scraper

You can ask your AI assistant questions like:

- "How do I search USPTO patents for a specific company?"
- "What fields are available in USPTO patent records?"
- "How do I monitor new patent filings for a competitor?"
- "What is the difference between a patent application and a grant?"

The answers will reference this actor and the USPTO bibliographic index.

***

### ❓ Frequently Asked Questions

**How current is the data?**
Data is fetched live on every run. USPTO publications typically appear within days of being granted or published.

**Can I search by assignee?**
Yes. Use the assignee field with a company or person name.

**Does this require a USPTO account?**
No. All data is public.

**Can I filter by date range?**
Yes. dateFrom and dateTo filter by priority date in YYYY-MM-DD format.

**What is the difference between application and grant?**
Applications are pending patents. Grants are issued patents. Use the status filter to choose.

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

**Can I export to CSV or Excel?**
Yes. The Apify dataset supports CSV, Excel, JSON, and XML export.

**Can I monitor new patents on a schedule?**
Yes. Use Apify scheduler to run the actor at any interval.

**Are international patents included if I set country=US?**
No. The country filter restricts to USPTO-issued patents only.

**How accurate is the assignee filter?**
It matches the assignee as recorded by the USPTO. Mergers and assignments after issuance are not reflected here.

**What if the source rate-limits my run?**
The actor retries with backoff. Most rate limits clear within minutes.

***

### 🔌 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 Patent Assignments Scraper](https://apify.com/parseforge/uspto-patent-assignments-scraper) | Pull chain-of-title from the USPTO Assignment Center |
| [USPTO Office Actions Scraper](https://apify.com/parseforge/uspto-office-actions-scraper) | Extract office action history for patent applications |
| [Google Patents Scraper](https://apify.com/parseforge/google-patents-scraper) | Worldwide patent search via Google Patents |

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

***

**Disclaimer:** This tool accesses publicly available US patent bibliographic data. ParseForge is not affiliated with the United States Patent and Trademark Office. Users are responsible for ensuring their use complies with applicable laws.

# Actor input Schema

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

Free users: 10. Paid: up to 1,000,000

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

Free-text keywords (e.g. "solar panel"). Use double quotes for exact phrases.

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

ISO country code (e.g. US, CA, IN, CN, JP, EP, WO). Leave empty for worldwide.

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

Filter by patent assignee (company or person)

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

Filter by inventor name

## `status` (type: `string`):

GRANT, APPLICATION, or empty for both

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

YYYY-MM-DD format

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

YYYY-MM-DD format

## `language` (type: `string`):

Filter by language code

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

Sort by publication date

## Actor input object example

```json
{
  "maxItems": 10,
  "query": "solar panel",
  "country": "US",
  "sort": "new"
}
```

# Actor output Schema

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

Scraped 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,
    "query": "solar panel",
    "country": "US",
    "sort": "new"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/uspto-pair-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": "solar panel",
    "country": "US",
    "sort": "new",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/uspto-pair-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,
  "query": "solar panel",
  "country": "US",
  "sort": "new"
}' |
apify call parseforge/uspto-pair-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USPTO PAIR Scraper | US Patent and Application Records",
        "description": "Search and export US patents and applications by keyword, assignee, inventor, status, and priority date. Pull title, abstract, dates, inventors, assignees and PDF links from millions of USPTO records. CSV, Excel, JSON or XML for IP research, FTO and prior-art workflows.",
        "version": "0.1",
        "x-build-id": "2djVmR9sa6GTzyGy8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~uspto-pair-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-uspto-pair-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-pair-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-uspto-pair-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-pair-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-uspto-pair-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: 10. Paid: up to 1,000,000"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Free-text keywords (e.g. \"solar panel\"). Use double quotes for exact phrases."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "",
                            "US",
                            "CA",
                            "IN",
                            "CN",
                            "JP",
                            "KR",
                            "GB",
                            "DE",
                            "FR",
                            "EP",
                            "WO",
                            "AU",
                            "BR",
                            "RU",
                            "ES",
                            "IT",
                            "NL",
                            "MX",
                            "AR",
                            "ZA",
                            "CH",
                            "SE",
                            "NO",
                            "FI",
                            "DK",
                            "BE",
                            "AT",
                            "SG",
                            "TW",
                            "HK",
                            "IL",
                            "TR",
                            "PL",
                            "PT",
                            "GR",
                            "IE"
                        ],
                        "type": "string",
                        "description": "ISO country code (e.g. US, CA, IN, CN, JP, EP, WO). Leave empty for worldwide."
                    },
                    "assignee": {
                        "title": "Assignee",
                        "type": "string",
                        "description": "Filter by patent assignee (company or person)"
                    },
                    "inventor": {
                        "title": "Inventor",
                        "type": "string",
                        "description": "Filter by inventor name"
                    },
                    "status": {
                        "title": "Status",
                        "enum": [
                            "",
                            "GRANT",
                            "APPLICATION"
                        ],
                        "type": "string",
                        "description": "GRANT, APPLICATION, or empty for both"
                    },
                    "dateFrom": {
                        "title": "Priority Date From",
                        "type": "string",
                        "description": "YYYY-MM-DD format"
                    },
                    "dateTo": {
                        "title": "Priority Date To",
                        "type": "string",
                        "description": "YYYY-MM-DD format"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "",
                            "en",
                            "de",
                            "fr",
                            "zh",
                            "ja",
                            "ko",
                            "es",
                            "ru"
                        ],
                        "type": "string",
                        "description": "Filter by language code"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "new",
                            "old",
                            ""
                        ],
                        "type": "string",
                        "description": "Sort by publication date"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
