# Amazon Search Products Scraper (`scrapelabsapi/amazon-search-products-scraper`) Actor

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

## Pricing

from $3.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

### 🤖 What is Amazon Search Products Scraper?

Amazon Search Products Scraper is an intelligent Amazon product data extraction tool that lets you scrape product listings, prices, ASINs, images, reviews, and other key metrics directly from Amazon’s search results. Whether you’re conducting market research, competitive pricing analysis, or dropshipping product research in 2025, this scraper helps you turn Amazon’s massive catalog into actionable datasets.

It works with Amazon search URLs, keywords, and filters, allowing you to get structured JSON or CSV data within minutes. Compared to manual copy-pasting or browser plugins, it’s faster, scalable, and doesn’t require coding.

✨ SEO Benefits:

*   Collect real-time product data for keyword optimization.  
      
    
*   Enhance your Amazon affiliate content with live pricing and ranking data.  
      
    
*   Identify trending products to build high-converting pages faster.  
      
    

* * *

### 📦 What “Amazon Search Products Scraper” Can Extract

| 🧩 Data Type | 📋 Description | 💡 Example Output |
| --- | --- | --- |
| ASIN | Unique Amazon product ID | B0BZXLMM3H |
| Title | Product name from search results | “Under Armour Men's Charged Surge 4 Sneaker” |
| Price | Listed price or range | $45.95 |
| Rating | Average customer rating | 4.5 out of 5 stars |
| Reviews | Number of reviews | 4,675 |
| Product URL | Canonical link to product page | https://www.amazon.com/dp/B0BZXLMM3H |
| Image URL | Thumbnail from search result | Amazon image link |
| Delivery Info | Shipping and delivery details | “FREE delivery Sun, Jun 8” |
| Sponsored/Prime | Flag for sponsored or Prime listings | true / false |

✅ Supports Amazon marketplaces including .com, .co.uk, .de, .in, .jp, .fr, and more.

* * *

#### 🌟 Key Features of Amazon Search Products Scraper

*   Multi-region scraping: Works with 20+ Amazon locales globally 🌍  
      
    
*   Advanced filters: Sort by price, reviews, or best sellers  
      
    
*   Powerful proxy support: Integrates with Apify proxies or custom proxy APIs for stable runs  
      
    
*   No coding required: Works instantly — ideal for beginners  
      
    
*   High scalability: Extract thousands of listings per query  
      
    
*   Flexible output: Export results to JSON, CSV, Excel, or via Amazon Scraper API  
      
    
*   Automation-ready: Connect with Zapier, Make, Google Sheets, Slack, or your database  
      
    
*   Open-source compatible: Inspired by top tools like amazon-scraper GitHub and amazon scraper Python  
      
    

Perfect for marketers, sellers, developers, and data analysts who need Amazon insights at scale 🚀

* * *

### 🧭 How to Use Amazon Search Products Scraper

#### Step-by-Step Guide

