# Whatnot Seller Rankings Scraper (`automation-lab/whatnot-seller-rankings-scraper`) Actor

🏆 Export public 30-day Whatnot seller rankings with revenue, sales, streams, viewers, categories, profile links, report totals, and freshness metadata.

- **URL**: https://apify.com/automation-lab/whatnot-seller-rankings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Whatnot Seller Rankings Scraper

Export the public 30-day Whatnot seller leaderboard as clean, analysis-ready data.

Track which sellers lead by observed revenue, compare sales and streaming activity, discover category leaders, and build repeatable competitor-monitoring workflows without copying a table by hand.

The Actor reads Resellbot's public market report and returns one normalized record per seller.

Each record includes the seller's rank, handle, Whatnot profile URL, observed revenue and sales, stream count, average viewers, primary category, report totals, and freshness dates.

### What does Whatnot Seller Rankings Scraper do?

Whatnot Seller Rankings Scraper converts a public 30-day leaderboard into a structured Apify dataset.

It can:

- 🏆 export up to 75 ranked Whatnot sellers;
- 💵 filter sellers by minimum observed revenue;
- 🎯 focus on one or more primary categories;
- 👤 look up exact seller handles from the ranking;
- 🔗 preserve clickable Whatnot profile URLs;
- 📅 report the source period and last update time;
- 📊 include marketplace-wide observed totals on every row.

Results can be downloaded as JSON, CSV, Excel, XML, or accessed through the Apify API.

### Who is it for?

#### Whatnot sellers and resellers

Benchmark your store against leaders with similar inventory.

Compare sales volume, stream frequency, viewers, and observed revenue instead of relying only on follower counts.

#### Brands and agencies

Build a focused list of visible sellers for partnerships, sponsorship research, or creator outreach.

Use category and revenue filters to keep the list relevant.

#### Live-commerce analysts

Capture a dated snapshot on a daily or weekly schedule.

Track changes in rank and reported performance in your warehouse or dashboard.

#### Marketplace operators and investors

Measure category concentration and identify high-throughput or high-value seller strategies from a consistent public report.

### Why use this Whatnot seller scraper?

- ⚡ **Fast HTTP extraction** — no browser is launched.
- 🔓 **No login required** — the source report is publicly accessible.
- 🧹 **Normalized numbers** — revenue, sales, streams, rank, and viewers are numeric.
- 🗓️ **Freshness included** — every row identifies the reporting window and source update.
- 🔁 **Schedule friendly** — run it daily or weekly in Apify.
- 🔌 **Integration ready** — connect datasets to Sheets, webhooks, Make, Zapier, or your own API client.
- 🛡️ **Structural checks** — the run fails loudly if expected report structures disappear.

### What Whatnot seller data can I extract?

| Field | Type | Meaning |
|---|---:|---|
| `rank` | number | Revenue position in the public report |
| `sellerHandle` | string | Whatnot seller handle |
| `whatnotProfileUrl` | URL | Public Whatnot profile link |
| `observedRevenue` | number | Revenue observed during the report period |
| `currency` | string | Revenue currency, currently USD |
| `observedSales` | number | Sales observed during the period |
| `streams` | number | Streams observed during the period |
| `averageViewers` | number | Average viewers reported for the seller |
| `primaryCategory` | string | Seller's primary category in the report |
| `reportObservedSales` | number | All observed report sales |
| `reportObservedRevenue` | number | All observed report revenue |
| `reportStreamsTracked` | number | All streams tracked by the report |
| `reportPeriodStart` | date | Beginning of the report window |
| `reportPeriodEnd` | date | End of the report window |
| `dataUpdatedAt` | datetime | Source report update time |
| `latestSaleDate` | date | Latest sale date represented by the report |
| `sourceUrl` | URL | Public leaderboard source |
| `scrapedAt` | datetime | Time this Actor fetched the report |

Observed metrics are estimates published by the source, not seller-provided accounting statements.

### How to scrape Whatnot seller rankings

