# Amazon DE Sellers Leads Scraper (`scraper-engine/amazon-de-sellers-leads-scraper`) Actor

Amazon DE Sellers Leads Scraper extracts seller data from Amazon.de — names, storefront URLs, ratings, categories, ASINs & Impressum contacts (emails/phones). 🚀 Ideal for B2B outreach, wholesale sourcing & brand partnerships. 📈 Export clean, CRM-ready leads fast.

- **URL**: https://apify.com/scraper-engine/amazon-de-sellers-leads-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

### Amazon DE Sellers Leads Scraper

Amazon DE Sellers Leads Scraper is a purpose-built Amazon.de seller leads scraper that extracts seller data from product pages and seller profiles on Amazon Germany. It solves the manual effort of finding seller contacts by automating discovery from search results or direct product URLs — ideal for sales teams, researchers, developers, and analysts who need an Amazon Germany seller leads extractor for B2B enrichment at scale. Use it to build an Amazon DE marketplace sellers database fast, with CRM-ready outputs for outreach and analysis.

### What data / output can you get?

Below are the structured fields pushed to the Apify dataset for each seller lead (one per product–seller pair). You can export results as JSON, CSV, or Excel from the dataset.

| Data type | Description | Example value |
| --- | --- | --- |
| asin | Product ASIN | B0FCS9LBVN |
| product_name | Product title | Ficerd 3er Pack Langarm Shirts für Damen... |
| product_url | Link to product page | https://www.amazon.de/dp/B0FCS9LBVN |
| seller_id | Amazon seller ID | A3OJWAJQNSBARP |
| seller_page_url | Link to seller profile | https://www.amazon.de/sp?ie=UTF8&seller=A3OJWAJQNSBARP |
| category | Breadcrumb category | Fashion > Damen > Bekleidung > Tops, T-Shirts & Blusen |
| rating_lifetime | Lifetime average rating (computed) | null |
| reviews_lifetime | Lifetime review count | null |
| rating_1_year | 1-year average rating (computed) | null |
| reviews_1_year | 1-year review count | null |
| about_seller | “About seller” text | Amazon Export Sales, LLC... |
| business_name | Registered business name | Amazon Export Sales LLC |
| business_type | Type of business | null |
| registration_number | Trade register number | 82-0544687 |
| vat_number | VAT ID | null |
| phone_number | Phone | +1206-266-1000 |
| email | Email | ags-prodm-us-de@amazon.com |
| business_address | Full address | 410 TERRY AVE N, Seattle, WA, 98109-5210, US |
| country_code | Country code (from address line) | US |

Note: Some sellers do not publish complete business details or ratings. In those cases, the relevant fields return null.  

### Key features

- 🚀 Bold parallel pipeline
  - Fetches search pages and product pages concurrently, then processes seller profile and business info in parallel. This accelerates lead collection for large Amazon Germany merchants list extraction.

- 🧠 Smart proxy fallback
  - Starts with no proxy. If Amazon.de blocks requests, it automatically falls back to Datacenter proxy, then Residential proxy with up to 3 retries per request — all with clear log messages.

- 🧩 Flexible input modes
  - Use Amazon.de search URLs or direct product URLs via startUrls, or switch to keyword + category search with sort_by. Perfect for Amazon Germany seller list scraping or product-focused prospecting.

- 🔁 Deduplicated results
  - Ensures each unique (ASIN, seller_id) pair is stored once, preventing duplicates in your Amazon DE vendor leads scraper workflows.

- 💾 Live dataset streaming
  - Each seller lead is pushed to the dataset as soon as it’s scraped — you keep your Amazon DE seller prospects even if a run stops early.

- 📦 Structured, CRM-ready output
  - Consistent JSON fields for ASINs, categories, ratings, and Impressum details (emails/phones). Export to CSV/JSON and plug into your CRM or analytics stack for Amazon Germany B2B leads scraping.

- 🔧 Tuning & control
  - Cap the run with maxResults (1–500). Control search sorting with sort_by for more targeted Amazon.de merchant leads extraction.