1.  Log in to Apify 🟢 – Create a free account or sign in.  
      
    
2.  Select the Actor – Search for “Amazon Search Products Scraper” in the Apify Store.  
      
    
3.  Enter Input Data – Add your Amazon search URL or keywords (e.g., https://www.amazon.com/s?k=wireless+headphones).  
      
    
4.  Configure Options – Choose filters like lowPrice, highPrice, category, or sortBy.  
      
    
5.  Run the Actor – Click Start to begin scraping; progress updates in real time.  
      
    
6.  View & Download Results – Export data to CSV, JSON, Excel, or connect via the Amazon Scraper API for automation.  
      
    

💡 Tip: Enable Residential Proxies for higher success rates and use pagination for deeper searches.

#### 🔧 If the Actor is marked "Under maintenance"

Apify marks an Actor as under maintenance when daily automated tests fail (e.g. run doesn’t finish successfully within the time limit). To fix this:

- **Use Apify Proxy** – In the Actor input, set **Proxy configuration** to use Apify Proxy. Amazon often blocks direct requests; using proxy helps the run (and automated tests) succeed.
- **Prefill required input** – Ensure **Enter Amazon Keywords or Search URLs** has at least one keyword or URL (the default prefill is fine).
- **Skip QA** – In the Actor’s build/settings on Apify, you can disable automated tests (“Skip QA”) if this Actor is meant to run only with proxy or custom input.

* * *

### 🎯 Real-World Use Cases

| 💼 Use Case | ⚙️ Description |
| --- | --- |
| E-Commerce Research | Identify trending items, track competitors, and optimize product listings. |
| Affiliate Marketing | Collect product data for content creation, comparison blogs, or niche sites. |
| Dropshipping Product Research 2025 | Find high-demand, low-competition items to add to your store. |
| Market Analytics | Benchmark product pricing and performance across regions. |
| Amazon Seller Scraper Use | Monitor competitor sellers and listings. |
| AI Product Research Tools | Feed Amazon data into machine learning models for trend forecasting. |

Use it as a junglee free Amazon product scraper alternative or combine it with Amazon Scraper Chrome Extension tools for hybrid workflows.

* * *

### 💎 Why Choose Us?

*   ⚙️ No coding, no setup hassle – everything works instantly online.  
      
    
*   🧠 Powered by Apify – stable cloud infrastructure for 24/7 automation.  
      
    
*   📊 Comprehensive output – ASINs, ratings, delivery info, and more.  
      
    
*   💬 Integrations ready – Connect with Zapier, Google Sheets, or Slack.  
      
    
*   🧩 Flexible for developers – Works perfectly with amazon-scraper GitHub libraries.  
      
    
*   🔒 Secure and ethical scraping – respects Amazon’s data policies.  
      
    

Whether you’re a startup, agency, or solo entrepreneur, Amazon Search Products Scraper online gives you the competitive edge you need.

* * *

### ⚡ How Many Results Can You Scrape?

Scalability is our superpower! 💪  
On average, the Amazon Search Products Scraper can extract over 100,000 results per run, depending on:

*   Input complexity (keywords, filters, regions)  
      
    
*   Pagination depth  
      
    
*   Proxy settings and location  
      
    
*   Product availability on Amazon  
      
    

You can start small (1–2 pages) and scale up seamlessly. There’s no hard limit, but Amazon’s own pagination and internal restrictions can vary by search.

For enterprise-grade users, we recommend combining the Apify Amazon Scraper API with scheduling tools to continuously monitor products, prices, and reviews in real time.

* * *

### ⚖️ Is It Legal to Scrape Amazon?

Scraping publicly available product data such as titles, prices, or ratings is generally legal ✅ — as long as it doesn’t violate Amazon’s Terms of Service or privacy laws.

#### Ethical Best Practices:

*   Respect robots.txt and rate limits.  
      
    
*   Avoid collecting personal or user-specific data.  
      
    
*   Use proxies responsibly to prevent excessive requests.  
      
    
*   Stay compliant with regulations like GDPR and CCPA.  
      
    

For detailed guidance, check out Apify’s article on “Is Web Scraping Legal?” or consult a legal professional before scaling large operations.

* * *

### ⚙️ Input Parameters

#### 🧾 JSON Example

```json
{
  "startUrls": [
    { "url": "Playstation" },
    { "url": "https://www.amazon.com/s?k=TV" },
    { "url": "Shoes" }
  ],
  "amazonDomain": "amazon.com",
  "sortOrder": "relevanceblender",
  "maxPages": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

| 🏷️ Parameter | 📖 Description | 🧠 Example |
| --- | --- | --- |
| query | Keyword to search for products | "gaming laptop" |
| category | Optional Amazon category | "electronics" |
| sortBy | Sorting method (featured, priceLowtoHigh, etc.) | "bestSellers" |
| lowPrice / highPrice | Price filter range | 20 / 200 |
| page | Pagination starting point | 1 |
| countryIso | Country locale code | "us" |

***

### 📤 Output Format

#### 🧾 JSON Example

```json
[
  {
    "asin": "B0CL5KNB9M",
    "productDescription": "PlayStation®5 Digital Edition (slim)",
    "imgUrl": "https://m.media-amazon.com/images/I/51fM0CKG+HL._AC_UY218_.jpg",
    "price": null,
    "retailPrice": null,
    "productRating": "4.7 out of 5 stars",
    "countReview": 10500,
    "dpUrl": "/PlayStation%C2%AE5-Digital-slim-PlayStation-5/dp/B0CL5KNB9M/ref=sr_1_1?...",
    "prime": false,
    "sponsored": false,
    "salesVolume": "7K+ bought in past month",
    "deliveryMessage": null,
    "manufacturer": "Amazon's Choice: Overall Pick",
    "series": null,
    "variations": [],
    "productDetails": [
      "Nov 24, 2023",
      "No featured offers available"
    ],
    "secondaryOffer": 0.0,
    "statusCode": 200,
    "statusMessage": "FOUND",
    "keyword": "Playstation",
    "domainCode": "com",
    "page": 1,
    "selectedCategory": "aps",
    "browseNode": null,
    "nodeHierarchy": null,
    "resultCount": 50000,
    "categories": [],
    "similarKeywords": [
      {
        "keyword": "playstation 5",
        "url": "/s?k=playstation+5&ref=rsl_sug_0_0&..."
      },
      {
        "keyword": "playstation gift card",
        "url": "/s?k=playstation+gift+card&ref=rsl_sug_0_3&..."
      }
    ],
    "currentPage": 1,
    "sortStrategy": "relevanceblender",
    "searchResultPosition": 0
  }
]
```

| 🧩 Field | 📋 Description | 🧠 Example |
| --- | --- | --- |
| asin | Unique product identifier | B0BZXLMM3H |
| title | Product name | “Under Armour Men’s Charged Surge 4 Sneaker” |
| price | Product price | $45.95 |
| rating | Customer rating | 4.5 |
| reviews | Total number of reviews | 4675 |
| url | Product link | Amazon product URL |
| image | Product thumbnail | Image URL |

***

### ❓ FAQ – Amazon Search Products Scraper

#### 1️⃣ Is Amazon Search Products Scraper free?

Yes! You can start with a free tier on Apify or try the Amazon Search Products Scraper free version online.

#### 2️⃣ Does it support all Amazon countries?

Absolutely! Supports 20+ countries including US, UK, IN, JP, DE, FR, and AU.

#### 3️⃣ Is there a Chrome extension available?

You can pair it with the Amazon Scraper Chrome Extension for browser-based searches.

#### 4️⃣ Can I use it with Python or GitHub?

Yes! Integrate results into scripts via Amazon Scraper Python or Amazon-Scraper GitHub repositories.

#### 5️⃣ Is this tool suitable for Amazon sellers?

Definitely — it’s also known as an Amazon Seller Scraper, perfect for tracking competition.

#### 6️⃣ Can it be automated?

Yes! Schedule runs via the Apify API or connect through Zapier for real-time automation.

#### 7️⃣ Is it beginner-friendly?

100%! It’s designed for non-coders, with one-click scraping and downloadable datasets.

#### 8️⃣ What’s the best use case in 2025?

Amazon dropshipping product research 2025 — uncover trending, profitable products fast 🚀

### 🏁 Final Note

The Amazon Search Products Scraper is your all-in-one solution to scrape Amazon products at scale — whether for market intelligence, dropshipping research, or affiliate marketing optimization.

💡 By combining Apify’s automation power, proxy reliability, and flexible API access, this tool outperforms traditional Amazon scraper Chrome extensions and junglee free Amazon product scrapers.

# Actor input Schema

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

📝 Add keywords (e.g., 'Playstation', 'TV') or full Amazon search URLs. Each item runs as a separate search.

## `amazonDomain` (type: `string`):

🌍 Choose which Amazon marketplace to scrape (e.g., amazon.com, amazon.co.uk, amazon.de). Default: amazon.com

## `language` (type: `string`):

🧭 Set page language for better localization. Leave empty to auto-detect from the selected domain.

## `proxyCountry` (type: `string`):

📍 Select proxy country manually, or keep AUTO for automatic selection based on Amazon domain.

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

📊 Choose how Amazon results are sorted: relevance, price low/high, customer reviews, or newest arrivals.

## `maxPages` (type: `integer`):

🔢 Set the max pages to scrape for each search. Keep 1 to allow auto-continue mode (stops after 2 consecutive empty pages), or raise it to enforce a strict limit.

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

🧱 Configure proxy behavior. Default: no proxy. If blocked, actor can automatically fall back to datacenter and residential proxies.

## Actor input object example

```json
{
  "startUrls": [
    "Playstation",
    "https://www.amazon.com/s?k=TV"
  ],
  "amazonDomain": "amazon.com",
  "language": "",
  "proxyCountry": "AUTO",
  "sortOrder": "relevanceblender",
  "maxPages": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        "Playstation",
        "https://www.amazon.com/s?k=TV"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapelabsapi/amazon-search-products-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 = {
    "startUrls": [
        "Playstation",
        "https://www.amazon.com/s?k=TV",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapelabsapi/amazon-search-products-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 '{
  "startUrls": [
    "Playstation",
    "https://www.amazon.com/s?k=TV"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapelabsapi/amazon-search-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Search Products Scraper",
        "version": "0.1",
        "x-build-id": "n1yjjMOBHJqwuxsvf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapelabsapi~amazon-search-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapelabsapi-amazon-search-products-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/scrapelabsapi~amazon-search-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapelabsapi-amazon-search-products-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/scrapelabsapi~amazon-search-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapelabsapi-amazon-search-products-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔍 Enter keywords or Amazon search URLs",
                        "type": "array",
                        "description": "📝 Add keywords (e.g., 'Playstation', 'TV') or full Amazon search URLs. Each item runs as a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "amazonDomain": {
                        "title": "🌐 Amazon domain (optional)",
                        "type": "string",
                        "description": "🌍 Choose which Amazon marketplace to scrape (e.g., amazon.com, amazon.co.uk, amazon.de). Default: amazon.com",
                        "default": "amazon.com"
                    },
                    "language": {
                        "title": "🗣️ Language (optional)",
                        "enum": [
                            "",
                            "en-US",
                            "en-GB",
                            "de-DE",
                            "fr-FR",
                            "es-ES",
                            "it-IT",
                            "ja-JP",
                            "zh-CN"
                        ],
                        "type": "string",
                        "description": "🧭 Set page language for better localization. Leave empty to auto-detect from the selected domain.",
                        "default": ""
                    },
                    "proxyCountry": {
                        "title": "🛡️ Proxy country (optional)",
                        "enum": [
                            "AUTO",
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "CA",
                            "AU",
                            "JP"
                        ],
                        "type": "string",
                        "description": "📍 Select proxy country manually, or keep AUTO for automatic selection based on Amazon domain.",
                        "default": "AUTO"
                    },
                    "sortOrder": {
                        "title": "↕️ Search result sort order (optional)",
                        "enum": [
                            "relevanceblender",
                            "price-asc-rank",
                            "price-desc-rank",
                            "review-rank",
                            "date-desc-rank"
                        ],
                        "type": "string",
                        "description": "📊 Choose how Amazon results are sorted: relevance, price low/high, customer reviews, or newest arrivals.",
                        "default": "relevanceblender"
                    },
                    "maxPages": {
                        "title": "📄 Maximum pages per search (optional)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "🔢 Set the max pages to scrape for each search. Keep 1 to allow auto-continue mode (stops after 2 consecutive empty pages), or raise it to enforce a strict limit.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "⚙️ Proxy configuration (optional)",
                        "type": "object",
                        "description": "🧱 Configure proxy behavior. Default: no proxy. If blocked, actor can automatically fall back to datacenter and residential proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
