# Amazon Scraper Ppe (`silentflow/amazon-scraper-ppe`) Actor

Scrape Amazon product data from 17 marketplaces with pay-per-result pricing. Extract prices, reviews, ratings, BSR rankings, specifications, images, and seller info. No monthly fees, only pay for results. Supports keyword search, ASIN lookup, URL scraping, sorting, and price filtering.

- **URL**: https://apify.com/silentflow/amazon-scraper-ppe.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Amazon Product Scraper - Pay Per Event

**Pay only for the data you get!** Proxies included, no compute costs.

Extract Amazon product data at scale: prices, ratings, review breakdowns, BSR rankings, coupons, Subscribe & Save, variants, seller info, images, and 40+ fields from any of the 17 Amazon marketplaces worldwide.

### ✨ Why use this scraper?

- 💰 **Pay per result**: No compute costs - only pay for data you get
- 🌐 **Proxies included**: No need to configure or pay for proxies separately
- 🌍 **17 Amazon marketplaces**: US, UK, Germany, France, Japan, Canada, Australia, India, Brazil, Mexico, and more in one tool
- 📊 **40+ data fields**: Prices, rating breakdown, BSR, coupons, Subscribe & Save, variants, A+ content detection, and more
- 🔍 **Flexible input**: Search by keyword, ASIN, or direct Amazon URL
- 🏷️ **Complete pricing**: Current price, list price, savings, coupons, Subscribe & Save discounts, and price per unit
- 📦 **Rich product details**: Feature bullets, specs, all images, variants, seller info, and category breadcrumbs

### 🎯 Use cases

| Industry | Application |
|----------|-------------|
| **E-commerce** | Track competitor prices, monitor deals, and optimize your pricing strategy |
| **Market Research** | Analyze ratings distribution, BSR trends, and category landscapes |
| **Product Development** | Study feature bullets, customer ratings breakdown, and A+ content strategies |
| **Brand Monitoring** | Track your products across 17 marketplaces with pricing, Buy Box, and seller data |
| **Dropshipping** | Find winning products with high ratings, Prime eligibility, and strong BSR |
| **Data Analytics** | Build product databases with complete specs, images, and pricing history |

### 📥 Input parameters

#### URL Scraping

| Parameter | Type | Description |
|-----------|------|-------------|
| `startUrls` | array | Direct Amazon URLs to scrape (product pages `/dp/ASIN` or search results `/s?k=...`) |

#### Search

| Parameter | Type | Description |
|-----------|------|-------------|
| `searches` | array | Keywords to search (e.g., `["iphone case", "wireless earbuds"]`) |
| `asins` | array | Amazon ASINs to scrape directly (e.g., `["B071S5NPG9"]`) |
| `country` | string | Amazon marketplace: `US`, `UK`, `DE`, `FR`, `ES`, `IT`, `JP`, `CA`, `AU`, `IN`, `BR`, `MX`, `NL`, `SE`, `PL`, `BE`, `SG` (default: `US`) |

#### Sorting & Filtering

| Parameter | Type | Description |
|-----------|------|-------------|
| `sort` | string | `relevance` (default), `price_asc`, `price_desc`, `avg_review`, `newest` |

#### Limits

| Parameter | Type | Description |
|-----------|------|-------------|
| `maxItems` | integer | Maximum total products to save (default: 50) |

#### Options

| Parameter | Type | Description |
|-----------|------|-------------|
| `includeDetails` | boolean | Visit each product's detail page for full data: description, feature bullets, specs, BSR, rating breakdown, all images, variants, seller info (default: true) |

### 📊 Output data

#### Product example