- 🛡️ Production-ready reliability
  - Robust request headers, randomized delays, and concurrency controls reduce blocks and improve stability when running your Amazon DE seller data scraping tool at scale.

### How to use Amazon DE Sellers Leads Scraper - step by step

1. Sign in to your Apify account at console.apify.com.
2. Open the “Amazon DE Sellers Leads Scraper” actor from your dashboard.
3. Choose your input method:
   - Paste Amazon.de search or product URLs into startUrls, or
   - Fill in keyword and amazon_category (both required for keyword mode). Optionally set sort_by.
4. Set maxResults to limit unique seller leads (1–500; default: 100).
5. Configure proxyConfiguration. By default it runs without a proxy and will automatically fall back to Datacenter then Residential if blocked.
6. Click Start to launch the run. Watch the Log tab to see progress, page counts, and proxy fallback messages.
7. When finished, go to the Dataset tab to view results and export to JSON or CSV.

Pro Tip: For focused outreach lists, paste multiple search URLs in startUrls to seed the Amazon DE marketplace sellers database with higher relevance immediately.

### Use cases

| Use case name | Description |
| --- | --- |
| B2B lead generation for Amazon.de | Build targeted outreach lists with seller emails and phones from Impressum pages using this Amazon.de seller contact scraper. |
| Wholesale sourcing & brand partnerships | Identify active retailers by category and extract business details to accelerate supplier discovery on Amazon Germany. |
| Category & competitor research | Map sellers by keyword + category and analyze ratings and addresses for market insights with an Amazon Germany seller list scraper. |
| Compliance and verification | Collect business_name, registration_number, VAT, and address to verify merchants for due diligence. |
| Amazon FBA Germany seller leads | Gather seller profiles from product pages to enrich your Amazon FBA Germany seller leads scraper workflows. |
| CRM enrichment | Export structured JSON/CSV and upload to your CRM for sales and account-based marketing. |
| Data pipelines for analysts | Automate Amazon Germany seller leads extraction into data warehouses for dashboards and segmentation. |

### Why choose Amazon DE Sellers Leads Scraper?

Built for precision, automation, and reliability — this Amazon Germany seller leads generator streamlines prospecting from Amazon.de into structured, compliant datasets.

- ✅ Accurate, structured outputs aligned to real seller pages and Impressum details
- 🌍 Works with Amazon.de public pages — no login or cookies required
- ⚡ Parallelized pipeline for scale — ideal for bulk Amazon.de merchant leads extractors
- 🔌 Developer-friendly dataset format for downstream workflows and APIs
- 🛡️ Smart proxy fallback (No proxy → Datacenter → Residential) for reliable runs
- 💸 Cost-efficient compared to manual copy-paste or unstable browser extensions
- 🔁 Deduplication by (ASIN, seller_id) to keep datasets clean

In short, it’s a production-ready Amazon DE seller contact finder that outperforms brittle tools with clean outputs and robust anti-blocking strategy.

### Is it legal / ethical to use Amazon DE Sellers Leads Scraper?

Yes — when used responsibly. The actor accesses only publicly available Amazon.de pages (product pages and seller profile/business info pages) and does not log in or access private data.

Guidelines for compliant use:
- Collect only public information visible on Amazon.de.
- Respect platform terms and local regulations (e.g., GDPR, data protection, anti-spam laws).
- Use contact data responsibly for legitimate B2B purposes.
- Avoid scraping personal or authenticated content.
- Consult your legal team for edge cases and storage/processing policies.

### Input parameters & output format

