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

Search official US trademark registrations from the USPTO Trademark Search system (tmsearch.uspto.gov). Search by wordmark, owner name, goods/services, serial number, or registration number. Filter by live/dead status and Nice international class (1-45).

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

Scrape **USPTO Trademark Search** (tmsearch.uspto.gov) — the official United States Patent
and Trademark Office trademark database. Search by wordmark/keyword, owner/applicant name,
goods & services description, or look up exact records by serial number or registration
number. Filter by live/dead status, Nice international class (1-45, plus certification
and collective-membership classes), and mark type. HTTP-only, no login, no API key.

### What this actor does

- **Seven modes:** `search`, `bySerialNumber`, `byRegistrationNumber`, `byOwner`, `byGoodsServices`, `byProceedingNumber`, `byInternationalRegistrationNumber`
- **Status filter:** live (active) vs. dead (abandoned/cancelled/expired)
- **International class filter:** full Nice Classification 1-45, plus certification (A/B) and collective-membership (200) classes
- **Mark type filter:** trademark, service mark, collective mark, collective membership mark, certification mark
- **Full record detail:** owner(s) incl. entity type/citizenship/city/DBA, filing/registration/first-use/priority/abandonment/cancellation dates, goods & services text, disclaimers, translations/transliterations, filing basis, drawing code + description, design search codes, detailed status description, TTAB proceeding history, Madrid international registration references, and a direct link to the official USPTO TSDR case-status page
- **Empty fields are omitted**

### Output per trademark

- `serialNumber` — USPTO application serial number
- `registrationNumber` — USPTO registration number (only present once registered)
- `wordmark` — the literal trademark text
- `wordmarkPseudoText[]` — normalized/phonetic equivalent text
- `status` — `live` or `dead`; `statusCode`, `statusDescription` — USPTO's detailed numeric/text status (e.g. `REGISTERED AND RENEWED`)
- `registered` — whether the filing has proceeded to registration
- `markType` — primary mark type (e.g. `TRADEMARK`, `SERVICE MARK`, `CERTIFICATION MARK`)
- `markTypes[]` — all mark types, when a filing has more than one
- `markDescription[]`, `designCodeDescription[]`, `designCode[]` — design-mark descriptions and USPTO design search codes, when applicable
- `internationalClass[]` — Nice Classification codes (e.g. `009`, `035`, `200`)
- `usClass[]`, `coordinatedClass` — US classification codes
- `ownerName[]`, `ownerFullText[]`, `ownerType`, `ownerEntity`, `ownerCitizenship`, `ownerCity`, `ownerStateCountryAddress`, `ownerDBA` — owner/registrant information
- `attorney` — attorney of record, if any
- `goodsAndServices[]` — goods & services description text (capped at 20 entries)
- `disclaimer`, `translation`, `transliteration` — legal disclaimer, foreign-wording translation, and transliteration text
- `currentBasis[]`, `originalBasis[]`, `registrationType[]`, `standardCharacterClaim`, `assignmentRecorded` — filing basis, registration type, and legal-status flags
- `affidavit[]` — Section 8/15 affidavits filed
- `proceedings[]` — TTAB opposition/cancellation proceeding numbers, when the mark has any
- `internationalRegistrationRefNumbers[]` — Madrid Protocol international registration references, when applicable
- `drawingCode`, `drawingCodeDescription` — USPTO drawing code and its description
- `filedDate`, `registrationDate`, `firstUseAnyDate`, `firstUseCommerceDate`, `priorityDate`, `abandonDate`, `cancelDate`, `publishForOppositionDate`, `supplementalRegistrationDate`
- `sourceUrl` — official USPTO TSDR case-status page for this filing
- `recordType: "trademark"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `bySerialNumber` / `byRegistrationNumber` / `byOwner` / `byGoodsServices` / `byProceedingNumber` / `byInternationalRegistrationNumber` |
| `searchQuery` | string | `apple` | Free-text wordmark query (mode=search) |
| `serialNumbers` | array | – | Serial numbers to look up (mode=bySerialNumber) |
| `registrationNumbers` | array | – | Registration numbers to look up (mode=byRegistrationNumber) |
| `ownerName` | string | – | Owner/applicant name query (mode=byOwner) |
| `goodsAndServicesQuery` | string | – | Keyword to search within goods & services text (mode=byGoodsServices) |
| `proceedingNumbers` | array | – | TTAB proceeding numbers to look up (mode=byProceedingNumber) |
| `internationalRegistrationNumbers` | array | – | Madrid Protocol international registration numbers (mode=byInternationalRegistrationNumber) |
| `status` | string | `any` | `any` / `live` / `dead` |
| `internationalClass` | string | `any` | Nice class `001`-`045`, `A`, `B`, `200`, or `any` |
| `markType` | string | `any` | Mark type filter, or `any` |
| `maxItems` | int | `20` | Hard cap on emitted records (1-500) |
| `proxyConfiguration` | object | AUTO | Optional Apify Proxy configuration |

#### Example: search by wordmark, live trademarks only

```json
{
  "mode": "search",
  "searchQuery": "apple",
  "status": "live",
  "internationalClass": "009",
  "maxItems": 25
}
````