```json
{
  "asin": "B0B375ZY12",
  "url": "https://www.amazon.de/dp/B0B375ZY12",
  "title": "TORRAS iPhone 13 Case (Ultimate Matte Finish) Slim Fit",
  "brand": "TORRAS",
  "seller": "TORRAS Official",
  "sellerUrl": "https://www.amazon.de/sp?seller=A2EXAMPLE",
  "price": "€18.44",
  "priceValue": 18.44,
  "currency": "EUR",
  "listPrice": "€24.99",
  "listPriceValue": 24.99,
  "savingsAmount": "€6.55",
  "savingsPercent": "-26%",
  "couponText": "Save 5% with coupon",
  "couponValue": "5%",
  "subscribeAndSave": "",
  "dealBadge": "",
  "pricePerUnit": "",
  "rating": 4.5,
  "ratingsCount": 39681,
  "reviewsCount": 0,
  "ratingBreakdown": {
    "fiveStar": 68,
    "fourStar": 17,
    "threeStar": 7,
    "twoStar": 4,
    "oneStar": 4
  },
  "qaCount": 12,
  "availability": "In Stock",
  "primeEligible": true,
  "freeShipping": true,
  "deliveryEstimate": "Get it by Wednesday, March 12",
  "fulfilledBy": "Amazon",
  "featureBullets": [
    "Designed for iPhone 13",
    "Slim profile with matte finish",
    "Anti-fingerprint coating",
    "Wireless charging compatible",
    "360-degree protection"
  ],
  "description": "TORRAS case designed specifically for iPhone 13...",
  "specifications": {
    "Product Dimensions": "11.94 x 6.1 x 0.51 cm; 50 g",
    "Manufacturer": "TORRAS",
    "ASIN": "B0B375ZY12",
    "Item model number": "iPhone 13"
  },
  "dimensions": "11.94 x 6.1 x 0.51 cm; 50 g",
  "weight": "",
  "imageUrl": "https://m.media-amazon.com/images/I/71example.jpg",
  "images": [
    "https://m.media-amazon.com/images/I/71example.jpg",
    "https://m.media-amazon.com/images/I/71example2.jpg"
  ],
  "videoCount": 2,
  "category": "Basic Cases",
  "breadcrumbs": ["Electronics", "Mobile Phones", "Cases", "Basic Cases"],
  "bsr": [
    {
      "rank": 1234,
      "category": "Cell Phone Basic Cases",
      "url": ""
    }
  ],
  "variants": [
    {
      "asin": "B0B375ABCD",
      "title": "",
      "url": "https://www.amazon.de/dp/B0B375ABCD",
      "value": "Black"
    }
  ],
  "variantCount": 5,
  "selectedVariant": "Black",
  "offersCount": 3,
  "offersFromText": "",
  "sponsored": false,
  "amazonChoice": true,
  "bestSeller": false,
  "hasAplusContent": true,
  "isAddonItem": false,
  "climatePledge": true,
  "country": "DE",
  "scrapedAt": "2026-03-06T22:31:14Z",
  "dataType": "product"
}
````

### 🗂️ Data fields

| Category | Fields |
|----------|--------|
| **Core** | `asin`, `url`, `title`, `brand` |
| **Seller** | `seller`, `sellerUrl` |
| **Pricing** | `price`, `priceValue`, `currency`, `listPrice`, `listPriceValue`, `savingsAmount`, `savingsPercent`, `couponText`, `couponValue`, `subscribeAndSave`, `dealBadge`, `pricePerUnit` |
| **Reviews** | `rating`, `ratingsCount`, `reviewsCount`, `ratingBreakdown` (5-star to 1-star distribution), `qaCount` |
| **Availability** | `availability`, `primeEligible`, `freeShipping`, `deliveryEstimate`, `fulfilledBy` |
| **Content** | `featureBullets`, `description`, `specifications`, `dimensions`, `weight` |
| **Images** | `imageUrl`, `images` (all product images), `videoCount` |
| **Categories** | `category`, `breadcrumbs`, `bsr` (Best Sellers Rank with rank + category) |
| **Variants** | `variants` (ASIN, value, URL), `variantCount`, `selectedVariant` |
| **Offers** | `offersCount`, `offersFromText` |
| **Flags** | `sponsored`, `amazonChoice`, `bestSeller`, `hasAplusContent`, `isAddonItem`, `climatePledge` |
| **Meta** | `country`, `scrapedAt`, `dataType` |

### 🚀 Examples

#### Search for products

```json
{
  "searches": ["wireless earbuds"],
  "country": "US",
  "maxItems": 100,
  "includeDetails": true
}
```

#### Scrape specific products by ASIN

```json
{
  "asins": ["B0B375ZY12", "B071S5NPG9", "B09V3KXJPB"],
  "country": "DE"
}
```

#### Scrape from Amazon URL

```json
{
  "startUrls": [
    { "url": "https://www.amazon.fr/s?k=casque+bluetooth" }
  ],
  "maxItems": 50,
  "sort": "avg_review"
}
```

#### Quick search without detail pages

```json
{
  "searches": ["laptop stand"],
  "country": "UK",
  "maxItems": 200,
  "includeDetails": false
}
```

### 💻 Integrations

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("silentflow/amazon-scraper-ppe").call(run_input={
    "searches": ["iphone case"],
    "country": "US",
    "maxItems": 50,
    "includeDetails": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']} - {item['price']} ({item['rating']}⭐ {item['ratingsCount']} ratings)")
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('silentflow/amazon-scraper-ppe').call({
    searches: ['iphone case'],
    country: 'US',
    maxItems: 50,
    includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`${item.title} - ${item.price} (${item.rating}⭐ ${item.ratingsCount} ratings)`);
});
```