1. Open **Whatnot Seller Rankings Scraper** in Apify Console.
2. Set **Maximum sellers** from 1 to 75.
3. Optionally add a minimum observed revenue.
4. Optionally enter exact primary categories or seller handles.
5. Click **Start**.
6. Open the **Dataset** tab when the run succeeds.
7. Export the records or connect the dataset to your workflow.

The prefilled example requests only 10 sellers and normally completes well under two minutes.

### Input parameters

#### Maximum sellers

`maxSellers` controls how many matching leaderboard rows are returned.

The allowed range is 1–75.

The Actor keeps the source's revenue ranking order.

#### Minimum observed revenue

`minObservedRevenue` is an inclusive USD threshold.

Set `1000000` to return sellers with at least one million dollars in observed 30-day revenue.

#### Primary categories

`primaryCategories` accepts exact category labels, matched case-insensitively.

For example:

```json
["Sports Cards", "Women's Fashion"]
````

#### Seller handles

`sellerHandles` accepts exact Whatnot handles.

Both `sellername` and `@sellername` are accepted.

Filters combine with AND logic across filter types and OR logic within each list.

### Example input

```json
{
  "maxSellers": 50,
  "minObservedRevenue": 500000,
  "primaryCategories": ["Sports Cards"]
}
```

To monitor exact competitors:

```json
{
  "maxSellers": 75,
  "sellerHandles": ["@backyardbreaks", "wethehobby"]
}
```

A valid filter can return zero rows when no seller in the current top 75 matches it.

### Example output

```json
{
  "rank": 1,
  "sellerHandle": "backyardbreaks",
  "whatnotProfileUrl": "https://www.whatnot.com/user/backyardbreaks",
  "observedRevenue": 10908671,
  "currency": "USD",
  "observedSales": 14378,
  "streams": 140,
  "averageViewers": 119.63,
  "primaryCategory": "Sports Cards",
  "reportObservedSales": 50931075,
  "reportObservedRevenue": 946706471,
  "reportStreamsTracked": 1049551,
  "reportPeriodStart": "2026-06-18",
  "reportPeriodEnd": "2026-07-17",
  "dataUpdatedAt": "2026-07-18T10:30:41.645Z",
  "latestSaleDate": "2026-07-17",
  "sourceUrl": "https://resellbot.com/top-whatnot-sellers/",
  "scrapedAt": "2026-07-19T00:00:00.000Z"
}
```

Values change whenever the public source report updates.

### How much does it cost to scrape Whatnot seller rankings?

The Actor uses pay-per-event pricing.

A small start fee covers fetching and validating the report, followed by a per-seller charge for records actually saved.

The current start event is **$0.005**.

Per-seller pricing is tiered by Apify plan:

| Apify plan tier | Price per seller |
|---|---:|
| Free | $0.000030962 |
| Bronze | $0.000026924 |
| Silver | $0.000021001 |
| Gold | $0.000016154 |
| Platinum | $0.00001077 |
| Diamond | $0.00001 |

A 10-seller test is intentionally inexpensive.

A 75-seller full export remains bounded because the public report contains at most 75 ranked sellers.

You are not charged a seller event for rows excluded by your filters.

Check the Actor pricing tab for the authoritative current prices.

### Tips for better seller research

- 📆 Schedule the Actor at the same time each week for comparable snapshots.
- 🧭 Start broad, then inspect exact category labels before filtering.
- 💾 Append snapshots to a named dataset or external warehouse for history.
- 📈 Calculate revenue per stream and sales per stream downstream.
- 🔍 Use seller-handle filters for competitor watchlists.
- 🏷️ Treat primary category as source classification, not an exhaustive catalog.
- 🕒 Compare `dataUpdatedAt` before treating two runs as distinct report versions.

### Scheduling and monitoring

Use an Apify schedule to run the scraper daily or weekly.

A webhook can notify your system after each successful run.

For change monitoring, store the latest dataset and join records by `sellerHandle`.

Useful alerts include:

- rank moved by more than five places;
- observed revenue crossed a threshold;
- a watched seller entered or left the top 75;
- a category gained a new leading seller;
- the source update timestamp changed.

### Integrations

#### Google Sheets

Export a dataset as CSV or connect Apify to Google Sheets for a shared seller benchmark.

#### Make and Zapier

Trigger the Actor on a schedule, wait for completion, and route new rows into a CRM or notification channel.

#### Webhooks

Send run-completion events to your application, then fetch the dataset through its API URL.

#### Data warehouses

Load dated snapshots into BigQuery, Snowflake, PostgreSQL, or another warehouse.

Use `sellerHandle` plus `dataUpdatedAt` as a practical snapshot key.

#### BI dashboards

Visualize seller rank, category concentration, revenue per stream, or sales per stream in Looker Studio, Tableau, or Power BI.

### Use with the Apify API

Replace `APIFY_TOKEN` with your token.

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/whatnot-seller-rankings-scraper').call({
  maxSellers: 25,
  minObservedRevenue: 1000000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/whatnot-seller-rankings-scraper').call(
    run_input={'maxSellers': 25, 'primaryCategories': ['Sports Cards']}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~whatnot-seller-rankings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxSellers":25,"minObservedRevenue":1000000}'
```

