# eBay Sold Listings Scraper — Completed Sales & Sold Prices (`crawloop/ebay-sold-listings-scraper`) Actor

Scrape eBay sold listings and completed sale prices by keyword. Export sold date, condition, shipping, seller feedback across 20+ regional sites. Fast curl\_cffi scraper — no browser, residential proxy ready.

- **URL**: https://apify.com/crawloop/ebay-sold-listings-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.50 / 1,000 sold listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Listings Scraper — Completed Sales & Sold Prices

> **Disclaimer:** This is an unofficial integration developed independently. It is not affiliated with, sponsored by, or endorsed by eBay Inc. or any of its subsidiaries.
>
> **eBay** and related names are trademarks of eBay Inc. Data is read from publicly accessible search results for completed (sold) listings only. No eBay account login or private seller APIs are used.
>
> This Actor is provided **for informational and research purposes only** (e.g. market pricing, resale valuation, competitor analysis). You are solely responsible for complying with applicable laws, eBay's terms of use, and your organization's policies.

Extract **real completed eBay transactions** — not active listings. Search by keyword across **20+ regional marketplaces** (`ebay.com`, `ebay.co.uk`, `ebay.de`, `ebay.fr`, and more), filter by sold date range, condition, listing type, and price, then export **sold price**, **end date**, **shipping**, and **seller feedback** as clean JSON. Built for **resale arbitrage**, **dynamic pricing**, **inventory valuation**, and **competitor monitoring**.

**Best for:** eBay sold price research, completed sales history, sneaker/card/tech comps, and bulk export to Google Sheets, Airtable, or your own database via Apify integrations.

### When to use this Actor

- **eBay sold price lookup** — See what items actually sold for in the last 1–90 days, not asking prices.
- **Resale & arbitrage research** — Compare completed sales for sneakers, GPUs, collectibles, vintage goods, and consumer electronics.
- **Competitive pricing** — Build sold-price datasets per keyword, category, and marketplace to set your own list prices.
- **Seller intelligence** — Filter out high-volume business sellers, track feedback scores, and focus on organic C2C sales.
- **Multi-market analysis** — Run the same keyword on `ebay.com`, `ebay.de`, or `ebay.co.uk` in parallel with localized currency parsing.

### When not to use this Actor

- **Active / live listings** — This Actor targets **Sold + Completed** search results only, not current Buy It Now inventory.
- **Single product PDP deep scrape** — Use a dedicated eBay item scraper if you need full description HTML, item specifics, or all gallery images from one URL.
- **Official eBay API replacement** — We parse public search pages; for licensed API access, use eBay's developer program directly.

### Key Features

- **Completed sales only** — Filters sponsored cards and active listings; every row includes a sold/end date.
- **20+ eBay sites** — US, UK, DE, FR, IT, ES, CA, AU, PL, NL, and more with correct currency handling.
- **Triple layout fallback** — Supports `.s-item`, `.s-item-card`, and `.s-card` search result layouts automatically.
- **Lightweight & fast** — `curl_cffi` Chrome TLS impersonation, 128–256 MB RAM, no Puppeteer or Playwright.
- **Rich sold listing data** — Price, shipping, total, condition ID, listing type (auction / BIN / best offer), seller type.
- **Advanced filters** — Date window, min/max price, condition, auction vs Buy It Now, free shipping, seller blocklist.
- **Proxy-ready** — Works with Apify Residential Proxies (recommended) and datacenter proxies on EU domains.

### Input Parameters

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `keywords` | Array | *(Required)* | Search queries (e.g. `["iphone 15", "rtx 4080"]`). Each keyword runs in parallel. |
| `daysToScrape` | Integer | `30` | How many days back to include completed sales (1–90). |
| `count` | Integer | `100` | Max sold listings to collect **per keyword**. |
| `ebaySite` | String | `"ebay.com"` | Regional eBay domain (`ebay.de`, `ebay.co.uk`, `ebay.fr`, …). |
| `itemCondition` | String | `"any"` | `any`, `new`, `used`, or `refurbished`. |
| `listingType` | String | `"any"` | `any`, `auction`, or `buy_it_now`. |
| `freeShippingOnly` | Boolean | `false` | Keep only listings with free shipping. |
| `excludeSellers` | Array | `[]` | Seller usernames to skip (case-insensitive). |
| `categoryId` | String | `"0"` | eBay category ID (`0` = all categories). |
| `subcategoryId` | String | `""` | Optional subcategory; overrides `categoryId` when set. |
| `minPrice` / `maxPrice` | Number | — | Sold price range in the marketplace currency. |
| `itemLocation` | String | `"default"` | `default`, `domestic`, or `worldwide` seller location. |
| `sortOrder` | String | `"endedRecently"` | Sort sold results (ended recently, price low/high, etc.). |
| `proxyConfiguration` | Object | Residential | Apify Proxy settings; residential recommended for US/UK. |

#### Input Example

