# eBay Sold Items & Auction Scraper — Prices, Bids, Sellers (`dr1ms/ebay-sold-auction-intelligence`) Actor

Extract eBay SOLD/completed listings the official Browse API does not expose: real sold price, sold date, bid count, listing format and seller reputation. Built for resellers and arbitrage. Multi-marketplace (.com/.fr/.de/.co.uk/.it/.es).

- **URL**: https://apify.com/dr1ms/ebay-sold-auction-intelligence.md
- **Developed by:** [Adrien](https://apify.com/dr1ms) (community)
- **Categories:** Lead generation, E-commerce, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## eBay Sold Items & Auction Scraper — Real Sold Prices, Bids, Sold Date, Seller Rep

Get the data eBay's official API **won't** give you: **real sold/completed prices**, **sold dates**, **bid counts**, **listing format**, and **seller reputation** — the exact signals resellers and arbitrage sellers need. Multi-marketplace (US, UK, FR, DE, IT, ES), fast, and resilient to eBay's anti-bot throttling.

> The official eBay Browse API only returns **active** listings. It does **not** expose what an item actually **sold** for. This scraper does — that is the whole point.

---

### Why this actor

- 💰 **Real sold prices** — what items *actually* sold for, not asking prices.
- 📅 **Sold date** — when each sale closed (eBay shows ~last 90 days of sold history).
- 🔨 **Bid counts** — auction demand signal, unavailable from the official API.
- ⭐ **Seller reputation** — username, positive-feedback %, and rating count, so you can weight a sale by who made it.
- 🏷️ **Listing format** — auction / Buy It Now / Best Offer / auction+BIN.
- 🌍 **Multi-marketplace** — `.com`, `.co.uk`, `.fr`, `.de`, `.it`, `.es` with correct currency and date parsing per site (price arbitrage across regions).
- 🧱 **Built for the current eBay markup** — many older eBay sold scrapers broke when eBay migrated from `li.s-item` to `.su-card-container`. This one targets the new markup and warns loudly if eBay changes it again.
- 🤖 **Agent-friendly** — flat, structured JSON output with a clean schema, callable by AI agents.

---

### Use cases

- **Resale & arbitrage** — find the true market clearing price before you buy to resell.
- **Sourcing decisions** — combine sold price × bids × sell-through to spot demand.
- **Repricing** — keep your Buy It Now prices aligned with what's actually selling.
- **Market research** — track price trends for a product or category over the sold window.
- **Cross-border arbitrage** — compare the same item's sold price on `.com` vs `.fr`/`.de`.

---

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` *(required)* | string[] | — | Keywords to search, one scrape per query. |
| `marketplace` | enum | `www.ebay.com` | eBay site: `.com / .co.uk / .fr / .de / .it / .es`. |
| `proxyCountryCode` | string | derived | Residential proxy country (e.g. `US`, `FR`). Defaults from the marketplace. |
| `maxItemsPerQuery` | int | `500` | Hard cap on unique items per query (cost guardrail). |
| `maxPagesPerQuery` | int | `10` | Max result pages to paginate per query. |
| `itemsPerPage` | enum | `240` | Results per page (`60`/`120`/`240`). |
| `format` | enum | `all` | `all` / `auction` / `buy_it_now`. |
| `priceMin` / `priceMax` | number | — | Price range filter. |
| `categoryId` | string | — | Restrict to an eBay category id. |
| `sortOrder` | string | — | eBay sort code (`_sop`), e.g. `12` = newly listed. |
| `fetchItemDetails` | bool | `false` | Also open each item page for specifics/location/qty (slower, costs more). |
| `maxConcurrency` | int | `5` | Simultaneous fetches (each on a fresh residential IP). |
| `maxRetriesPerPage` | int | `8` | Fresh IPs to try before giving up on a page. eBay throttles per IP, so a blocked page usually succeeds on a later IP. Higher = fewer lost pages, more IPs used. |
| `proxyConfiguration` | object | RESIDENTIAL | **Residential proxy is required** (see below). |

#### Example input

```json
{
  "searchQueries": ["nintendo switch oled", "pokemon booster box"],
  "marketplace": "www.ebay.com",
  "maxItemsPerQuery": 500,
  "maxPagesPerQuery": 10,
  "itemsPerPage": 240,
  "format": "all",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

***

### Output

One record per sold listing. Example:

```json
{
  "item_id": "327182193885",
  "title": "Nintendo Switch OLED",
  "sold_price": 149.27,
  "currency": "USD",
  "price_is_masked": false,
  "sold_date": "2026-06-03",
  "condition": "Pre-Owned",
  "listing_format": "auction",
  "bids": 19,
  "shipping": "+$82.00 delivery Jun 17 - Jun 22",
  "seller_name": "salesmanmike11",
  "seller_feedback_pct": 100.0,
  "seller_feedback_count": 334,
  "item_url": "https://www.ebay.com/itm/327182193885",
  "image_url": "https://i.ebayimg.com/images/g/51oAAeSw7IlqF7u5/s-l500.webp",
  "marketplace": "www.ebay.com",
  "query": "nintendo switch oled",
  "scraped_at": "2026-06-04T12:00:00+00:00"
}
```

#### Field reference

| Field | Type | Notes |
|---|---|---|
| `item_id` | string | eBay item id (used for deduplication). |
| `title` | string | Listing title. |
| `sold_price` | number | null | Final sale price. `null` when masked (see below). |
| `currency` | string | `USD` / `GBP` / `EUR` … |
| `price_is_masked` | bool | `true` when eBay hid the real price (accepted Best Offer); `sold_price` is then `null` — we never fabricate a price. |
| `sold_date` | string (ISO) | `YYYY-MM-DD`. |
| `condition` | string | null | `Brand New` / `Pre-Owned` / `Open Box` / `Parts Only` … |
| `listing_format` | string | `auction` / `buy_it_now` / `best_offer` / `auction_bin` / `unknown`. |
| `bids` | int | null | Auction bid count; `null` on pure Buy It Now. |
| `shipping` | string | null | Shipping/delivery text. |
| `seller_name` | string | null | Seller username. |
| `seller_feedback_pct` | number | null | e.g. `99.7`. |
| `seller_feedback_count` | int | null | Rating count (K/M expanded, e.g. `12.1K` → `12100`). |
| `item_url` | string | Canonical item URL, tracking params stripped. |
| `image_url` | string | null | Thumbnail. |
| `marketplace`, `query`, `scraped_at` | — | Provenance. |

When `fetchItemDetails` is enabled, items also include `item_specifics` (brand/model/…), `seller_location`, `quantity_sold`, and `returns`.

***

### Proxy & reliability (please read)

eBay throttles aggressively by IP: a single IP typically serves only ~1 useful sold-search request before eBay returns blocks that don't clear with waiting. **This actor requires Apify Residential proxy with per-request rotation** — it uses a fresh IP for every request and retries blocked pages on new IPs. Datacenter or single-IP proxies will fail.

The actor prints **cost telemetry** at the end of every run (IPs consumed, IP/page ratio, MB transferred, items, estimated $/1000) so you can see exactly what a run costs.

***

### Pricing model

This actor is intended to run **pay-per-result**: you pay per sold item returned. Residential proxy is the main underlying cost; the per-run telemetry makes that cost transparent.

***

### Running locally (for developers)

```bash
## from the actor root
pip install -r requirements.txt
pip install apify-cli            ## or: npm i -g apify-cli

apify run                        ## uses .actor/input_schema.json prefill as input
```

Local runs that hit Apify Proxy need an `APIFY_TOKEN` in your environment (run `apify login` once). Without residential proxy, expect eBay to block after the first request — that is eBay's throttle, not a bug.

The repo also ships offline tests that validate parsing/orchestration against a captured eBay sample without any network or proxy:

```bash
python -m tests_local.test_units            ## locale, URL building, block classification
python -m tests_local.validate_parser       ## parser vs. real captured HTML (field coverage)
python -m tests_local.test_main_integration ## full pagination/dedup/telemetry flow (mocked Actor)
```

***

### Notes on data & compliance

This actor collects **publicly visible** eBay search-results data. It is **not affiliated with, endorsed by, or operated by eBay Inc.** "eBay" is a trademark of its respective owner. You are responsible for using the output in accordance with eBay's terms and applicable law in your jurisdiction. Use it for legitimate market research, pricing, and resale-sourcing purposes.

***

### Keywords

eBay sold items scraper, eBay sold prices API, eBay completed listings, eBay sold listings data, eBay auction bids scraper, eBay seller feedback scraper, eBay price history, eBay reseller tool, eBay arbitrage, eBay market research, sold comps, eBay product research.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search eBay sold/completed listings for. One scrape per query. Example: \['nintendo switch oled', 'pokemon booster box'].

## `marketplace` (type: `string`):

eBay site to scrape. Currency and date format follow the marketplace automatically.

## `proxyCountryCode` (type: `string`):

Two-letter residential proxy country (e.g. US, FR, DE, GB). Leave empty to derive from the marketplace (.com→US, .fr→FR, …). Scraping a marketplace from its own country reduces blocks.

## `maxItemsPerQuery` (type: `integer`):

Hard cap on unique sold items collected per query. Primary cost guardrail (residential proxy is billed per GB).

## `maxPagesPerQuery` (type: `integer`):

Maximum search-result pages to paginate per query. eBay limits sold history to roughly the last 90 days.

## `itemsPerPage` (type: `integer`):

eBay results per page (\_ipg). Use 60, 120, or 240 — 240 maximizes items per request (fewer IPs consumed, recommended).

## `format` (type: `string`):

Filter by sale format. 'all' = every sold listing; 'auction' = LH\_Auction=1; 'buy\_it\_now' = LH\_BIN=1.

## `priceMin` (type: `integer`):

Lower price bound (\_udlo), in the marketplace currency. Optional.

## `priceMax` (type: `integer`):

Upper price bound (\_udhi), in the marketplace currency. Optional.

## `categoryId` (type: `string`):

Restrict the search to an eBay category (\_sacat). Optional.

## `sortOrder` (type: `string`):

eBay sort code (\_sop). Common values: 13 = Best Match, 12 = Newly listed, 10 = Ending soonest, 15 = Price+shipping highest, 16 = Price+shipping lowest. Optional.

## `fetchItemDetails` (type: `boolean`):

Also open each item's /itm/ page to add item specifics (brand/model), seller location, quantity sold and returns policy. Multiplies proxy cost — opt-in.

## `maxConcurrency` (type: `integer`):

Max simultaneous page fetches. Each fetch uses its own fresh residential IP. Keep modest to stay polite and control cost.

## `maxRetriesPerPage` (type: `integer`):

How many fresh residential IPs to try before giving up on a page. eBay throttles per IP, so a blocked page usually succeeds on a later fresh IP. Higher = fewer lost pages but more IPs consumed. 8 is a good balance.

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

Apify Proxy settings. RESIDENTIAL with per-request rotation is REQUIRED — eBay throttles datacenter and single IPs. Defaults are correct; change only if you know what you are doing.

## Actor input object example

```json
{
  "searchQueries": [
    "nintendo switch oled"
  ],
  "marketplace": "www.ebay.com",
  "maxItemsPerQuery": 500,
  "maxPagesPerQuery": 10,
  "itemsPerPage": 240,
  "format": "all",
  "fetchItemDetails": false,
  "maxConcurrency": 5,
  "maxRetriesPerPage": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchQueries": [
        "nintendo switch oled"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dr1ms/ebay-sold-auction-intelligence").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 = { "searchQueries": ["nintendo switch oled"] }

# Run the Actor and wait for it to finish
run = client.actor("dr1ms/ebay-sold-auction-intelligence").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 '{
  "searchQueries": [
    "nintendo switch oled"
  ]
}' |
apify call dr1ms/ebay-sold-auction-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dr1ms/ebay-sold-auction-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Sold Items & Auction Scraper — Prices, Bids, Sellers",
        "description": "Extract eBay SOLD/completed listings the official Browse API does not expose: real sold price, sold date, bid count, listing format and seller reputation. Built for resellers and arbitrage. Multi-marketplace (.com/.fr/.de/.co.uk/.it/.es).",
        "version": "1.0",
        "x-build-id": "NClsKmdwd8dTuP09X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dr1ms~ebay-sold-auction-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dr1ms-ebay-sold-auction-intelligence",
                "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/dr1ms~ebay-sold-auction-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-dr1ms-ebay-sold-auction-intelligence",
                "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/dr1ms~ebay-sold-auction-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-dr1ms-ebay-sold-auction-intelligence",
                "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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "minItems": 1,
                        "type": "array",
                        "description": "Keywords to search eBay sold/completed listings for. One scrape per query. Example: ['nintendo switch oled', 'pokemon booster box'].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "marketplace": {
                        "title": "Marketplace",
                        "enum": [
                            "www.ebay.com",
                            "www.ebay.co.uk",
                            "www.ebay.fr",
                            "www.ebay.de",
                            "www.ebay.it",
                            "www.ebay.es"
                        ],
                        "type": "string",
                        "description": "eBay site to scrape. Currency and date format follow the marketplace automatically.",
                        "default": "www.ebay.com"
                    },
                    "proxyCountryCode": {
                        "title": "Proxy country code",
                        "type": "string",
                        "description": "Two-letter residential proxy country (e.g. US, FR, DE, GB). Leave empty to derive from the marketplace (.com→US, .fr→FR, …). Scraping a marketplace from its own country reduces blocks."
                    },
                    "maxItemsPerQuery": {
                        "title": "Max items per query",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on unique sold items collected per query. Primary cost guardrail (residential proxy is billed per GB).",
                        "default": 500
                    },
                    "maxPagesPerQuery": {
                        "title": "Max pages per query",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum search-result pages to paginate per query. eBay limits sold history to roughly the last 90 days.",
                        "default": 10
                    },
                    "itemsPerPage": {
                        "title": "Items per page",
                        "minimum": 60,
                        "maximum": 240,
                        "type": "integer",
                        "description": "eBay results per page (_ipg). Use 60, 120, or 240 — 240 maximizes items per request (fewer IPs consumed, recommended).",
                        "default": 240
                    },
                    "format": {
                        "title": "Listing format",
                        "enum": [
                            "all",
                            "auction",
                            "buy_it_now"
                        ],
                        "type": "string",
                        "description": "Filter by sale format. 'all' = every sold listing; 'auction' = LH_Auction=1; 'buy_it_now' = LH_BIN=1.",
                        "default": "all"
                    },
                    "priceMin": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower price bound (_udlo), in the marketplace currency. Optional."
                    },
                    "priceMax": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper price bound (_udhi), in the marketplace currency. Optional."
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Restrict the search to an eBay category (_sacat). Optional."
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "type": "string",
                        "description": "eBay sort code (_sop). Common values: 13 = Best Match, 12 = Newly listed, 10 = Ending soonest, 15 = Price+shipping highest, 16 = Price+shipping lowest. Optional."
                    },
                    "fetchItemDetails": {
                        "title": "Fetch item details (slower, more expensive)",
                        "type": "boolean",
                        "description": "Also open each item's /itm/ page to add item specifics (brand/model), seller location, quantity sold and returns policy. Multiplies proxy cost — opt-in.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Max simultaneous page fetches. Each fetch uses its own fresh residential IP. Keep modest to stay polite and control cost.",
                        "default": 5
                    },
                    "maxRetriesPerPage": {
                        "title": "Max retries per page",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many fresh residential IPs to try before giving up on a page. eBay throttles per IP, so a blocked page usually succeeds on a later fresh IP. Higher = fewer lost pages but more IPs consumed. 8 is a good balance.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. RESIDENTIAL with per-request rotation is REQUIRED — eBay throttles datacenter and single IPs. Defaults are correct; change only if you know what you are doing.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
