# Amazon Contact Extractor (`scraperoka/amazon-contact-extractor`) Actor

📇 Extract contact data from websites faster with Amazon Contact Extractor. Effortlessly pull emails, phone numbers & more for lead generation, sales, and outreach. ⚡ Save time, boost productivity, and reach the right customers.

- **URL**: https://apify.com/scraperoka/amazon-contact-extractor.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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 Contact Extractor 📬

**Amazon Contact Extractor** is a dedicated tool for extracting Amazon contact emails and profile details from publicly available web data, so you can quickly build targeted prospect lists. If you’re searching for an *Amazon contact extractor*, an *Amazon email scraper*, or an *Amazon lead extraction tool*, this actor helps you turn “search → contact list” into one automated workflow. Whether you're a marketer, data analyst, researcher, or outreach specialist, it’s designed to support B2B and B2C lead generation and save you hours of manual work.

---

### Why choose Amazon Contact Extractor?

| Feature | Benefit |
|---|---|
| ✅ **All-in-one Amazon contact extraction** | Extract emails alongside profile metadata (title, URL, description, and more) in one run |
| ✅ **Region support (source region + country)** | Target results with a selected regional index and a country setting |
| ✅ **B2B or B2C email targeting** | Collect contacts based on your selected `emailType` choice |
| ✅ **Reliability-focused scraping engine options** | Choose between `cost-effective` and `legacy` engines for different performance/reliability tradeoffs |
| ✅ **Structured dataset output** | Receive consistent fields like `email`, `email_domain`, `email_type`, and `scrape_from` |
| ✅ **Scale via email limits** | Control volume with `maxEmails` to collect up to your desired number of emails |

---

### Key features

- 🔍 **Accurate email + profile data capture**: Produces structured records with `email` and profile context (`title`, `url`, `description`)
- 🌍 **Regional Amazon targeting**: Use `sourceRegion` to focus on the regional Amazon index you need
- 🎯 **B2C vs B2B email extraction**: Choose `emailType` to guide whether you’re collecting B2C or B2B contacts
- 🧩 **Keyword-driven extraction**: Provide `searchTerms` to drive how the actor builds its extraction targets
- 🛡️ **Resilience with selectable scraping engine**: Pick `engine` (`cost-effective` or `legacy`) depending on your reliability and speed needs
- 💾 **Real-time dataset storage**: Records are saved to the dataset in a consistent table-friendly structure
- 📊 **Domain-level enrichment**: Includes `email_domain` so you can segment leads quickly
- ✅ **Volume control**: Set `maxEmails` (min 1, max 10000) to stay within your collection budget

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "searchTerms": [
    "fitness",
    "gym",
    "workout"
  ],
  "country": "United States",
  "sourceRegion": "Amazon US",
  "emailType": "B2C",
  "maxEmails": 20,
  "engine": "legacy"
}
````

#### Input Fields

| Key | Required | Description |
|---|---:|---|
| `searchTerms` | ✅ | A list of queries to find Amazon profiles. Use terms that match the audience you want to reach (e.g., fitness/gym/workout). |
| `country` | ✅ | Specify the country to target for country-based results filtering. Default is `United States`. |
| `sourceRegion` | ✅ | Select the regional index to target on Amazon (for example, `Amazon US`, `Amazon Germany`, `Amazon UK`, etc.). |
| `emailType` | ✅ | Choose one — `B2C` or `B2B` — to decide the type of contacts the extractor is looking for. |
| `maxEmails` | ✅ | Enter the maximum number of emails to collect (min 1, max 10000). Default is `20`. |
| `engine` | ❌ | Choose scraping engine. `cost-effective` (Cost Effective (New)) uses residential proxies with async requests for faster/cheaper scraping; `legacy` uses a legacy approach that can be more reliable but slower and more expensive. Default is `legacy`. |

***

### Output

The actor saves each extracted contact record into an Apify dataset in JSON format.