#### Example input
```json
{
  "startUrls": [
    { "url": "https://www.amazon.de/s?k=shirt&i=fashion-womens" }
  ],
  "sort_by": "Featured",
  "maxResults": 50,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

- keyword (string, required by schema, default: "shirt")\
  Product or search term used to build the Amazon.de search and find sellers.
- amazon\_category (string, required by schema, default: "fashion-womens")\
  Amazon.de category ID for the search (e.g., fashion-womens).
- sort\_by (string, optional, default: "Featured")\
  Sort order for search results. Supported values: Featured, Best Sellers, Price: Low to High, Price: High to Low, Avg. Customer Review, Newest Arrivals, Relevance, Select....
- maxResults (integer, optional, default: 100; min: 1, max: 500)\
  Maximum number of unique seller leads to collect per run.
- startUrls (array, optional)\
  Amazon.de search or product URLs to process. Items should be objects like { "url": "https://..." }.
- proxyConfiguration (object, optional, default prefill: { "useApifyProxy": false })\
  Proxy settings. By default the actor starts without a proxy and will fall back to Datacenter then Residential proxies if blocked.

Note: Provide startUrls or both keyword and amazon\_category. In keyword mode, both fields are required.

#### Example output item

```json
{
  "asin": "B0FCS9LBVN",
  "product_name": "Ficerd 3er Pack Langarm Shirts für Damen...",
  "product_url": "https://www.amazon.de/dp/B0FCS9LBVN",
  "seller_id": "A3OJWAJQNSBARP",
  "seller_page_url": "https://www.amazon.de/sp?ie=UTF8&seller=A3OJWAJQNSBARP",
  "category": "Fashion > Damen > Bekleidung > Tops, T-Shirts & Blusen",
  "rating_lifetime": null,
  "reviews_lifetime": null,
  "rating_1_year": null,
  "reviews_1_year": null,
  "rating_3_months": null,
  "reviews_3_months": null,
  "about_seller": "Amazon Export Sales, LLC...",
  "business_name": "Amazon Export Sales LLC",
  "business_type": null,
  "registration_number": "82-0544687",
  "vat_number": null,
  "phone_number": "+1206-266-1000",
  "email": "ags-prodm-us-de@amazon.com",
  "business_address": "410 TERRY AVE N, Seattle, WA, 98109-5210, US",
  "country_code": "US"
}
```

Fields that may return null include ratings, about\_seller, business\_type, registration\_number, vat\_number, phone\_number, email, business\_address, and country\_code if the seller does not publish them.

### FAQ

#### Do I need a proxy to run this Amazon.de seller leads scraper?

No. By default, it starts with no proxy. If Amazon.de blocks requests, it automatically falls back to Datacenter proxy and then to Residential proxy, with up to 3 retries per request on Residential. You’ll see clear fallback messages in the logs.

#### Can I use search URLs and product URLs?

Yes. Add Amazon.de search or product URLs in startUrls. For search URLs, the actor paginates and queues products; for product URLs, it extracts the ASIN and processes the single product page to find the seller.

#### Are keyword and category required?

If you run keyword mode, both keyword and amazon\_category are required (as defined in the input schema). Alternatively, you can supply startUrls (search or product) and skip keyword mode.

#### How many seller leads can I extract per run?

You control this via maxResults. It supports 1–500 unique seller leads per run (default: 100). The actor stops once it reaches your target.

#### What seller data does this Amazon Germany seller leads extractor return?

It returns ASIN, product\_name, product\_url, seller\_id, seller\_page\_url, category, ratings (lifetime, 1-year, 3-months), about\_seller, and business details such as business\_name, registration\_number, VAT, phone, email, address, and country\_code when available.

#### Why are some fields null?

Not all sellers display complete business or ratings information. The actor only returns what’s present on public pages. Missing entries are set to null to keep the schema consistent for analytics and CRM imports.

#### Can I export the Amazon DE marketplace sellers database to CSV or JSON?

Yes. Open the run’s Dataset and export to JSON, CSV, or Excel with a single click. This makes it easy to use the results in CRMs or spreadsheets.

#### Does it deduplicate results?

Yes. It ensures each (ASIN, seller\_id) pair is stored once, preventing duplicates when generating Amazon.de merchant leads lists across multiple pages.

#### Is login required to scrape Amazon.de sellers?

No. The actor only accesses public Amazon.de pages and does not require login or cookies.

#### Will it find emails and phone numbers for Amazon.de sellers?

When sellers publish contact details on their business information pages (Impressum), the actor extracts email and phone\_number fields. If those details aren’t shown, the fields return null.

### Closing CTA / Final thoughts

Amazon DE Sellers Leads Scraper is built to generate clean, structured Amazon.de seller leads at scale. With smart proxy fallback, parallel extraction, deduplication, and CRM-ready outputs, it’s ideal for marketers, developers, data analysts, and researchers targeting the German marketplace.

Run it with search URLs or keyword + category, cap results with maxResults, and export your Amazon Germany B2B leads to JSON or CSV. Developers can plug the dataset into pipelines and automation workflows with ease. Start extracting smarter seller insights from Amazon.de today.

# Actor input Schema

## `keyword` (type: `string`):

Product or search term (e.g. shirt, shoes). Used to build the Amazon.de search and find sellers.

## `amazon_category` (type: `string`):

Amazon.de category for the search. Values are sent as category ID in the search URL (e.g. fashion-womens).

## `sort_by` (type: `string`):

Sort order for search results.

## `maxResults` (type: `integer`):

Maximum number of unique seller leads to collect per run (1–500).

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

Optional: Amazon.de search or product URLs. If provided, these are used in addition to or instead of the product type + category search.

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

Default: no proxy. If Amazon blocks requests, the actor falls back to Datacenter proxy, then Residential (with 3 retries).

## Actor input object example

```json
{
  "keyword": "shirt",
  "amazon_category": "fashion-womens",
  "sort_by": "Featured",
  "maxResults": 100,
  "startUrls": [],
  "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": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/amazon-de-sellers-leads-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": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/amazon-de-sellers-leads-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": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/amazon-de-sellers-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon DE Sellers Leads Scraper",
        "description": "Amazon DE Sellers Leads Scraper extracts seller data from Amazon.de — names, storefront URLs, ratings, categories, ASINs & Impressum contacts (emails/phones). 🚀 Ideal for B2B outreach, wholesale sourcing & brand partnerships. 📈 Export clean, CRM-ready leads fast.",
        "version": "1.0",
        "x-build-id": "i7iR60pruKnq5yhXf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~amazon-de-sellers-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-amazon-de-sellers-leads-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/scraper-engine~amazon-de-sellers-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-amazon-de-sellers-leads-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/scraper-engine~amazon-de-sellers-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-amazon-de-sellers-leads-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": [
                    "keyword",
                    "amazon_category"
                ],
                "properties": {
                    "keyword": {
                        "title": "Product type you are looking sellers for (required)",
                        "type": "string",
                        "description": "Product or search term (e.g. shirt, shoes). Used to build the Amazon.de search and find sellers.",
                        "default": "shirt"
                    },
                    "amazon_category": {
                        "title": "Amazon Category (required)",
                        "enum": [
                            "fashion-womens",
                            "fashion-mens",
                            "fashion-kids",
                            "electronics",
                            "grocery",
                            "toys",
                            "sports",
                            "books",
                            "beauty",
                            "home-garden",
                            "automotive",
                            "pet-supplies",
                            "tools-garden",
                            "baby",
                            "health"
                        ],
                        "type": "string",
                        "description": "Amazon.de category for the search. Values are sent as category ID in the search URL (e.g. fashion-womens).",
                        "default": "fashion-womens"
                    },
                    "sort_by": {
                        "title": "Sort By",
                        "enum": [
                            "Featured",
                            "Best Sellers",
                            "Price: Low to High",
                            "Price: High to Low",
                            "Avg. Customer Review",
                            "Newest Arrivals",
                            "Relevance",
                            "Select..."
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "Featured"
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of unique seller leads to collect per run (1–500).",
                        "default": 100
                    },
                    "startUrls": {
                        "title": "URLs (Search or Product)",
                        "type": "array",
                        "description": "Optional: Amazon.de search or product URLs. If provided, these are used in addition to or instead of the product type + category search.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Default: no proxy. If Amazon blocks requests, the actor falls back to Datacenter proxy, then Residential (with 3 retries)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