### 📈 Performance & limits

| Metric | Value |
|--------|-------|
| Items per search page | ~16-48 products |
| Detail page enrichment | ~1-3 seconds per product |
| Parallel detail workers | 3 concurrent requests |
| Supported marketplaces | 17 Amazon sites |
| Data fields per product | 40+ fields |
| Export formats | JSON, CSV, Excel |

### 💡 Tips for best results

1. **Start small**: Test with `maxItems: 5` to verify results before scaling up
2. **Use ASINs for specific products**: If you know the exact products, use `asins` input for fastest results
3. **Disable detail pages for speed**: Set `includeDetails: false` for quick price/rating monitoring (search data only)
4. **Match marketplace to proxy country**: The scraper automatically matches proxy location to the target marketplace
5. **Use sort options**: Sort by `avg_review` to find top-rated products, or `price_asc` for budget options

### ❓ FAQ

**Q: Which Amazon marketplaces are supported?**
A: All 17 major Amazon sites: US, UK, Germany, France, Spain, Italy, Japan, Canada, Australia, India, Brazil, Mexico, Netherlands, Sweden, Poland, Belgium, and Singapore.

**Q: What's the difference between search mode and ASIN mode?**
A: Search mode finds products by keyword (like searching on Amazon). ASIN mode fetches specific products directly. ASIN mode is faster and always returns full detail data.

**Q: What does "includeDetails" do?**
A: When enabled (default), the scraper visits each product's detail page to get full data: description, feature bullets, specifications, BSR, rating breakdown, all images, variants, and seller info. Disabling it returns only search-level data (title, price, rating, image) but is much faster.

**Q: Why are some fields empty?**
A: Not all products have all data. For example, BSR is only shown for products ranked in a category, coupons only appear on discounted items, and Subscribe & Save is limited to eligible products.

**Q: Can I scrape Amazon without a proxy?**
A: Product pages (ASIN mode) often work without proxy. Search pages on some marketplaces may require residential proxies for consistent results.

**Q: How do I export the data?**
A: Results are stored in an Apify dataset. You can export as JSON, CSV, or Excel from the Apify console, or use the API/SDK to download programmatically.

### 📬 Support

We're building this scraper for **you**, your feedback makes it better for everyone!

- 💡 **Need a feature?** Tell us what's missing and we'll prioritize it
- ⚙️ **Custom solutions**: Contact us for enterprise integrations or high-volume needs

