# USPTO Trademark Search Scraper (`automation-lab/uspto-trademark-search-scraper`) Actor

Search USPTO trademark records by keyword, owner, serial number, registration number, status, and class. Export owners, goods/services, dates, and links.

- **URL**: https://apify.com/automation-lab/uspto-trademark-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## USPTO Trademark Search Scraper

Search and extract public USPTO trademark records from the official Trademark Search system.

Use this actor to collect word marks, serial numbers, registration numbers, owners, goods and services, Nice classes, live/dead status, filing dates, registration dates, and USPTO detail links for brand research, IP due diligence, and trademark monitoring workflows.

### What does USPTO Trademark Search Scraper do?

USPTO Trademark Search Scraper turns USPTO trademark search results into structured dataset rows.

It can search by:

- 🔎 Trademark keyword or phrase
- 🏢 Owner, applicant, or registrant name
- 🔢 USPTO serial number
- 🧾 USPTO registration number
- ⚖️ Live or dead status
- 🧩 International class / Nice class

The actor uses the same public JSON endpoints that power the USPTO Trademark Search web app and can optionally enrich each record with detail data from USPTO TSDR.

### Who is it for?

This actor is built for people who need repeatable trademark intelligence without manually copying search results.

- ⚖️ IP attorneys checking potential conflicts
- 🏢 In-house legal teams monitoring brand filings
- 🕵️ Brand-protection analysts watching names and owners
- 📈 Market researchers tracking competitor marks
- 🧾 Agencies preparing clearance reports
- 🤖 Developers feeding trademark data into internal tools

### Why use it?

Manual USPTO searches are useful for one-off lookups, but they are slow to repeat and hard to export.

This actor helps you:

- Export search results as JSON, CSV, Excel, XML, or RSS
- Run the same monitoring query on a schedule
- Mix keyword and owner searches with direct serial-number lookups
- Keep URLs back to USPTO and TSDR for legal review
- Enrich selected runs with TSDR detail fields
- Integrate USPTO data into dashboards, CRMs, spreadsheets, and data warehouses

### Data extracted

| Field | Description |
| --- | --- |
| `serialNumber` | USPTO serial number |
| `registrationNumber` | USPTO registration number when available |
| `wordmark` | Trademark word mark / mark text |
| `status` | Live or Dead |
| `ownerNames` | Owner/applicant names |
| `ownerFullText` | USPTO owner text with entity and address details |
| `goodsAndServices` | Goods and services descriptions |
| `internationalClasses` | Nice / international classes |
| `markType` | Mark type values from USPTO |
| `filingDate` | Filing date |
| `registrationDate` | Registration date when available |
| `statusDate` | USPTO status date when available |
| `attorney` | Attorney name when available |
| `designCodeDescription` | Design code descriptions when present |
| `detailUrl` | USPTO Trademark Search detail URL |
| `tsdrUrl` | TSDR status URL |
| `imageUrl` | USPTO mark image URL |
| `caseStatus` | Optional TSDR case status when detail enrichment is enabled |

### How much does it cost to scrape USPTO trademark search results?

The actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-record fee for each trademark record saved.

Keep `includeDetails` disabled for broad monitoring runs when you only need search-result fields. Enable detail enrichment when you need deeper TSDR case status data.

### Input options

#### `searchQuery`

A word, phrase, brand name, slogan, or product name to search in USPTO trademark records.

Example:

