# Amazon Phone Number Scraper (`solid-scraper/amazon-phone-number-scraper`) Actor

📞 Amazon Phone Number Scraper extracts verified customer/retailer phone numbers from listings fast. Perfect for lead generation, outreach, and sales teams—save time, boost targeting accuracy, and scale campaigns with ease. 🚀

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

## Pricing

from $2.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Phone Number Scraper 📞

**Amazon Phone Number Scraper** is an Apify actor that automatically extracts phone numbers connected to Amazon profiles and posts using your chosen keywords and a country dial code. It helps you solve the “manual digging” problem when you’re trying to build lead lists, enrich records, or research contact points at scale—especially for **Amazon phone number scraper** and **Amazon contact number scraper** workflows.

Whether you’re a marketer, sales ops specialist, data analyst, or researcher, this **Amazon phone number web scraper** gives you structured results you can review, filter, and export—saving you hours of manual work when prospecting for the right **Amazon seller phone number scraper** leads.

***

### Why choose Amazon Phone Number Scraper?

| Feature | Benefit |
|---|---|
| ✅ **Keyword-driven phone extraction** | Finds phone numbers tied to Amazon bios, profiles, and posts related to your keywords |
| ✅ **Country dial code targeting** | Helps focus results by extracting and formatting phone numbers for the country you select |
| ✅ **Engine options for reliability** | Choose between **Cost Effective (New)** and **Legacy** engines based on your needs |
| ✅ **Structured JSON output** | Produces consistent fields like `phone_number`, `keyword`, `url`, and `country` for easier downstream use |
| ✅ **Controlled scale with limits** | Use `maxPhoneNumbers` to cap collection and manage runtime for larger searches |
| ✅ **Real-time dataset saving** | Each discovered number is pushed immediately to the output dataset for faster feedback loops |

***

### Key features

- 🔎 **Keyword-based Amazon contact discovery**: Collects phone numbers related to your provided `keywords`
- 🌍 **Country-focused results**: Extracts and formats phone numbers using the selected `country` and its dial code
- 🧠 **Better targeting support**: Use specific keywords and include custom phone numbers (like `+49`) when needed for more precise results
- 🛡️ **Engine choice for robustness**: Run with `engine` set to `legacy` or `cost-effective` depending on your reliability vs cost preference
- 🔄 **Resilience through fallbacks**: Includes retries and fallbacks for pages that appear blocked or return empty results
- 💾 **Deduplication**: Avoids duplicates by tracking `seen_numbers` during the run
- 📊 **Clean, structured output rows**: Every result row includes `platform`, `keyword`, `phone_number`, `url`, and country context
- ⏱️ **Run stops when limits are hit**: Uses `maxPhoneNumbers` to stop once the collection target is reached

***

### Input

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