Check out our other scrapers: [SilentFlow on Apify](https://apify.com/silentflow)

# Actor input Schema

## `searches` (type: `array`):

Keywords to search for on Amazon (e.g. "wireless headphones", "iphone case"). Each query runs as a separate search.

## `country` (type: `string`):

Which Amazon marketplace to search.

## `asins` (type: `array`):

Scrape specific products by ASIN (the 10-character Amazon product ID, e.g. B071S5NPG9). You can find it in the product URL after /dp/.

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

Scrape specific Amazon URLs directly. Supports product pages (/dp/ASIN) and search result pages (/s?k=...). The country is auto-detected from the URL domain.

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

Maximum total number of products to return.

## `includeDetails` (type: `boolean`):

Fetch each product's detail page for richer data: reviews, BSR ranking, feature bullets, specifications, all images, seller info. Disable for faster results with basic data only (title, price, rating, image).

## `sort` (type: `string`):

How to order search results. Only applies to keyword searches.

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

Only return products priced at or above this value.

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

Only return products priced at or below this value.

## Actor input object example

```json
{
  "searches": [
    "iphone case"
  ],
  "country": "US",
  "maxItems": 10,
  "includeDetails": true,
  "sort": "relevance"
}
```

# Actor output Schema

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

All scraped products with full data.

## `resultsCSV` (type: `string`):

CSV format for spreadsheet analysis.

## `resultsExcel` (type: `string`):

Excel format export.

# 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 = {
    "searches": [
        "iphone case"
    ],
    "country": "US",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/amazon-scraper-ppe").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 = {
    "searches": ["iphone case"],
    "country": "US",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/amazon-scraper-ppe").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 '{
  "searches": [
    "iphone case"
  ],
  "country": "US",
  "maxItems": 10
}' |
apify call silentflow/amazon-scraper-ppe --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Scraper Ppe",
        "description": "Scrape Amazon product data from 17 marketplaces with pay-per-result pricing. Extract prices, reviews, ratings, BSR rankings, specifications, images, and seller info. No monthly fees, only pay for results. Supports keyword search, ASIN lookup, URL scraping, sorting, and price filtering.",
        "version": "1.0",
        "x-build-id": "FmVXJSaTSEaHV09wX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~amazon-scraper-ppe/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-amazon-scraper-ppe",
                "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/silentflow~amazon-scraper-ppe/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-amazon-scraper-ppe",
                "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/silentflow~amazon-scraper-ppe/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-amazon-scraper-ppe",
                "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": {
                    "searches": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search for on Amazon (e.g. \"wireless headphones\", \"iphone case\"). Each query runs as a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "JP",
                            "CA",
                            "AU",
                            "IN",
                            "BR",
                            "MX",
                            "NL",
                            "SE",
                            "PL",
                            "BE",
                            "SG"
                        ],
                        "type": "string",
                        "description": "Which Amazon marketplace to search.",
                        "default": "US"
                    },
                    "asins": {
                        "title": "Product ASINs",
                        "type": "array",
                        "description": "Scrape specific products by ASIN (the 10-character Amazon product ID, e.g. B071S5NPG9). You can find it in the product URL after /dp/.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Amazon URLs",
                        "type": "array",
                        "description": "Scrape specific Amazon URLs directly. Supports product pages (/dp/ASIN) and search result pages (/s?k=...). The country is auto-detected from the URL domain.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum total number of products to return.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Include full product details",
                        "type": "boolean",
                        "description": "Fetch each product's detail page for richer data: reviews, BSR ranking, feature bullets, specifications, all images, seller info. Disable for faster results with basic data only (title, price, rating, image).",
                        "default": true
                    },
                    "sort": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "price_asc",
                            "price_desc",
                            "avg_review",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to order search results. Only applies to keyword searches.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only return products priced at or above this value."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only return products priced at or below this value."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