```json
"nike"
````

#### `ownerName`

An owner, applicant, registrant, or company name.

Example:

```json
"NIKE"
```

#### `serialNumbers`

Direct USPTO serial-number lookups.

Example:

```json
["73758651", "97123456"]
```

#### `registrationNumbers`

Direct USPTO registration-number lookups.

Example:

```json
["1558118"]
```

#### `status`

Choose `all`, `live`, or `dead`.

#### `internationalClasses`

Filter to one or more Nice classes.

Examples:

```json
["025", "IC 009"]
```

#### `includeDetails`

When true, the actor calls the USPTO TSDR detail endpoint for each result.

This adds fields such as `caseStatus`, `publicationDate`, `earliestRenewalDate`, and related-record counts.

#### `maxItems`

Maximum trademark records to save.

Use small limits for testing and larger limits for monitoring or research exports.

### Example input

```json
{
  "searchQuery": "nike",
  "status": "live",
  "internationalClasses": ["025"],
  "includeDetails": false,
  "maxItems": 50
}
```

### Example output

```json
{
  "searchQuery": "nike",
  "serialNumber": "73758651",
  "registrationNumber": "1558118",
  "wordmark": "I.E. NIKE",
  "status": "Dead",
  "alive": false,
  "ownerNames": ["NIKE, INC. (CORPORATION; OREGON, USA)"],
  "goodsAndServices": ["(CANCELLED) IC 025: [ FOOTWEAR ]."],
  "internationalClasses": ["IC 025"],
  "filingDate": "1988-10-20",
  "registrationDate": "1989-09-26",
  "detailUrl": "https://tmsearch.uspto.gov/search/summary?serial=73758651",
  "tsdrUrl": "https://tsdr.uspto.gov/#caseNumber=73758651&caseSearchType=US_APPLICATION&caseType=DEFAULT&searchType=statusSearch",
  "scrapedAt": "2026-07-10T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Enter a trademark keyword, owner name, serial number, or registration number.
3. Choose status and class filters if needed.
4. Set `maxItems`.
5. Run the actor.
6. Download the dataset in your preferred format.

### Tips for better results

- Use exact brand names for clearance-style checks.
- Use owner search for portfolio monitoring.
- Use class filters to narrow broad marks.
- Start without `includeDetails` for faster broad searches.
- Enable `includeDetails` for final review exports.
- Keep `maxItems` small while testing a new query.

### Common workflows

#### Trademark clearance research

Search a proposed name and export matching live and dead records for review.

#### Owner portfolio monitoring

Run a scheduled owner query to detect newly visible filings for a company or competitor.

#### Class-specific brand monitoring

Combine a keyword with one or more Nice classes to focus on a product category.

#### Direct record enrichment

Provide serial numbers or registration numbers to normalize known marks into a structured dataset.

### Integrations

You can connect the dataset to:

- Google Sheets
- Airtable
- Slack alerts
- Legal review dashboards
- Brand monitoring systems
- Data warehouses
- Custom APIs through Apify webhooks

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/uspto-trademark-search-scraper').call({
  searchQuery: 'nike',
  status: 'live',
  maxItems: 50,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/uspto-trademark-search-scraper').call(run_input={
    'searchQuery': 'nike',
    'status': 'live',
    'maxItems': 50,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~uspto-trademark-search-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQuery":"nike","status":"live","maxItems":50}'
```

### MCP usage

Use the actor from Claude Desktop, Claude Code, or other MCP-compatible clients with Apify MCP Server.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/uspto-trademark-search-scraper
```

Claude Code setup:

```bash
claude mcp add apify-uspto-trademark-search "https://mcp.apify.com/?tools=automation-lab/uspto-trademark-search-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-uspto-trademark-search": {
      "url": "https://mcp.apify.com/?tools=automation-lab/uspto-trademark-search-scraper"
    }
  }
}
```

Example prompts:

- "Search USPTO trademarks for this proposed brand name and summarize live conflicts."
- "Find live USPTO trademark records owned by this company in class 025."
- "Export USPTO trademark records for these serial numbers."

### Scheduling

Create an Apify schedule to run the same query daily, weekly, or monthly.

Scheduling is useful for:

- New filings by a competitor
- New marks containing a monitored word
- Class-specific brand monitoring
- Portfolio snapshots

### Webhooks

Use Apify webhooks to notify your system when a run finishes.

Common webhook targets include:

- Slack
- Make
- Zapier
- Internal legal dashboards
- Data ingestion APIs

### Data quality notes

The actor returns data available from USPTO public systems at run time.

USPTO records can contain missing registration numbers, cancelled records, old owner text, or marks without images.

Always review official USPTO/TSDR links before making legal decisions.

### Limitations

- The actor is not legal advice.
- USPTO may change its public web app or API behavior.
- Very broad queries can return many records; use `maxItems` and filters.
- Detail enrichment adds one extra USPTO detail request per record.

### Legality

This actor extracts public data from official USPTO public search systems.

You are responsible for using the data lawfully, respecting Apify terms, USPTO terms, and any professional obligations that apply to your work.

### FAQ

#### Can I search by serial number?

Yes. Add serial numbers to `serialNumbers`.

#### Can I search by registration number?

Yes. Add registration numbers to `registrationNumbers`.

#### Can I get only live trademarks?

Yes. Set `status` to `live`.

#### Why are some registration numbers empty?

Pending applications and some dead records may not have a registration number.

#### Why is a mark image missing?

Some marks do not have a usable image URL, especially typed drawings or older records.

#### Should I enable detail enrichment?

Enable it when you need deeper case-status fields. Leave it off for faster and cheaper broad searches.

### Troubleshooting

#### My query returns too many records

Add a status filter, owner name, international class, or lower `maxItems`.

#### My query returns no records

Try a broader keyword, remove class filters, or check the spelling in the official USPTO search interface.

### Related scrapers

Other automation-lab actors that may fit adjacent IP and legal workflows:

- https://apify.com/automation-lab/uspto-trademark-status-checker
- https://apify.com/automation-lab/uspto-patent-assignments-scraper

### Support

If you need a field that is visible in USPTO but missing from this actor, open an issue with an example serial number and the field you need.

### Changelog

See `.actor/CHANGELOG.md` for release notes.

### Ready-to-use examples

Use the task examples in Apify after publication for:

- Search-intent trademark keyword exports
- Owner portfolio monitoring
- Detail-enriched due diligence exports

# Actor input Schema

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

Word mark or phrase to search in USPTO trademark records (for example, a brand name, product line, or slogan).

## `ownerName` (type: `string`):

Optional owner, applicant, or registrant name to match in USPTO owner text.

## `serialNumbers` (type: `array`):

Optional USPTO serial numbers to retrieve directly. One serial number per item.

## `registrationNumbers` (type: `array`):

Optional USPTO registration numbers to retrieve directly. One registration number per item.

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

Filter results to live filings, dead filings, or all matching records.

## `internationalClasses` (type: `array`):

Optional Nice classes such as 025 or IC 025. Leave empty to include all classes.

## `includeDetails` (type: `boolean`):

Fetch the USPTO TSDR detail endpoint for each result to add case status, publication date, renewal date, and counts.

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

Maximum USPTO trademark records to save to the dataset.

## Actor input object example

```json
{
  "searchQuery": "nike",
  "serialNumbers": [],
  "registrationNumbers": [],
  "status": "all",
  "internationalClasses": [],
  "includeDetails": false,
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQuery": "nike",
    "ownerName": "",
    "serialNumbers": [],
    "registrationNumbers": [],
    "status": "all",
    "internationalClasses": [],
    "includeDetails": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/uspto-trademark-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQuery": "nike",
    "ownerName": "",
    "serialNumbers": [],
    "registrationNumbers": [],
    "status": "all",
    "internationalClasses": [],
    "includeDetails": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/uspto-trademark-search-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 '{
  "searchQuery": "nike",
  "ownerName": "",
  "serialNumbers": [],
  "registrationNumbers": [],
  "status": "all",
  "internationalClasses": [],
  "includeDetails": false,
  "maxItems": 20
}' |
apify call automation-lab/uspto-trademark-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USPTO Trademark Search Scraper",
        "description": "Search USPTO trademark records by keyword, owner, serial number, registration number, status, and class. Export owners, goods/services, dates, and links.",
        "version": "0.1",
        "x-build-id": "eb9WEFb38louWgnGN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~uspto-trademark-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-uspto-trademark-search-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/automation-lab~uspto-trademark-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-uspto-trademark-search-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/automation-lab~uspto-trademark-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-uspto-trademark-search-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": {
                    "searchQuery": {
                        "title": "Trademark keyword",
                        "type": "string",
                        "description": "Word mark or phrase to search in USPTO trademark records (for example, a brand name, product line, or slogan)."
                    },
                    "ownerName": {
                        "title": "Owner / applicant name",
                        "type": "string",
                        "description": "Optional owner, applicant, or registrant name to match in USPTO owner text."
                    },
                    "serialNumbers": {
                        "title": "Serial numbers",
                        "type": "array",
                        "description": "Optional USPTO serial numbers to retrieve directly. One serial number per item.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "registrationNumbers": {
                        "title": "Registration numbers",
                        "type": "array",
                        "description": "Optional USPTO registration numbers to retrieve directly. One registration number per item.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "status": {
                        "title": "Trademark status",
                        "enum": [
                            "all",
                            "live",
                            "dead"
                        ],
                        "type": "string",
                        "description": "Filter results to live filings, dead filings, or all matching records.",
                        "default": "all"
                    },
                    "internationalClasses": {
                        "title": "International classes",
                        "type": "array",
                        "description": "Optional Nice classes such as 025 or IC 025. Leave empty to include all classes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDetails": {
                        "title": "Include detail record",
                        "type": "boolean",
                        "description": "Fetch the USPTO TSDR detail endpoint for each result to add case status, publication date, renewal date, and counts.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum USPTO trademark records to save to the dataset.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```