Fetch dataset items after the run finishes:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use with Apify MCP

Connect the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/whatnot-seller-rankings-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/whatnot-seller-rankings-scraper"
    }
  }
}
```

Example prompts:

- “Export the top 25 Whatnot sellers and summarize categories.”
- “Find ranked Sports Cards sellers above $1 million observed revenue.”
- “Compare streams, sales, and revenue for these Whatnot handles.”
- “Create a CSV-ready weekly snapshot of the full seller leaderboard.”

### Data quality and methodology

The source describes its metrics as aggregated analysis of observed Whatnot marketplace activity.

The Actor preserves that language by naming fields `observedRevenue` and `observedSales`.

Revenue is not guaranteed gross merchandise value, payout, profit, or audited seller income.

Average viewers comes from the source's structured data and may contain decimals even when the visible table rounds it.

The Actor joins categories from the visible table to sellers in JSON-LD by normalized handle.

It verifies that every emitted seller has all required structured metrics and a category.

### Limitations

- The source currently exposes the first 75 revenue-ranked sellers.
- The Actor does not scrape arbitrary Whatnot profiles or listings.
- The Actor does not require or use private Whatnot Seller API access.
- Category labels reflect the source's primary-category assignment.
- Historical results must be collected by scheduling repeated runs.
- Source methodology and coverage can change independently of this Actor.
- Valid narrow filters may produce an empty dataset.

### Is it legal to scrape Whatnot seller rankings?

This Actor extracts a publicly available aggregate market report without login.

Public availability does not remove every legal or contractual obligation.

Use the data for lawful purposes, respect applicable terms and database rights, avoid harassment or spam, and comply with privacy and marketing rules in your jurisdiction.

Do not represent observed estimates as audited financial statements.

If you plan commercial redistribution, review the source's linked data license and obtain appropriate legal advice.

### Troubleshooting

#### Why did my run return no seller records?

Your category, handle, and revenue filters may not match any seller in the current top 75.

Remove filters, run a small broad export, and copy current category labels or handles from that dataset.

#### Why did the run fail instead of returning empty data?

A failure means the public report could not be fetched or its expected ranking structures changed.

Inspect the run log for the HTTP status or missing structural field.

Retry later if the source was temporarily unavailable.

If the source layout changed, report the failed run URL through the Actor's issue form.

#### Why does average viewers differ from the visible table?

The visible page rounds viewer values, while the structured data can preserve decimal precision.

The Actor returns the more precise structured value.

#### Why is a seller missing?

Only sellers present in the current public top-75 report can be returned.

The Actor is not a universal Whatnot user lookup tool.

### FAQ

#### Does this Actor need a proxy?

No proxy is expected for the current anonymous public report.

#### Does it log in to Whatnot?

No. It reads an aggregate public report and only preserves public Whatnot profile links.

#### Can I extract all Whatnot sellers?

No. The product scope is the public 30-day top-seller leaderboard.

#### Can I monitor rank changes?

Yes. Schedule repeated runs and compare snapshots by `sellerHandle` and `dataUpdatedAt`.

#### Are numeric fields returned as strings?

No. Rank, revenue, sales, streams, viewers, and report totals are numbers.

#### Can I export CSV or Excel?

Yes. Use the Dataset export menu or Apify dataset API formats.

#### How fresh is the data?

Check `dataUpdatedAt`, `latestSaleDate`, `reportPeriodStart`, and `reportPeriodEnd` in every record.

### Related scrapers

Combine this Actor with other Automation Lab tools when you need broader commerce research:

- [TikTok Shop Scraper](https://apify.com/automation-lab/tiktok-shop-scraper) for social-commerce product research.
- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) for marketplace listing and price research.
- [Amazon Product Scraper](https://apify.com/automation-lab/amazon-product-scraper) for retail catalog analysis.
- [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) for creator and video research.

Choose this Actor when your question is specifically about the public Whatnot seller revenue ranking.

### Support

If a run fails unexpectedly, open an issue from the Actor page and include:

- the run URL;
- your input;
- the expected seller or category;
- whether the source report was accessible in your browser;
- the approximate time of the failure.

That evidence makes source changes and transient failures much faster to diagnose.

# Actor input Schema

## `maxSellers` (type: `integer`):

Return at most this many qualifying sellers, ordered by observed revenue rank.

## `minObservedRevenue` (type: `number`):

Only return sellers whose observed 30-day revenue is at least this amount.

## `primaryCategories` (type: `array`):

Match category names exactly, case-insensitively; for example Sports Cards.

## `sellerHandles` (type: `array`):

Return only these Whatnot handles. Leading @ signs are accepted.

## Actor input object example

```json
{
  "maxSellers": 10,
  "minObservedRevenue": 0,
  "primaryCategories": [],
  "sellerHandles": []
}
```

# 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 = {
    "maxSellers": 10,
    "minObservedRevenue": 0,
    "primaryCategories": [],
    "sellerHandles": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/whatnot-seller-rankings-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 = {
    "maxSellers": 10,
    "minObservedRevenue": 0,
    "primaryCategories": [],
    "sellerHandles": [],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/whatnot-seller-rankings-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 '{
  "maxSellers": 10,
  "minObservedRevenue": 0,
  "primaryCategories": [],
  "sellerHandles": []
}' |
apify call automation-lab/whatnot-seller-rankings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whatnot Seller Rankings Scraper",
        "description": "🏆 Export public 30-day Whatnot seller rankings with revenue, sales, streams, viewers, categories, profile links, report totals, and freshness metadata.",
        "version": "0.1",
        "x-build-id": "feVPXuAjnOlgr31cK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~whatnot-seller-rankings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-whatnot-seller-rankings-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~whatnot-seller-rankings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-whatnot-seller-rankings-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~whatnot-seller-rankings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-whatnot-seller-rankings-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": {
                    "maxSellers": {
                        "title": "Maximum sellers",
                        "minimum": 1,
                        "maximum": 75,
                        "type": "integer",
                        "description": "Return at most this many qualifying sellers, ordered by observed revenue rank.",
                        "default": 25
                    },
                    "minObservedRevenue": {
                        "title": "Minimum observed revenue (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only return sellers whose observed 30-day revenue is at least this amount.",
                        "default": 0
                    },
                    "primaryCategories": {
                        "title": "Primary categories",
                        "type": "array",
                        "description": "Match category names exactly, case-insensitively; for example Sports Cards.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerHandles": {
                        "title": "Seller handles",
                        "type": "array",
                        "description": "Return only these Whatnot handles. Leading @ signs are accepted.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