```json
{
  "keywords": ["nike air max", "rtx 4080"],
  "daysToScrape": 14,
  "count": 100,
  "ebaySite": "ebay.de",
  "itemCondition": "used",
  "listingType": "auction",
  "freeShippingOnly": false,
  "excludeSellers": ["mega_shop_de"],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "DE"
  }
}
````

### Output Format

Each dataset row = one **completed eBay sale** that passed your filters.

| Field | Type | Description |
| :--- | :--- | :--- |
| `itemId` | String | eBay listing ID. |
| `url` | String | Clean item URL (no tracking params). |
| `title` | String | Listing title. |
| `condition` | String | Localized condition (e.g. `Pre-owned`, `Gebraucht`). |
| `conditionId` | Integer | Normalized code (`1000` New, `3000` Used, `7000` For parts). |
| `endedAt` | String | Sale end time (UTC ISO 8601). |
| `soldPrice` | String | Final sold price. |
| `soldCurrency` | String | USD, EUR, GBP, PLN, etc. |
| `listingType` | String | `buy_it_now`, `auction`, or `best_offer_accepted`. |
| `isBestOfferAccepted` | Boolean | Best Offer accepted flag. |
| `shippingPrice` | String | Shipping cost (`0.00` = free). |
| `shippingType` | String | `free`, `paid`, `pickup`, or `unknown`. |
| `totalPrice` | String | Sold price + shipping (same currency). |
| `sellerUsername` | String | Seller account name. |
| `sellerPositivePercent` | Number | Positive feedback %. |
| `sellerFeedbackScore` | Integer | Total feedback count. |
| `sellerType` | String | `business` or `private` when shown. |
| `keyword` | String | Keyword that found this sale. |
| `scrapedAt` | String | Extraction timestamp (UTC). |

#### Output Example

```json
{
  "itemId": "377309614758",
  "url": "https://www.ebay.de/itm/377309614758",
  "title": "ASUS TUF Gaming GeForce RTX 3080 OC 10GB GDDR6 - FAULTY",
  "condition": "Nur Ersatzteile / defekt",
  "conditionId": 7000,
  "endedAt": "2026-07-02T12:00:00.000Z",
  "soldPrice": "163.34",
  "soldCurrency": "EUR",
  "listingType": "auction",
  "isBestOfferAccepted": false,
  "shippingPrice": "15.99",
  "shippingType": "paid",
  "totalPrice": "179.33",
  "sellerUsername": "basspares",
  "sellerPositivePercent": 100,
  "sellerFeedbackScore": 907,
  "sellerType": "business",
  "keyword": "rtx 3080",
  "scrapedAt": "2026-07-02T12:52:34.598Z"
}
```

*Note: When Best Offer is accepted, eBay often hides the negotiated price — the Actor flags `isBestOfferAccepted: true` and records the displayed asking price.*

### Use Cases

| Use Case | What you get |
| :--- | :--- |
| **Sold comps for resale** | Historical sold prices for flips, thrift finds, and liquidation buys |
| **Market pricing** | 30/60/90-day sold price bands per SKU or keyword |
| **Category research** | Sold data narrowed by `categoryId` and condition filters |
| **Cross-border pricing** | Same keyword on `.com` vs `.de` with local currency |
| **Seller filtering** | Exclude dropshippers and bulk dealers via `excludeSellers` |

### FAQ

#### How is this different from a regular eBay scraper?

Regular eBay scrapers return **active** listings with current ask prices. This Actor searches eBay's **Sold + Completed** filter, so every row reflects a transaction that already ended — ideal for true market value and sold comps.

#### Which eBay sites are supported?

`ebay.com`, `ebay.co.uk`, `ebay.de`, `ebay.fr`, `ebay.it`, `ebay.es`, `ebay.ca`, `ebay.com.au`, `ebay.at`, `ebay.ch`, `ebay.ie`, `ebay.pl`, `ebay.nl`, `ebay.be`, `ebay.com.sg`, `ebay.com.my`, `ebay.ph`, and `ebay.com.hk`.

#### Do I need proxies?

Residential proxies are **recommended** for US and UK marketplaces to reduce bot challenges. European domains often work with datacenter proxies. The Actor defaults to geo-targeted Apify Residential Proxy per marketplace.

#### Can I scrape multiple keywords at once?

Yes. Pass an array in `keywords` — each query runs in parallel with the same filters and its own `count` limit.

#### How far back can I scrape sold history?

Set `daysToScrape` from 1 to 90. Results older than your window are skipped; with `endedRecently` sort, pagination stops after five consecutive out-of-range items.

#### Does it export to JSON / CSV / API?

Yes. Results land in the Apify dataset. Download JSON, CSV, or Excel from the run, or connect webhooks and integrations (Google Sheets, BigQuery, etc.).

# Actor input Schema

## `keywords` (type: `array`):

One or more eBay search keywords for sold/completed listings. Each keyword runs as a separate parallel search with the same filters.

## `daysToScrape` (type: `integer`):

Include completed eBay sales from the last N days (1–90). Older sold listings are filtered out.

## `count` (type: `integer`):

Maximum number of completed (sold) listings to collect for each keyword.

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

eBay category filter (use '0' for all categories).

## `subcategoryId` (type: `string`):

Optional subcategory filter. If set, overrides the main Category field.

## `ebaySite` (type: `string`):

Regional eBay domain for sold listing search — e.g. ebay.com (US), ebay.co.uk, ebay.de, ebay.fr.

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

Sort order for search results.

## `minPrice` (type: `number`):

Minimum sold price filter (in site currency).

## `maxPrice` (type: `number`):

Maximum sold price filter (in site currency).

## `itemLocation` (type: `string`):

Search items based on seller's location.

## `itemCondition` (type: `string`):

Filter by item condition.

## `listingType` (type: `string`):

Filter by buy-it-now or auction format.

## `freeShippingOnly` (type: `boolean`):

Only return listings that offer free shipping.

## `excludeSellers` (type: `array`):

List of seller usernames to exclude from the results.

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

Select proxies to bypass eBay bot protection. Apify Residential Proxies recommended.

## Actor input object example

```json
{
  "keywords": [
    "rtx 4080"
  ],
  "daysToScrape": 30,
  "count": 100,
  "categoryId": "0",
  "subcategoryId": "",
  "ebaySite": "ebay.com",
  "sortOrder": "endedRecently",
  "itemLocation": "default",
  "itemCondition": "any",
  "listingType": "any",
  "freeShippingOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "keywords": [
        "rtx 4080"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/ebay-sold-listings-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 = {
    "keywords": ["rtx 4080"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/ebay-sold-listings-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 '{
  "keywords": [
    "rtx 4080"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call crawloop/ebay-sold-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Sold Listings Scraper — Completed Sales & Sold Prices",
        "description": "Scrape eBay sold listings and completed sale prices by keyword. Export sold date, condition, shipping, seller feedback across 20+ regional sites. Fast curl_cffi scraper — no browser, residential proxy ready.",
        "version": "0.4",
        "x-build-id": "Evty8xe2gkF4995bu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawloop~ebay-sold-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawloop-ebay-sold-listings-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/crawloop~ebay-sold-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawloop-ebay-sold-listings-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/crawloop~ebay-sold-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawloop-ebay-sold-listings-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "One or more eBay search keywords for sold/completed listings. Each keyword runs as a separate parallel search with the same filters.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "daysToScrape": {
                        "title": "Days to scrape sold history",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Include completed eBay sales from the last N days (1–90). Older sold listings are filtered out.",
                        "default": 30
                    },
                    "count": {
                        "title": "Max sold listings per keyword",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of completed (sold) listings to collect for each keyword.",
                        "default": 100
                    },
                    "categoryId": {
                        "title": "Category",
                        "type": "string",
                        "description": "eBay category filter (use '0' for all categories).",
                        "default": "0"
                    },
                    "subcategoryId": {
                        "title": "Subcategory ID (Optional)",
                        "type": "string",
                        "description": "Optional subcategory filter. If set, overrides the main Category field.",
                        "default": ""
                    },
                    "ebaySite": {
                        "title": "eBay marketplace (regional site)",
                        "enum": [
                            "ebay.com",
                            "ebay.co.uk",
                            "ebay.de",
                            "ebay.fr",
                            "ebay.it",
                            "ebay.es",
                            "ebay.ca",
                            "ebay.com.au",
                            "ebay.at",
                            "ebay.ch",
                            "ebay.ie",
                            "ebay.pl",
                            "ebay.nl",
                            "ebay.be",
                            "ebay.com.sg",
                            "ebay.com.my",
                            "ebay.ph",
                            "ebay.com.hk"
                        ],
                        "type": "string",
                        "description": "Regional eBay domain for sold listing search — e.g. ebay.com (US), ebay.co.uk, ebay.de, ebay.fr.",
                        "default": "ebay.com"
                    },
                    "sortOrder": {
                        "title": "Sort Order",
                        "enum": [
                            "endedRecently",
                            "timeNewlyListed",
                            "pricePlusPostageLowest",
                            "pricePlusPostageHighest",
                            "distanceNearest"
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "endedRecently"
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "type": "number",
                        "description": "Minimum sold price filter (in site currency)."
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "type": "number",
                        "description": "Maximum sold price filter (in site currency)."
                    },
                    "itemLocation": {
                        "title": "Item Location",
                        "enum": [
                            "default",
                            "domestic",
                            "worldwide"
                        ],
                        "type": "string",
                        "description": "Search items based on seller's location.",
                        "default": "default"
                    },
                    "itemCondition": {
                        "title": "Item Condition",
                        "enum": [
                            "any",
                            "new",
                            "used",
                            "refurbished"
                        ],
                        "type": "string",
                        "description": "Filter by item condition.",
                        "default": "any"
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "any",
                            "auction",
                            "buy_it_now"
                        ],
                        "type": "string",
                        "description": "Filter by buy-it-now or auction format.",
                        "default": "any"
                    },
                    "freeShippingOnly": {
                        "title": "Free Shipping Only",
                        "type": "boolean",
                        "description": "Only return listings that offer free shipping.",
                        "default": false
                    },
                    "excludeSellers": {
                        "title": "Exclude Sellers",
                        "type": "array",
                        "description": "List of seller usernames to exclude from the results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies to bypass eBay bot protection. Apify Residential Proxies recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