```json
{
  "keyword": "fitness",
  "title": "Example Profile Title",
  "url": "https://www.amazon.com/...",
  "description": "Example description text from the profile listing.",
  "email": "contact@example.com",
  "email_domain": "example.com",
  "email_type": "B2C",
  "scrape_from": "Amazon US",
  "country": "United States"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | The keyword (from your `searchTerms`) connected to this extracted record |
| `title` | string | The profile title captured during extraction |
| `url` | string | A link to the profile page (saved for easy review) |
| `description` | string | Descriptive text associated with the listing/profile |
| `email` | string | The extracted email address (when found) |
| `email_domain` | string | The domain part of the email (e.g., `example.com`) for fast segmentation |
| `email_type` | string | The email type used for collection (B2C or B2B) |
| `scrape_from` | string | The region source indicator tied to the run (based on your `sourceRegion`) |
| `country` | string | The country value used for targeting (based on your `country`) |

After the run, export the dataset to JSON/CSV using Apify’s built-in export options to plug the Amazon contact data into your CRM or outreach workflows.

***

### How to use Amazon Contact Extractor (via Apify Console)

1. **Open Apify Console**\
   Go to the Apify Console: <https://console.apify.com> and sign in.

2. **Find the actor**\
   Search for **Amazon Contact Extractor** and open its actor page.

3. **Configure input settings**\
   In the **INPUT** section, enter the required fields:
   `searchTerms`, `country`, `sourceRegion`, `emailType`, and `maxEmails`.\
   Optionally set `engine` to `cost-effective` or `legacy` depending on your needs.

4. **Set your email volume**
   Use `maxEmails` to define how many emails you want to collect in this run (up to 10000).

5. **Run the actor**
   Click **Run** to start extraction. During the run, watch the logs for progress and reliability-related messages.

6. **Review results in the dataset**
   When the run finishes, open the dataset in the **OUTPUT** tab. You’ll see the table view with fields like `email`, `email_domain`, `email_type`, and `url`.

7. **Export for outreach or analysis**
   Export to JSON/CSV and import into your spreadsheet, CRM, or data pipeline.

No coding required — get accurate Amazon contact extraction results in minutes. 🚀

***

### Advanced features & SEO optimization

- ⚙️ **Engine choice for Amazon email scraper workflows**: Use `engine` (`cost-effective` or `legacy`) to balance speed and reliability for your Amazon contact data scraper needs.
- 🔎 **Keyword-driven lead extraction**: Feed `searchTerms` to generate outreach email lists with an Amazon outreach email list extractor approach.
- 🧱 **Structured output designed for segmentation**: The dataset includes `email_domain` and `email_type`, making an Amazon contact list scraper workflow much easier downstream.
- 📊 **Region + country targeting together**: Combine `sourceRegion` and `country` to match the market you’re researching or prospecting.

***

### Best use cases

- 📈 **Lead generation teams building Amazon contact list scraper pipelines**: Rapidly assemble outreach-ready contact data with consistent fields for onboarding into your outreach tools.
- 🧠 **Researchers validating market segments**: Use `sourceRegion`, `country`, and `email_domain` to analyze where contacts cluster across niches like fitness, gym, or workout.
- ✉️ **Sales & partnerships prospecting**: Extract emails for B2B or B2C engagement by selecting `emailType` and limiting volume with `maxEmails`.
- 🛠️ **Marketing ops building automated enrichment steps**: Turn automated Amazon contact extraction software runs into standardized inputs for CRM updates.
- 💻 **Data analysts creating outreach-ready datasets**: Use the structured dataset fields (`title`, `url`, `description`, `email`) for analysis and quality checks.
- 🧾 **Community managers curating business contact finder lists**: Find relevant Amazon business contacts and export them as a table-ready dataset.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ JSON input matching the actor schema (object with required fields: `searchTerms`, `country`, `sourceRegion`, `emailType`, `maxEmails`)

- **Proxy Support**
  - ✅ Built-in proxy support via the selectable `engine` option (`cost-effective` or `legacy`)

- **Retry Mechanism**
  - ✅ Includes resilience features (retries and fallback behavior) controlled by the selected scraping engine approach

- **Dataset Structure**
  - ✅ Dataset view named **Scraped Emails** with these fields:
    `keyword`, `title`, `url`, `description`, `email`, `email_domain`, `email_type`, `scrape_from`, `country`

- **Rate Limits & Performance**
  - ✅ Performance depends on engine choice and your `maxEmails` volume setting

- **Limitations**
  - ❌ Only email/profile details that are available from publicly available sources can be extracted
  - ❌ If emails are not present in the available data for a given listing, the `email` field may be empty/absent for that record

***

### FAQ

#### What does Amazon Contact Extractor scrape?

✅ Amazon Contact Extractor extracts email addresses and related profile details (such as `title`, `url`, and `description`) from publicly available data sources, then stores the results in a structured dataset you can export.

#### Can I choose between B2B and B2C email extraction?

✅ Yes. Use the `emailType` input to choose either `B2C` or `B2B`, depending on the audience you’re targeting with your Amazon outreach email list extractor workflow.

#### How do I control how many emails I collect?

✅ Set `maxEmails`. It accepts values from **1 to 10000** and defaults to `20`.

#### Which Amazon region can I target?

✅ You can select a `sourceRegion` from the provided regional index options (for example `Amazon US`, `Amazon UK`, `Amazon Germany`, etc.). The selected region is reflected in the dataset field `scrape_from`.

#### Is there a way to adjust reliability vs speed?

✅ Yes. Use the `engine` input. Select `cost-effective` for a faster/cheaper residential-proxy approach, or `legacy` for a more traditional approach with different performance tradeoffs.

#### What output fields will I get?

✅ Each dataset record includes: `keyword`, `title`, `url`, `description`, `email`, `email_domain`, `email_type`, `scrape_from`, and `country`.

#### Do I need to write code to use this actor?

✅ No. You can run it directly from Apify Console by filling in the `INPUT` fields and exporting the resulting dataset.

#### Is my use compliant and legal?

✅ You’re responsible for complying with applicable laws (for example GDPR/CCPA), spam regulations, and platform terms. Amazon Contact Extractor only helps you work with publicly available data, but it’s still on you to use the results appropriately.

***

### Support & feature requests

If you want to improve Amazon Contact Extractor or request enhancements to your Amazon contact extraction software workflow, we’d love to hear from you.

- 💡 **Feature Requests:** Examples include better exports for your Amazon contact data scraper pipelines (CSV/CRM-ready formats), additional filtering options, or expanded segmentation outputs (like more domain-level fields).
- 📧 **Contact:** For help or questions, email <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for Amazon Contact Extractor. 🙌

***

*Amazon Contact Extractor is built to deliver the most comprehensive, SEO-optimized Amazon contact extraction results at scale.*

### Disclaimer

**This tool accesses publicly accessible sources only.** It does not access private profiles, authenticated data, or password-protected pages. Legal compliance (including GDPR/CCPA), spam regulations, and platform terms are your responsibility.

For data removal requests, contact <dataforleads@gmail.com>. Always use Amazon Contact Extractor responsibly, ethically, and for legitimate purposes.

# Actor input Schema

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

Specify the country to target for Google search results.

## `emailType` (type: `string`):

Choose one — B2C or B2B.

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `maxEmails` (type: `integer`):

Enter the maximum number of emails to collect.

## `searchTerms` (type: `array`):

List of queries to find Amazon profiles.

## `sourceRegion` (type: `string`):

Select the regional index to target.

## Actor input object example

```json
{
  "country": "United States",
  "emailType": "B2C",
  "engine": "legacy",
  "maxEmails": 20,
  "searchTerms": [
    "fitness",
    "gym",
    "workout"
  ],
  "sourceRegion": "Amazon US"
}
```

# 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 = {
    "searchTerms": [
        "fitness",
        "gym",
        "workout"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/amazon-contact-extractor").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 = { "searchTerms": [
        "fitness",
        "gym",
        "workout",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/amazon-contact-extractor").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 '{
  "searchTerms": [
    "fitness",
    "gym",
    "workout"
  ]
}' |
apify call scraperoka/amazon-contact-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Contact Extractor",
        "description": "📇 Extract contact data from websites faster with Amazon Contact Extractor. Effortlessly pull emails, phone numbers & more for lead generation, sales, and outreach. ⚡ Save time, boost productivity, and reach the right customers.",
        "version": "1.0",
        "x-build-id": "sB9j6GA5Pg2y5tXah"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~amazon-contact-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-amazon-contact-extractor",
                "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/scraperoka~amazon-contact-extractor/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-amazon-contact-extractor",
                "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/scraperoka~amazon-contact-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-amazon-contact-extractor",
                "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": [
                    "searchTerms",
                    "country",
                    "sourceRegion",
                    "emailType",
                    "maxEmails"
                ],
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "Germany",
                            "France",
                            "India",
                            "Japan",
                            "Brazil",
                            "Italy",
                            "Spain",
                            "Netherlands",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Finland",
                            "Poland",
                            "Czech Republic",
                            "Hungary",
                            "Romania",
                            "Bulgaria",
                            "Croatia",
                            "Slovenia",
                            "Slovakia",
                            "Estonia",
                            "Latvia",
                            "Lithuania",
                            "Portugal",
                            "Greece",
                            "Cyprus",
                            "Malta",
                            "Luxembourg",
                            "Ireland",
                            "Belgium",
                            "Austria",
                            "Switzerland",
                            "Liechtenstein",
                            "Iceland",
                            "South Korea",
                            "China",
                            "Mexico",
                            "Argentina",
                            "Chile",
                            "Colombia",
                            "Peru",
                            "Venezuela",
                            "Ecuador",
                            "Uruguay",
                            "Paraguay",
                            "Bolivia",
                            "Guyana",
                            "Suriname",
                            "French Guiana",
                            "Falkland Islands (Malvinas)",
                            "South Georgia and the South Sandwich Islands",
                            "Bonaire, Sint Eustatius and Saba",
                            "Curaçao",
                            "Aruba",
                            "Sint Maarten (Dutch part)",
                            "Turks and Caicos Islands",
                            "British Virgin Islands",
                            "Anguilla",
                            "Montserrat",
                            "Antigua and Barbuda",
                            "Barbados",
                            "Dominica",
                            "Grenada",
                            "Saint Kitts and Nevis",
                            "Saint Lucia",
                            "Saint Vincent and the Grenadines",
                            "Trinidad and Tobago",
                            "Jamaica",
                            "Bahamas",
                            "Belize",
                            "Costa Rica",
                            "Guatemala",
                            "Honduras",
                            "Nicaragua",
                            "Panama",
                            "El Salvador",
                            "Cuba",
                            "Dominican Republic",
                            "Haiti",
                            "Puerto Rico",
                            "U.S. Virgin Islands",
                            "American Samoa",
                            "Guam",
                            "Northern Mariana Islands",
                            "Saudi Arabia",
                            "United Arab Emirates",
                            "Bahrain",
                            "Iraq",
                            "Iran, Islamic Republic of",
                            "Israel",
                            "Jordan",
                            "Kuwait",
                            "Lebanon",
                            "Oman",
                            "Qatar",
                            "Syrian Arab Republic",
                            "Yemen",
                            "Afghanistan",
                            "Bangladesh",
                            "Bhutan",
                            "Maldives",
                            "Nepal",
                            "Pakistan",
                            "Sri Lanka",
                            "Myanmar",
                            "Cambodia",
                            "Lao People's Democratic Republic",
                            "Thailand",
                            "Viet Nam",
                            "Malaysia",
                            "Singapore",
                            "Brunei Darussalam",
                            "Philippines",
                            "Indonesia",
                            "Timor-Leste",
                            "Papua New Guinea",
                            "Fiji",
                            "New Zealand",
                            "Solomon Islands",
                            "Vanuatu",
                            "New Caledonia",
                            "French Polynesia",
                            "Wallis and Futuna",
                            "Samoa",
                            "Tonga",
                            "Tuvalu",
                            "Kiribati",
                            "Nauru",
                            "Federated States of Micronesia",
                            "Marshall Islands",
                            "Palau",
                            "Cook Islands",
                            "Niue",
                            "Tokelau"
                        ],
                        "type": "string",
                        "description": "Specify the country to target for Google search results.",
                        "default": "United States"
                    },
                    "emailType": {
                        "title": "Email Type",
                        "enum": [
                            "B2C",
                            "B2B"
                        ],
                        "type": "string",
                        "description": "Choose one — B2C or B2B.",
                        "default": "B2C"
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Enter the maximum number of emails to collect.",
                        "default": 20
                    },
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "List of queries to find Amazon profiles.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sourceRegion": {
                        "title": "Source Region",
                        "enum": [
                            "Amazon US",
                            "Amazon India",
                            "Amazon Germany",
                            "Amazon UK",
                            "Amazon Japan",
                            "Amazon Canada",
                            "Amazon France",
                            "Amazon Italy",
                            "Amazon Spain",
                            "Amazon Brazil",
                            "Amazon Australia",
                            "Amazon Mexico",
                            "Amazon UAE",
                            "Amazon Saudi Arabia",
                            "Amazon Netherlands"
                        ],
                        "type": "string",
                        "description": "Select the regional index to target.",
                        "default": "Amazon US"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