```json
{
  "keywords": ["marketing", "founder"],
  "platform": "Amazon",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 20,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `keywords` | ✅ | A list of keywords to search for (for example: `marketing`, `founder`, or even person/role terms like `John`). |
| `platform` | ❌ | Select the platform. This actor supports `Amazon` and defaults to `Amazon`. |
| `country` | ✅ | Select a country to scrape related phone numbers (this drives the dial code used for formatting/validation). |
| `maxPhoneNumbers` | ❌ | Maximum number of phone numbers to collect. The run stops once the limit is reached. (Helps control scraping time.) |
| `engine` | ❌ | Choose scraping engine: `legacy` (more reliable but slower and more expensive) or `cost-effective` (cost effective using the actor’s residential-proxy approach). |
| `proxyConfiguration` | ❌ | Configure proxies for this Actor using Apify proxy settings. |

***

### Output

The actor saves each discovered phone number as a structured JSON row in the output dataset.

Sample output row:

```json
[
  {
    "platform": "Amazon",
    "keyword": "marketing",
    "title": "Some profile/title text",
    "description": "Some source text that may contain phone numbers",
    "url": "https://www.example.com/some-amazon-page",
    "phone_number": "+441234567890",
    "country": "United Kingdom",
    "dial_code": "+44",
    "proxyGroups": [
      "legacy"
    ]
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `platform` | string | Always set to `Amazon` for this actor’s results. |
| `keyword` | string | The keyword currently being processed when the phone number was found. |
| `title` | string | Title text from the source item where the phone number appeared. |
| `description` | string | Source text used for phone extraction. |
| `url` | string | URL of the Amazon page associated with the extracted number. |
| `phone_number` | string | Phone number in E.164 format. |
| `country` | string | Country name used for the run. |
| `dial_code` | string | Dial code used for the run (based on the selected country). |
| `proxyGroups` | array | Proxy group information used during scraping (as recorded in the output row). |

> Note: The dataset is populated as each result is found via `Actor.push_data(...)`, so you don’t need to wait for the entire run to start reviewing output.

***

### How to use Amazon Phone Number Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at [console.apify.com](https://console.apify.com) and open the Actors page.

2. **Find Amazon Phone Number Scraper**\
   Search for **Amazon Phone Number Scraper** and open the actor details page.

3. **Go to the INPUT section**\
   Use the built-in form to set:
   - `keywords` (required)
   - `country` (required)

4. **Optional: fine-tune scope and runtime**\
   Set `maxPhoneNumbers` if you want to cap results for the run (helpful for larger batches).

5. **Optional: choose the engine**\
   Pick `engine`:
   - `legacy` for maximum reliability
   - `cost-effective` for a more cost-focused approach

6. **Optional: configure proxies**\
   If you have specific proxy requirements, fill `proxyConfiguration`. Otherwise, you can keep defaults.

7. **Click Run**\
   Watch the logs while the actor processes keywords and collects phone numbers. If it hits blocked/empty pages, it can retry and use fallbacks.

8. **Open the OUTPUT dataset and export**\
   After the run finishes (or while it’s running, since data is pushed as it’s found), export the dataset to JSON/CSV from the Apify Console.

No coding required—get accurate results for your **Amazon phone number extractor tool** workflow in minutes. ⚡

***

### Advanced features & SEO optimization

- 🧩 **Engine tuned for your tradeoffs**: Switch between `legacy` and `cost-effective` using the `engine` setting to balance reliability and cost for Amazon lead generation phone number scraper use cases.
- 🔍 **Targeting with dial-code aware extraction**: The actor uses the selected `country` dial code to extract phone numbers in a standardized format (E.164), making it easier to merge into CRMs.
- 💾 **Immediate dataset pushing**: Each phone number row is saved as it’s discovered, which reduces “wait time” when testing new keywords for an Amazon phone numbers database scraper pipeline.
- 📈 **Scalable keyword-driven harvesting**: Use broader or more related keywords if results appear low—this is often faster than manually expanding searches elsewhere when you’re scraping phone numbers from Amazon.

***

### Best use cases

- 📊 **Lead generation lists**: Build phone number lead targets for outreach campaigns by extracting Amazon listing contact phone scraper numbers tied to your keywords.
- 🧾 **Sales research & enrichment**: Enrich existing CRM records with phone numbers by using an Amazon contact details scraper workflow.
- 🏪 **Seller outreach research**: Find seller-related contact points for campaigns with an Amazon seller contact info scraper approach.
- 🧠 **Market research**: Aggregate publicly available contact phone numbers by country to analyze regional presence.
- 🛠️ **Data analyst pipelines**: Feed structured rows (including `url`, `keyword`, and `phone_number`) into analysis or scoring models.
- 💼 **Business directory style sourcing**: Collect numbers for a business directory scraper phone numbers dataset where phone-first enrichment matters.
- 🔁 **Iterative keyword testing**: Run multiple batches with different `keywords` to optimize results for Amazon phone number web scraper strategies.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of strings
  - ✅ `country` as a selected country + dial code string (required)
  - ✅ `platform` supports `Amazon` (defaults to `Amazon`)
  - ✅ `maxPhoneNumbers` integer between 1 and 10000 (defaults to 20)
  - ✅ `engine` supports `cost-effective` and `legacy` (defaults to `legacy`)
  - ✅ `proxyConfiguration` object to configure Apify proxies

- **Proxy Support**
  - ✅ Built-in proxy configuration support via `proxyConfiguration`
  - ✅ Engine choice supports different proxy approaches (`legacy` vs `cost-effective`)

- **Retry Mechanism**
  - ✅ Includes retries and fallbacks when pages fail or return empty results

- **Dataset Structure**
  - ✅ One dataset row per extracted phone number
  - ✅ Includes `platform`, `keyword`, `phone_number`, `url`, `country`, and `dial_code`

- **Limitations**
  - ❌ `maxPhoneNumbers` controls the stop condition but does not guarantee reaching the exact number if fewer matches exist for your keywords

***

### FAQ

#### What does Amazon Phone Number Scraper extract?

✅ It extracts phone numbers associated with Amazon bios, profiles, and posts related to your provided `keywords`, and formats them into the `phone_number` field in E.164 format.

#### Do I need keywords and a country to run it?

✅ Yes. `keywords` and `country` are required fields.

#### What is `maxPhoneNumbers` used for?

`maxPhoneNumbers` sets the maximum number of phone numbers the actor will collect. Once the limit is reached, the run stops (this helps control scraping time and cost).

#### Which engine should I choose: `legacy` or `cost-effective`?

If you want maximum reliability, choose `engine: "legacy"`. If you want a more cost-focused approach, choose `engine: "cost-effective"`. The actor’s input descriptions explain the tradeoff in reliability vs speed/cost.

#### What format will phone numbers be in?

The `phone_number` field is produced in E.164 format (for example, numbers starting with `+`).

#### Will the actor avoid duplicate phone numbers?

Yes. The actor tracks `seen_numbers` during the run and skips numbers already collected.

#### Can I use custom proxy settings?

Yes. Use the `proxyConfiguration` object input to configure proxies for the actor.

#### Is this actor legal/compliance friendly?

The actor works with **publicly accessible sources**. You are responsible for complying with applicable laws (including GDPR/CCPA where relevant), spam regulations, and the platform’s terms of service.

***

### Support & feature requests

Want to improve your Amazon Phone Number Scraper results? We’d love to hear from you. 💬

- 💡 **Feature Requests**: Examples include adding additional export formats, expanding output enrichment fields, or enhancing filtering logic for your Amazon phone number scraper workflows.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for Amazon phone number extractor tool capabilities and better structured outputs.

***

*If you’re looking for the most comprehensive Amazon Phone Number Scraper experience, this is built for practical, scalable phone-first lead enrichment.*\
*Get started now and make your Amazon phone numbers harvesting workflow faster and easier.* 🚀

***

### Disclaimer

**This actor only accesses publicly accessible sources** to extract phone numbers. It does not access private profiles, authenticated data, or password-protected content.

It is your responsibility to comply with applicable laws (including GDPR and CCPA where relevant), spam regulations, and the platform’s terms of service while using **Amazon Phone Number Scraper**.

For data removal requests, contact <dataforleads@gmail.com>. Please use this tool responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords to search for. (Example: John, marketing, etc.)

## `platform` (type: `string`):

Select platform.

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

Select a country to scrape related phone numbers.

## `maxPhoneNumbers` (type: `integer`):

Maximum number of phone numbers to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## `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.

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

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "marketing",
    "founder"
  ],
  "platform": "Amazon",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 20,
  "engine": "legacy"
}
```

# 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 = {
    "keywords": [
        "marketing",
        "founder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/amazon-phone-number-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 = { "keywords": [
        "marketing",
        "founder",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/amazon-phone-number-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 '{
  "keywords": [
    "marketing",
    "founder"
  ]
}' |
apify call solid-scraper/amazon-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bzeKLv8lWWn1PFbhc/builds/YGXdGzwt78fulnKji/openapi.json