#### Example: exact lookup by serial number

```json
{
  "mode": "bySerialNumber",
  "serialNumbers": ["74683130", "87491047"]
}
```

#### Example: search by owner name

```json
{
  "mode": "byOwner",
  "ownerName": "nike inc",
  "status": "live",
  "maxItems": 50
}
```

#### Example: search by goods & services keyword

```json
{
  "mode": "byGoodsServices",
  "goodsAndServicesQuery": "coffee",
  "internationalClass": "030"
}
```

#### Example: lookup by TTAB proceeding number

```json
{
  "mode": "byProceedingNumber",
  "proceedingNumbers": ["91177505"]
}
```

#### Example: lookup by Madrid international registration number

```json
{
  "mode": "byInternationalRegistrationNumber",
  "internationalRegistrationNumbers": ["0870749"]
}
```

### Data source / limitations

Data comes from the same public search index that powers USPTO's own tmsearch.uspto.gov
search UI. Mark description text and design code are exposed as output fields (populated
whenever USPTO records them) rather than as separate search modes, since they're most
useful as enrichment alongside the other lookup axes. The raw field-tag/search-builder
syntax from the USPTO UI is not exposed as a passthrough — all of its practical lookup
axes (wordmark, owner, goods/services, serial/registration number, TTAB proceeding number,
Madrid international registration number, status, class, mark type) are already covered
by the modes and filters above.

### Use cases

- **Trademark clearance searches** — check whether a mark is already registered before filing
- **Brand protection** — monitor filings by a competitor or by your own company across all classes
- **IP due diligence** — pull registration status and dates for M\&A or licensing review
- **Legal research** — bulk-export filings in a given Nice class or goods/services category
- **Portfolio management** — track your own trademark portfolio's status and key dates

### FAQ

**What is the data source?**
The public USPTO Trademark Search system at tmsearch.uspto.gov, which replaced the legacy
TESS system. All data is official USPTO trademark register data.

**Is this affiliated with the USPTO?**
No. This is an independent third-party actor that uses USPTO's own public search system. It
is not affiliated with, endorsed by, or sponsored by the USPTO.

**What does "live" vs. "dead" mean?**
Live means the application or registration is still active (pending or registered). Dead
means it has been abandoned, cancelled, expired, or otherwise removed from active status.

**Why do some records have no `registrationNumber`?**
Only applications that proceed to registration receive a registration number. Pending or
abandoned applications may only have a serial number.

**What is `internationalClass`?**
The Nice Classification system groups goods and services into 45 numbered international
classes (e.g. class 025 = clothing, class 042 = computer/scientific services), plus special
classes for certification marks (A, B) and collective membership marks (200).

