# eBay Vehicles Scraper (`fmchisti/ebay-vehicles-scraper`) Actor

Scrape eBay Motors vehicle listings by keyword, search URL, or category page. Extract titles, prices, model year, mileage, condition, location, seller details, and more.

- **URL**: https://apify.com/fmchisti/ebay-vehicles-scraper.md
- **Developed by:** [Fahim Mahmud Chisti](https://apify.com/fmchisti) (community)
- **Categories:** Developer tools, Integrations, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/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

## eBay Vehicles Scraper

Scrape vehicle listings from eBay search, category, and filtered browse pages.

### How to use

1. Open the **Input** tab.
2. Add one or more eBay URLs under **Start URLs** — search pages, vehicle category/browse pages, or direct listing (`/itm/...`) URLs — or enter terms under **Search keywords**.
3. Set **Max items** and **Max pages per search**.
4. Optionally set **Only listings from the last (days)** to `10`, `30`, or another number.
5. Keep **Scrape item details** enabled to open each listing and extract full vehicle specifics.
6. Keep the default residential proxy configuration.
7. Click **Start**.
8. Open the run's **Dataset** tab to view or export the results.

For complex filters such as model year, condition, mileage, seller type, and sort order, configure the filters on eBay first and paste the resulting URL into **Start URLs**. The Actor requests that URL string exactly as pasted (no rewrite of encoding, filters, sort, page, or page size).

### Input options

- **Start URLs** — eBay search, vehicle category/browse, or direct listing URLs.
- **Search keywords** — terms used to create Cars & Trucks (Motors category) searches on the selected domain.
- **eBay domain** — marketplace used for keyword searches; also used for proxy country when no Start URL is provided.
- **Max items** — maximum number of listings returned across the run.
- **Max pages per search** — maximum pages processed for each keyword or URL.
- **Only listings from the last (days)** — optional maximum listing age. Searches are sorted newest-first; older listings and listings whose publication time cannot be determined are excluded.
- **Scrape item details** — opens every listing page one by one for full vehicle specifics (enabled by default; disable for faster runs with search-card data only).
- **Duplicate check** — skip detail scraping for listing URLs already known (default `false`).
- **Duplicate check API URL** — optional POST exists API; leave empty for Apify storage only.
- **Duplicate check store name** — named KV store (default `vehicle-listing-urls`).
- **Proxy configuration** — residential proxies are recommended and enabled by default.

At least one start URL or search keyword is required.

### Skip existing listings (duplicate check)

Detail scraping opens every listing through residential proxies. On scheduled re-runs, most results are often listings you already stored. Duplicate check skips those URLs so you do not pay again for detail pages you already have.

Enable it with `duplicateCheck: true` (default `false`).

If N consecutive listing URLs in a search are known duplicates (N = `duplicateCheckLeadingStop`, default **20**), that search stops (no further pages) to avoid paying for known inventory.

**Modes**

- When **`duplicateCheckApiUrl`** is set, the Actor POSTs batches of up to 500 listing URLs to your endpoint, then skips URLs returned in `existing`. It also reads and updates the named Apify Key-Value store. A URL is skipped if **either** your API or the store marks it as known.
- When **`duplicateCheckApiUrl`** is empty, the Actor uses the **Apify Key-Value store only** (no external API).

**API contract**

```json
// Request
{ "listingUrls": ["https://example.com/listing/1", "https://example.com/listing/2"] }

// Response
{
  "existing": ["https://example.com/listing/1"],
  "missing": ["https://example.com/listing/2"]
}
````

`listingUrls` may also be a single string. URLs are normalized (query string and trailing slash ignored). No auth header is required for public endpoints. If the API call fails, the Actor fail-opens and scrapes the batch.

After a listing is saved successfully, its URL is written to the named store under the `KNOWN_LISTING_URLS` record so future runs skip it even without an API.

Example:

```json
{
    "startUrls": [{ "url": "https://www.ebay.com/sch/i.html?_nkw=toyota+tacoma" }],
    "maxItems": 100,
    "duplicateCheck": true,
    "duplicateCheckApiUrl": "https://your-api.example.com/listings/exists",
    "duplicateCheckStoreName": "vehicle-listing-urls"
}
```

### Results

With **Scrape item details** enabled, each dataset item can include:

- Item ID, listing title, subtitle, and the time it was listed
- Price and currency
- Year, make, model, trim, and VIN
- Mileage, body type, engine, transmission, drive type, and fuel type
- Exterior and interior colors
- Vehicle title status and "for sale by" (private seller or dealer)
- Condition, item location, seller name, and seller feedback score and percentage
- All listing images and the listing URL
- Full **Item specifics** section as key-value pairs
- Source URL, result page, listing timestamp, and scrape timestamp

With detail scraping disabled, items contain the lighter search-card fields only (title, price, condition, image, URL). When the listing-age filter is enabled, the Actor still checks each item page to determine its publication time before saving it.

Some fields may be empty when the seller does not provide them.

Results can be downloaded from Apify as JSON, CSV, Excel, XML, or RSS.

When the Actor is started from an Apify Task, each dataset item also includes `taskId` and `taskName` so you can track which Task produced it. Direct Actor runs set both to `null`.

### Tips

- Enable `duplicateCheck` on scheduled re-runs to skip listings you already stored.
- Bound cost with **Max items** and **Max pages per search**.
- Disable **Scrape item details** when search-card data is enough (note: the listing-age filter still opens item pages to read publication time).
- Prefer skipping known listings over raising memory.

# Actor input Schema

## `searchKeywords` (type: `array`):

Used only when Start URLs are empty. List of keywords to search on eBay. Each keyword produces its own search.

## `startUrls` (type: `array`):

Paste the exact eBay URL from your browser address bar. The Actor fetches that string as-is (no rewrite of filters, sort, page, encoding, or page size). When provided, only these URLs are crawled (keywords ignored).

## `domain` (type: `string`):

eBay marketplace domain to search on (used only for keyword searches).

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

Maximum number of listings to scrape across all searches. Set to 0 for no limit.

## `maxPagesPerSearch` (type: `integer`):

Maximum number of result pages to paginate through per search/URL.

## `maxListingAgeDays` (type: `integer`):

Optional. Return only listings published within this many days, for example 10 or 30. Older listings and listings without a known publication time are excluded.

## `scrapeItemDetails` (type: `boolean`):

Open each listing page one by one to extract full item specifics — year, mileage, make, model, VIN, colors, seller feedback, location, and all images. Slower but much richer data.

## `duplicateCheck` (type: `boolean`):

When enabled, skip detail scraping for listing URLs already known from your duplicate-check API and/or a named Apify Key-Value store. Saves proxy and compute cost on re-runs.

## `duplicateCheckApiUrl` (type: `string`):

Optional. POST endpoint that accepts { "listingUrls": string|string\[] } and returns { "existing": string\[], "missing": string\[] }. Leave empty to use Apify Key-Value store only.

## `duplicateCheckStoreName` (type: `string`):

Named Apify Key-Value store that remembers listing URLs across runs. Used whenever Skip existing listings is enabled.

## `duplicateCheckLeadingStop` (type: `integer`):

When Skip existing listings is enabled, stop that search after this many consecutive listing URLs are known duplicates (in a row). Default 20. Lower to stop sooner; raise to keep scanning longer.

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

Proxy settings. eBay blocks most datacenter IPs — use Apify residential proxies.

## Actor input object example

```json
{
  "searchKeywords": [],
  "startUrls": [
    {
      "url": "https://www.ebay.com/b/Private-Seller-Less-than-75-000-miles-Clean-Cars-and-Trucks/6001/bn_116418348?LH_ItemCondition=1000%7C2500%7C3000&Model%2520Year=1980%7C1981%7C1982%7C1983%7C1984%7C1985%7C1986%7C1987%7C1988%7C1989%7C1990%7C1991%7C1992%7C1993%7C1994%7C1995%7C1996%7C1997%7C1998%7C1999%7C2000%7C2001%7C2002%7C2003%7C2004%7C2005%7C2006%7C2007%7C2008%7C2009%7C2010%7C2011%7C2012%7C2013%7C2014%7C2015%7C2016%7C2017%7C2018%7C2019%7C2020%7C2021%7C2022%7C2023%7C2024%7C2025%7C2026&_pgn=2&_sop=10&mag=1&rt=nc"
    }
  ],
  "domain": "www.ebay.com",
  "maxItems": 100,
  "maxPagesPerSearch": 3,
  "scrapeItemDetails": true,
  "duplicateCheck": false,
  "duplicateCheckApiUrl": "https://ccscraperapi.up.railway.app/api/listings/exists",
  "duplicateCheckStoreName": "vehicle-listing-urls",
  "duplicateCheckLeadingStop": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `scrapeState` (type: `string`):

No description

## `debugItems` (type: `string`):

No description

## `debugPages` (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 = {
    "searchKeywords": [],
    "startUrls": [
        {
            "url": "https://www.ebay.com/b/Private-Seller-Less-than-75-000-miles-Clean-Cars-and-Trucks/6001/bn_116418348?LH_ItemCondition=1000%7C2500%7C3000&Model%2520Year=1980%7C1981%7C1982%7C1983%7C1984%7C1985%7C1986%7C1987%7C1988%7C1989%7C1990%7C1991%7C1992%7C1993%7C1994%7C1995%7C1996%7C1997%7C1998%7C1999%7C2000%7C2001%7C2002%7C2003%7C2004%7C2005%7C2006%7C2007%7C2008%7C2009%7C2010%7C2011%7C2012%7C2013%7C2014%7C2015%7C2016%7C2017%7C2018%7C2019%7C2020%7C2021%7C2022%7C2023%7C2024%7C2025%7C2026&_pgn=2&_sop=10&mag=1&rt=nc"
        }
    ],
    "duplicateCheckApiUrl": "https://ccscraperapi.up.railway.app/api/listings/exists",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fmchisti/ebay-vehicles-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 = {
    "searchKeywords": [],
    "startUrls": [{ "url": "https://www.ebay.com/b/Private-Seller-Less-than-75-000-miles-Clean-Cars-and-Trucks/6001/bn_116418348?LH_ItemCondition=1000%7C2500%7C3000&Model%2520Year=1980%7C1981%7C1982%7C1983%7C1984%7C1985%7C1986%7C1987%7C1988%7C1989%7C1990%7C1991%7C1992%7C1993%7C1994%7C1995%7C1996%7C1997%7C1998%7C1999%7C2000%7C2001%7C2002%7C2003%7C2004%7C2005%7C2006%7C2007%7C2008%7C2009%7C2010%7C2011%7C2012%7C2013%7C2014%7C2015%7C2016%7C2017%7C2018%7C2019%7C2020%7C2021%7C2022%7C2023%7C2024%7C2025%7C2026&_pgn=2&_sop=10&mag=1&rt=nc" }],
    "duplicateCheckApiUrl": "https://ccscraperapi.up.railway.app/api/listings/exists",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fmchisti/ebay-vehicles-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 '{
  "searchKeywords": [],
  "startUrls": [
    {
      "url": "https://www.ebay.com/b/Private-Seller-Less-than-75-000-miles-Clean-Cars-and-Trucks/6001/bn_116418348?LH_ItemCondition=1000%7C2500%7C3000&Model%2520Year=1980%7C1981%7C1982%7C1983%7C1984%7C1985%7C1986%7C1987%7C1988%7C1989%7C1990%7C1991%7C1992%7C1993%7C1994%7C1995%7C1996%7C1997%7C1998%7C1999%7C2000%7C2001%7C2002%7C2003%7C2004%7C2005%7C2006%7C2007%7C2008%7C2009%7C2010%7C2011%7C2012%7C2013%7C2014%7C2015%7C2016%7C2017%7C2018%7C2019%7C2020%7C2021%7C2022%7C2023%7C2024%7C2025%7C2026&_pgn=2&_sop=10&mag=1&rt=nc"
    }
  ],
  "duplicateCheckApiUrl": "https://ccscraperapi.up.railway.app/api/listings/exists",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call fmchisti/ebay-vehicles-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Vehicles Scraper",
        "description": "Scrape eBay Motors vehicle listings by keyword, search URL, or category page. Extract titles, prices, model year, mileage, condition, location, seller details, and more.",
        "version": "0.2",
        "x-build-id": "rpWWSECUhAhEwxj99"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fmchisti~ebay-vehicles-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fmchisti-ebay-vehicles-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/fmchisti~ebay-vehicles-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fmchisti-ebay-vehicles-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/fmchisti~ebay-vehicles-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fmchisti-ebay-vehicles-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": {
                    "searchKeywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Used only when Start URLs are empty. List of keywords to search on eBay. Each keyword produces its own search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste the exact eBay URL from your browser address bar. The Actor fetches that string as-is (no rewrite of filters, sort, page, encoding, or page size). When provided, only these URLs are crawled (keywords ignored).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "domain": {
                        "title": "eBay domain",
                        "enum": [
                            "www.ebay.com",
                            "www.ebay.co.uk",
                            "www.ebay.de",
                            "www.ebay.com.au",
                            "www.ebay.ca",
                            "www.ebay.fr",
                            "www.ebay.it",
                            "www.ebay.es"
                        ],
                        "type": "string",
                        "description": "eBay marketplace domain to search on (used only for keyword searches).",
                        "default": "www.ebay.com"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape across all searches. Set to 0 for no limit.",
                        "default": 100
                    },
                    "maxPagesPerSearch": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of result pages to paginate through per search/URL.",
                        "default": 3
                    },
                    "maxListingAgeDays": {
                        "title": "Only listings from the last (days)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional. Return only listings published within this many days, for example 10 or 30. Older listings and listings without a known publication time are excluded."
                    },
                    "scrapeItemDetails": {
                        "title": "Scrape item details",
                        "type": "boolean",
                        "description": "Open each listing page one by one to extract full item specifics — year, mileage, make, model, VIN, colors, seller feedback, location, and all images. Slower but much richer data.",
                        "default": true
                    },
                    "duplicateCheck": {
                        "title": "Skip existing listings",
                        "type": "boolean",
                        "description": "When enabled, skip detail scraping for listing URLs already known from your duplicate-check API and/or a named Apify Key-Value store. Saves proxy and compute cost on re-runs.",
                        "default": false
                    },
                    "duplicateCheckApiUrl": {
                        "title": "Duplicate check API URL",
                        "type": "string",
                        "description": "Optional. POST endpoint that accepts { \"listingUrls\": string|string[] } and returns { \"existing\": string[], \"missing\": string[] }. Leave empty to use Apify Key-Value store only."
                    },
                    "duplicateCheckStoreName": {
                        "title": "Duplicate check store name",
                        "type": "string",
                        "description": "Named Apify Key-Value store that remembers listing URLs across runs. Used whenever Skip existing listings is enabled.",
                        "default": "vehicle-listing-urls"
                    },
                    "duplicateCheckLeadingStop": {
                        "title": "Stop after consecutive duplicates",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "When Skip existing listings is enabled, stop that search after this many consecutive listing URLs are known duplicates (in a row). Default 20. Lower to stop sooner; raise to keep scanning longer.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. eBay blocks most datacenter IPs — use Apify residential proxies.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```