# eBay Product Reviews Scraper (`scrapier/ebay-review-scraper`) Actor

🛒 eBay Product Reviews Scraper (ebay-review-scraper) extracts structured eBay reviews—ratings, titles, text & dates. 🔍 Advanced filters: star rating, keywords, date range, locale & verified. 📦 Export CSV/JSON for market research, sentiment & SEO. 🚀

- **URL**: https://apify.com/scrapier/ebay-review-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** E-commerce, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.99 / 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.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 Product Reviews Scraper

The eBay Product Reviews Scraper extracts structured buyer feedback from public eBay item pages, turning scattered reviews into clean, analysis-ready rows with product context. It solves the challenge of consolidating eBay reviews at scale by collecting ratings, comments, dates, photo signals, and verified purchase flags — ideal for marketers, developers, data analysts, and researchers. Built as a reliable product review scraper for market research and seller analysis, it enables bulk processing and live streaming of results into an Apify dataset for CSV/JSON export.

### What data / output can you get?

Below are the exact fields this scraper produces. The first review row for each product includes ProductDetails; subsequent rows repeat Url and omit ProductDetails to keep output compact.

| Data field | Description | Example value |
| --- | --- | --- |
| Url | Product URL from JSON-LD offers.url | https://www.ebay.com/itm/364771787371 |
| ProductDetails.productTitle | Title from JSON-LD Product name | “Wireless Bluetooth Earbuds Pro” |
| ProductDetails.productPrice | Price with currency from JSON-LD offers | “USD 29.99” |
| ProductDetails.sellerUsername | eBay seller username (from JSON-LD offers.seller or page HTML) | “best_seller_store” |
| ProductDetails.productImages | Array of product image URLs | ["https://i.ebayimg.com/…/s-l1600.jpg"] |
| ReviewerName | Display name of the reviewer | “john_doe (124)” |
| IsVerifiedPurchase | “Verified purchase” if present, otherwise empty string | “Verified purchase” |
| ReviewRatingType | Text label for rating sentiment | “Positive feedback rating” |
| ReviewComment | Review text/comment | “Great value for the price. Battery lasts long.” |
| ReviewDateRange | Relative time window captured from context text | “Past 6 months” |
| ReviewImageCount | Count of buyer photos associated with the review (string) | “2” |
| ReviewImageUrl | Comma-separated image URLs if discovered on item page reviews | “https://i.ebayimg.com/…1.jpg,https://i.ebayimg.com/…2.jpg” |

Notes:
- Results stream live to the Apify dataset; export to CSV or JSON in one click.
- When no reviews are available, a single row with ProductDetails is returned and review fields are empty.

### Key features

- 🚀 Advanced proxy ladder & resilience — Starts without proxy, then auto-falls back to Apify datacenter and finally residential proxy with up to three rotated attempts. Once residential succeeds, subsequent URLs stick to residential for reliability.
- 📦 Bulk URL input — Paste many item links at once via ebayProductUrls. Accepts plain strings or { "url": "…" } objects for fast batch research.
- 🧠 Accurate HTML + JSON parsing — Combines on-page review HTML with the paginated mweb_profile JSON, plus JSON-LD Product data for a clean product snapshot.
- 🖼️ Photo-only filtering — Use withPhotosOnly to keep reviews that include buyer photos, ideal for social proof analysis.
- 🔎 Flexible sorting and sentiment focus — Sort by RELEVANCE or TIME, and optionally filter by ratingType (All ratings, POSITIVE, NEUTRAL, NEGATIVE).
- ⏱️ Live dataset output — Each review row is pushed as it’s produced, so you can monitor progress and export anytime.
- 🧰 Developer-friendly Python stack — Built with the Apify Python SDK and curl_cffi (Chrome TLS impersonation), making it robust for production workflows.
- 🔐 Production-ready networking — Chrome-like TLS via curl_cffi and intelligent fallback across regional item URLs improve reachability and stability.

### How to use eBay Product Reviews Scraper - step by step