**Is search full-text or exact match?**
`search`, `byOwner`, and `byGoodsServices` perform relevance-ranked full-text search (similar
to typing into the USPTO's own search box). `bySerialNumber` and `byRegistrationNumber` are
exact lookups.

**How fresh is the data?**
Data reflects the USPTO's live trademark search index at the time the actor runs.

**What is a TTAB proceeding number?**
The Trademark Trial and Appeal Board (TTAB) hears oppositions and cancellations. A mark
with a contested history lists every associated proceeding number in `proceedings[]`;
`mode=byProceedingNumber` looks up every mark tied to a given proceeding.

**What is the Madrid international registration number?**
Marks registered internationally through the Madrid Protocol carry a WIPO international
registration number alongside their US filing. `mode=byInternationalRegistrationNumber`
looks up the US filing(s) tied to a given international registration number.

**Are there rate limits?**
The USPTO search system is public and does not require an API key or login. The actor
paginates politely; very large `maxItems` values on broad queries may take longer to complete.

# Actor input Schema

## `mode` (type: `string`):

What to search.

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

Free-text trademark/wordmark query (mode=search), e.g. `apple` or `nike air`.

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

USPTO application serial numbers, e.g. `74683130`.

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

USPTO registration numbers, e.g. `2005764`.

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

Free-text owner/applicant name query, e.g. `nike inc`.

## `goodsAndServicesQuery` (type: `string`):

Free-text keyword to search within the goods & services description, e.g. `coffee`.

## `proceedingNumbers` (type: `array`):

USPTO Trademark Trial and Appeal Board proceeding numbers (opposition/cancellation), e.g. `91177505`.

## `internationalRegistrationNumbers` (type: `array`):

WIPO Madrid Protocol international registration numbers, e.g. `0870749`.

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

Restrict results to live (active) or dead (abandoned/cancelled/expired) trademark filings.

## `internationalClass` (type: `string`):

Restrict results to a single Nice Classification international class.

## `markType` (type: `string`):

Restrict results to a specific mark type.

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

Hard cap on emitted records.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy (free AUTO datacenter group). The USPTO search API is public and does not require proxy, but this can help if datacenter IPs get rate-limited.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "apple",
  "serialNumbers": [],
  "registrationNumbers": [],
  "proceedingNumbers": [],
  "internationalRegistrationNumbers": [],
  "status": "any",
  "internationalClass": "any",
  "markType": "any",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `trademarks` (type: `string`):

Dataset containing all scraped USPTO trademark 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 = {
    "mode": "search",
    "searchQuery": "apple",
    "serialNumbers": [],
    "registrationNumbers": [],
    "proceedingNumbers": [],
    "internationalRegistrationNumbers": [],
    "status": "any",
    "internationalClass": "any",
    "markType": "any",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "mode": "search",
    "searchQuery": "apple",
    "serialNumbers": [],
    "registrationNumbers": [],
    "proceedingNumbers": [],
    "internationalRegistrationNumbers": [],
    "status": "any",
    "internationalClass": "any",
    "markType": "any",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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 '{
  "mode": "search",
  "searchQuery": "apple",
  "serialNumbers": [],
  "registrationNumbers": [],
  "proceedingNumbers": [],
  "internationalRegistrationNumbers": [],
  "status": "any",
  "internationalClass": "any",
  "markType": "any",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/uspto-trademark-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/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 official US trademark registrations from the USPTO Trademark Search system (tmsearch.uspto.gov). Search by wordmark, owner name, goods/services, serial number, or registration number. Filter by live/dead status and Nice international class (1-45).",
        "version": "1.0",
        "x-build-id": "l5dEtG2urvaKIBGA0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~uspto-trademark-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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/crawlerbros~uspto-trademark-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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/crawlerbros~uspto-trademark-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "bySerialNumber",
                            "byRegistrationNumber",
                            "byOwner",
                            "byGoodsServices",
                            "byProceedingNumber",
                            "byInternationalRegistrationNumber"
                        ],
                        "type": "string",
                        "description": "What to search.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Mark / keyword",
                        "type": "string",
                        "description": "Free-text trademark/wordmark query (mode=search), e.g. `apple` or `nike air`.",
                        "default": "apple"
                    },
                    "serialNumbers": {
                        "title": "Serial numbers (mode=bySerialNumber)",
                        "type": "array",
                        "description": "USPTO application serial numbers, e.g. `74683130`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "registrationNumbers": {
                        "title": "Registration numbers (mode=byRegistrationNumber)",
                        "type": "array",
                        "description": "USPTO registration numbers, e.g. `2005764`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "ownerName": {
                        "title": "Owner / applicant name (mode=byOwner)",
                        "type": "string",
                        "description": "Free-text owner/applicant name query, e.g. `nike inc`."
                    },
                    "goodsAndServicesQuery": {
                        "title": "Goods & services keyword (mode=byGoodsServices)",
                        "type": "string",
                        "description": "Free-text keyword to search within the goods & services description, e.g. `coffee`."
                    },
                    "proceedingNumbers": {
                        "title": "TTAB proceeding numbers (mode=byProceedingNumber)",
                        "type": "array",
                        "description": "USPTO Trademark Trial and Appeal Board proceeding numbers (opposition/cancellation), e.g. `91177505`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "internationalRegistrationNumbers": {
                        "title": "Madrid international registration numbers (mode=byInternationalRegistrationNumber)",
                        "type": "array",
                        "description": "WIPO Madrid Protocol international registration numbers, e.g. `0870749`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "status": {
                        "title": "Status filter",
                        "enum": [
                            "any",
                            "live",
                            "dead"
                        ],
                        "type": "string",
                        "description": "Restrict results to live (active) or dead (abandoned/cancelled/expired) trademark filings.",
                        "default": "any"
                    },
                    "internationalClass": {
                        "title": "International (Nice) class filter",
                        "enum": [
                            "any",
                            "001",
                            "002",
                            "003",
                            "004",
                            "005",
                            "006",
                            "007",
                            "008",
                            "009",
                            "010",
                            "011",
                            "012",
                            "013",
                            "014",
                            "015",
                            "016",
                            "017",
                            "018",
                            "019",
                            "020",
                            "021",
                            "022",
                            "023",
                            "024",
                            "025",
                            "026",
                            "027",
                            "028",
                            "029",
                            "030",
                            "031",
                            "032",
                            "033",
                            "034",
                            "035",
                            "036",
                            "037",
                            "038",
                            "039",
                            "040",
                            "041",
                            "042",
                            "043",
                            "044",
                            "045",
                            "A",
                            "B",
                            "200"
                        ],
                        "type": "string",
                        "description": "Restrict results to a single Nice Classification international class.",
                        "default": "any"
                    },
                    "markType": {
                        "title": "Mark type filter",
                        "enum": [
                            "any",
                            "TRADEMARK",
                            "SERVICE MARK",
                            "COLLECTIVE MARK",
                            "COLLECTIVE MEMBERSHIP MARK",
                            "CERTIFICATION MARK"
                        ],
                        "type": "string",
                        "description": "Restrict results to a specific mark type.",
                        "default": "any"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy (free AUTO datacenter group). The USPTO search API is public and does not require proxy, but this can help if datacenter IPs get rate-limited.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