1. Create or log in to your Apify account.
2. Open the eBay Product Reviews Scraper in your Apify Console.
3. Add input data:
   - In ebayProductUrls, paste eBay item links (e.g., https://www.ebay.com/itm/364771787371). You can use either plain strings or objects like { "url": "…" }.
4. Configure settings:
   - sortReviewsBy: Choose RELEVANCE or TIME.
   - ratingType: Choose All ratings, POSITIVE, NEUTRAL, or NEGATIVE.
   - withPhotosOnly: Set to true to keep reviews with buyer photos.
   - maxReviewsPerUrl: Set a cap per product (0 = no limit).
   - proxyConfiguration: Keep default to enable automatic fallback if needed.
5. Start the run:
   - Click Start. The actor logs steps like product loading, collection progress, and row saves.
6. Monitor progress:
   - Results appear live in the Dataset tab as each row is pushed.
7. Export results:
   - Download your dataset in CSV or JSON for analysis and reporting.

Pro Tip: Leave proxyConfiguration at its default (useApifyProxy: true) for the best success rate. The actor automatically escalates from direct to datacenter to residential proxy when needed.

### Use cases

| Use case | Description |
| --- | --- |
| Market research – product benchmarking | Aggregate buyer sentiment, comments, and photo signals across competing listings to compare quality and value. |
| Seller trust & QA monitoring | Track “Verified purchase” signals and sentiment labels to evaluate seller performance over time. |
| SEO & content strategy | Extract review language to inform keyword targeting and on-page copy based on real buyer phrasing. |
| Competitive intelligence – review trends | Monitor changes in ReviewRatingType distribution (Positive/Neutral/Negative) and comment themes at scale. |
| UGC analysis – photo-led insights | Filter photo-only reviews to analyze visual social proof and real-world usage. |
| Data enrichment pipeline (API/ETL) | Feed structured rows into analytics dashboards or ML pipelines for sentiment and topic modeling. |
| Academic & policy research | Study product categories and buyer behavior using standardized fields and exportable formats. |

### Why choose eBay Product Reviews Scraper?

This scraper is engineered for precision, automation, and reliability in extracting eBay review data at scale.

- ✅ Accurate hybrid extraction: Combines on-page HTML with mweb_profile JSON and Product JSON-LD for complete, structured rows.
- 🌍 Regional URL fallback: Automatically tries common marketplace domains for the same item ID to bypass regional blocks.
- 📈 Scales to batches: Handles many item URLs with live streaming to the dataset for continuous export.
- 👩‍💻 Developer-ready: Built on the Apify Python SDK and curl_cffi with Chrome TLS impersonation for robust production use.
- 🔒 Stable & ethical: Targets public eBay pages only; no login or cookies required.
- 💾 Flexible exports: Download clean CSV or JSON for BI tools, notebooks, or internal systems.
- 🧩 Workflow friendly: Ideal for integration into research, analytics, or enrichment pipelines running on Apify.

In short, it’s a production-grade eBay review scraper that outperforms manual tools and fragile browser extensions with structured, repeatable outputs.

### Is it legal / ethical to use eBay Product Reviews Scraper?

Yes — when used responsibly. This actor collects data only from public eBay pages and does not access private or authenticated content.

Guidelines for responsible use:
- Scrape only publicly available content.
- Comply with eBay’s terms of service and applicable laws (e.g., GDPR, CCPA).
- Avoid collecting or storing unnecessary personal data.
- Use results for legitimate analysis and research purposes.
- Consult your legal team if you have edge cases or jurisdiction-specific questions.

### Input parameters & output format

Example JSON input
```json
{
  "ebayProductUrls": [
    { "url": "https://www.ebay.com/itm/364771787371" }
  ],
  "sortReviewsBy": "RELEVANCE",
  "ratingType": "All ratings",
  "withPhotosOnly": false,
  "maxReviewsPerUrl": 0,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

Parameter reference

- ebayProductUrls (array, required) — Paste eBay item links. Accepts plain strings or { "url": "…" } objects. Default: none.
- sortReviewsBy (string) — Choose RELEVANCE or TIME. Default: "RELEVANCE".
- ratingType (string) — Choose "All ratings", "POSITIVE", "NEUTRAL", or "NEGATIVE". Default: "All ratings".
- withPhotosOnly (boolean) — true to keep reviews that include buyer photos. Default: false.
- maxReviewsPerUrl (integer) — Cap the number of reviews per product; 0 means no limit. Default: 0.
- proxyConfiguration (object) — Apify Proxy settings. By default, the actor uses Apify Proxy and can escalate from direct to datacenter to residential when needed. Default: { "useApifyProxy": true }.

Compatibility note:

- The actor also reads legacy keys if present: urls/startUrls (for input URLs), sortBy, and maxReviews. These are optional and not required by the input schema.

Example JSON output

```json
[
  {
    "Url": "https://www.ebay.com/itm/364771787371",
    "ProductDetails": {
      "productTitle": "Wireless Bluetooth Earbuds Pro",
      "productPrice": "USD 29.99",
      "sellerUsername": "best_seller_store",
      "productImages": [
        "https://i.ebayimg.com/images/g/abcd/s-l1600.jpg",
        "https://i.ebayimg.com/images/g/efgh/s-l1600.jpg"
      ]
    },
    "ReviewerName": "john_doe (124)",
    "IsVerifiedPurchase": "Verified purchase",
    "ReviewRatingType": "Positive feedback rating",
    "ReviewComment": "Great value for the price. Battery lasts long.",
    "ReviewDateRange": "Past 6 months",
    "ReviewImageCount": "2",
    "ReviewImageUrl": "https://i.ebayimg.com/revimg1.jpg,https://i.ebayimg.com/revimg2.jpg"
  },
  {
    "Url": "https://www.ebay.com/itm/364771787371",
    "ReviewerName": "shopper_2020",
    "IsVerifiedPurchase": "",
    "ReviewRatingType": "Neutral feedback rating",
    "ReviewComment": "Okay overall, but shipping took a while.",
    "ReviewDateRange": "Past year",
    "ReviewImageCount": "0",
    "ReviewImageUrl": ""
  }
]
```

Notes:

- The first row per product includes ProductDetails. Subsequent rows include Url and review fields only.
- ReviewImageCount is provided as a string (e.g., "0", "2").

### FAQ

#### Do I need to log in to scrape eBay reviews?

No. This actor works on public eBay pages without login or cookies. It targets publicly available item and feedback content only.

#### Can I filter reviews by sentiment or photos?

Yes. Use ratingType to focus on All ratings, POSITIVE, NEUTRAL, or NEGATIVE. Toggle withPhotosOnly to keep reviews that include buyer photos.

#### How many reviews per product can I collect?

You control this via maxReviewsPerUrl. Set 0 for no limit, or any positive integer to cap the number of reviews collected per item.

#### What fields are included in the output?

Each review row includes Url, ReviewerName, IsVerifiedPurchase, ReviewRatingType, ReviewComment, ReviewDateRange, ReviewImageCount, and ReviewImageUrl. The first row per product also includes a ProductDetails object with productTitle, productPrice, sellerUsername, and productImages.

#### Does it work across different eBay sites?

Yes. The actor automatically tries common regional URLs for the same item ID (e.g., ebay.com, ebay.co.uk, ebay.de) to improve reachability before proceeding to seller feedback collection.

#### How does the proxy fallback work?

Runs start without a proxy. If blocked or challenged, the actor falls back to Apify datacenter proxy and then to residential proxy with up to three rotated attempts. After a residential success, remaining URLs use residential for stability.

#### What export formats are supported?

Results are stored in an Apify dataset. You can export to CSV or JSON directly from the Dataset tab.

#### Are numeric star ratings included?

The actor captures sentiment labels via ReviewRatingType (e.g., “Positive feedback rating”, “Neutral feedback rating”, “Negative feedback rating”). Numeric star values are not included in the current output.

### Closing thoughts

The eBay Product Reviews Scraper is built to turn public eBay listings into structured review datasets you can trust. With robust filtering, a resilient proxy strategy, and clean ProductDetails context, it’s ideal for marketers, developers, and researchers who need reliable CSV/JSON outputs. Integrate results into your analytics or enrichment pipelines on Apify and start extracting smarter insights from real buyer feedback today.

# Actor input Schema

## `ebayProductUrls` (type: `array`):

Paste one or more **eBay item links** (the pages where you see the product). Add as many as you need — perfect for batch research or building a comparison sheet.

## `sortReviewsBy` (type: `string`):

Choose what matters most: **most relevant** feedback first, or **newest** comments at the top.

## `ratingType` (type: `string`):

Focus on **all feedback** or zoom in on **positive**, **neutral**, or **negative** experiences — ideal when you only want a specific mood of reviews.

## `withPhotosOnly` (type: `boolean`):

Toggle **on** to keep reviews that include buyer photos — great when you want visual proof or richer social proof.

## `maxReviewsPerUrl` (type: `integer`):

Cap how many reviews to collect **per link**. Use **0** for no limit — handy for quick samples or full deep-dives.

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

Optional Apify Proxy can help **when pages are harder to reach** from certain networks. Leave as default for the best balance, or adjust if your organization requires it.

## Actor input object example

```json
{
  "ebayProductUrls": [
    {
      "url": "https://www.ebay.com/itm/364771787371"
    },
    {
      "url": "https://www.ebay.co.uk/itm/194488920284"
    }
  ],
  "sortReviewsBy": "RELEVANCE",
  "ratingType": "All ratings",
  "withPhotosOnly": false,
  "maxReviewsPerUrl": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "ebayProductUrls": [
        {
            "url": "https://www.ebay.com/itm/364771787371"
        },
        {
            "url": "https://www.ebay.co.uk/itm/194488920284"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/ebay-review-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 = {
    "ebayProductUrls": [
        { "url": "https://www.ebay.com/itm/364771787371" },
        { "url": "https://www.ebay.co.uk/itm/194488920284" },
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/ebay-review-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 '{
  "ebayProductUrls": [
    {
      "url": "https://www.ebay.com/itm/364771787371"
    },
    {
      "url": "https://www.ebay.co.uk/itm/194488920284"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapier/ebay-review-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Product Reviews Scraper",
        "description": "🛒 eBay Product Reviews Scraper (ebay-review-scraper) extracts structured eBay reviews—ratings, titles, text & dates. 🔍 Advanced filters: star rating, keywords, date range, locale & verified. 📦 Export CSV/JSON for market research, sentiment & SEO. 🚀",
        "version": "1.0",
        "x-build-id": "VlWqp1TZn7jEZwSaL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~ebay-review-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-ebay-review-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/scrapier~ebay-review-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-ebay-review-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/scrapier~ebay-review-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-ebay-review-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": [
                    "ebayProductUrls"
                ],
                "properties": {
                    "ebayProductUrls": {
                        "title": "🔗 eBay product URLs",
                        "type": "array",
                        "description": "Paste one or more **eBay item links** (the pages where you see the product). Add as many as you need — perfect for batch research or building a comparison sheet.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "sortReviewsBy": {
                        "title": "📊 Sort reviews by",
                        "enum": [
                            "RELEVANCE",
                            "TIME"
                        ],
                        "type": "string",
                        "description": "Choose what matters most: **most relevant** feedback first, or **newest** comments at the top.",
                        "default": "RELEVANCE"
                    },
                    "ratingType": {
                        "title": "⭐ Rating type",
                        "enum": [
                            "All ratings",
                            "POSITIVE",
                            "NEUTRAL",
                            "NEGATIVE"
                        ],
                        "type": "string",
                        "description": "Focus on **all feedback** or zoom in on **positive**, **neutral**, or **negative** experiences — ideal when you only want a specific mood of reviews.",
                        "default": "All ratings"
                    },
                    "withPhotosOnly": {
                        "title": "📷 With photos only",
                        "type": "boolean",
                        "description": "Toggle **on** to keep reviews that include buyer photos — great when you want visual proof or richer social proof.",
                        "default": false
                    },
                    "maxReviewsPerUrl": {
                        "title": "🔢 Max reviews per product",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Cap how many reviews to collect **per link**. Use **0** for no limit — handy for quick samples or full deep-dives.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy can help **when pages are harder to reach** from certain networks. Leave as default for the best balance, or adjust if your organization requires it."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
