# About.Me Phone Number Scraper - Verified Numbers (`scrapido/aboutme-phone-number-scraper`) Actor

📞 About.me Phone Number Scraper finds numbers via keyword and location search. ✅ Returns validated About.me numbers with country code, line type and carrier — split mobiles from landlines before you dial. 🎯 Built for SMS outreach.

- **URL**: https://apify.com/scrapido/aboutme-phone-number-scraper.md
- **Developed by:** [Scrapido](https://apify.com/scrapido) (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 $2.50 / 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

### About.Me Phone Number Scraper

**About.Me Phone Number Scraper** solves the time-consuming problem of manually hunting for phone contacts across About.Me profiles. Instead of spreadsheet chaos, you get an automated **About.Me contact number scraper** experience tailored for sales pros, recruiters, and marketers. If you’re looking for an **About.me phone number API** style workflow, this actor turns targeted research into a clean dataset—so you can move from lead discovery to outreach much faster. 🔥

### What is About.Me Phone Number Scraper? 🔍

**About.Me Phone Number Scraper** is an Apify automation actor that extracts phone numbers from About.Me profiles, bios, and post content using your `keywords` and selected `country` targeting. It’s an **About.me lead generation phone scraper** built for anyone who needs scalable **automated About.Me scraping**—without manually clicking through profiles one by one. Whether you’re a sales professional, recruiter, or marketing team building an **about.me phone number database**, this **About.Me Phone Number Scraper** helps you create outreach-ready lists quickly and consistently.

### What Does About.Me Phone Number Scraper Do? ⚙️

**About.Me Phone Number Scraper** uses your input to scrape relevant About.Me profile content and output structured records to your Apify dataset.

- 🔍 **Searches** About.Me using your `keywords` and optional `location` filter
- 📞 **Extracts** publicly listed phone numbers from matching profile content
- 🌍 **Filters** results by the selected country dial code targeting (`country` → `dial_code`)
- 📊 **Structures** the results as clean JSON records in a dataset
- 💾 **Exports** data from the Apify Dataset tab (JSON/CSV via Apify UI)

### What Would Results from About.Me Phone Number Scraper Look Like? 👀

You’ll see each discovered phone contact as a JSON record you can export and enrich in your CRM.

```json
{
  "keyword": "marketing",
  "title": "Example Studio Founder",
  "description": "Marketing and partnerships. WhatsApp available. Call for bookings.",
  "url": "https://about.me/example-studio",
  "phone_number": "+447700900123",
  "country": "United Kingdom",
  "dial_code": "+44"
}
```

Export as JSON or CSV from the **Dataset** tab in the Apify Console. ✅

### Capabilities of About.Me Phone Number Scraper 🛠️

Below are the practical capabilities you’ll care about when evaluating an **About.me phone number extraction tool** or an **about.me phone number finder**:

| Capability | What It Means for You |
|---|---|
| ✅ **Keyword-driven discovery** | Use `keywords` (like “marketing” or “founder”) to target relevant About.Me bios, profiles, and post content |
| ✅ **Optional location filtering** | Use `location` to focus results on a specific city/region while leaving it empty for global discovery |
| ✅ **Country targeting with dial-code context** | Pick a `country` (default: United Kingdom (+44)) so results align with your intended dial code (`dial_code`) |
| ✅ **Result cap control (`maxPhoneNumbers`)** | Stop once you’ve collected the number of phone contacts you need (default: 20) |
| ✅ **Resilient runs for larger tasks** | Built for longer scrapes (you can adjust timeout in Run Options) so big batches don’t feel “fragile” |
| ✅ **Deduplication within the run** | The actor avoids pushing duplicate `phone_number` values into the dataset during execution |
| ✅ **Clean dataset output** | Each match is pushed into the Apify dataset with consistent field structure for easy analysis |

### Launch Your First About.Me Phone Number Scraper Task 🚀

Set up the run in the Apify Console by entering your target inputs, then exporting the dataset after the run completes. 🚀

#### Required Input Fields

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

| Parameter | Type | Required | Default | Description |
|---|---|---:|---|---|
| `keywords` | array | ✅ Yes | `["marketing","founder"]` | Enter keywords to search for (for example, to find About.Me bios related to your niche like “marketing” or “founder”). |
| `location` | string | No | `""` | Filter by location (e.g., “London”, “California”). Leave empty for global search. |
| `country` | string | ✅ Yes | `United Kingdom (+44)` | Select the country to target for phone numbers. |
| `maxPhoneNumbers` | integer | No | `20` | Stop scraping after this many phone numbers are found. Setting a higher limit extends the scraping duration. |

#### Required Output Fields

The dataset includes these fields (in this exact order) for every scraped record:

| Field | Label | Format | Description |
|---|---|---|---|
| `keyword` | Keyword | text | Keyword from your input that surfaced this phone contact. |
| `title` | Title | text | Profile title/heading text associated with the found phone contact. |
| `description` | Description | text | Text extracted from the About.Me profile content where the phone number match appeared. |
| `url` | Url | link | The About.Me URL where the match was found. |
| `phone_number` | Phone Number | text | Extracted phone number in normalized form for consistency. |
| `country` | Country | text | Target country name aligned to your selected dial code targeting. |
| `dial_code` | Dial Code | text | Dial code value used for the country targeting filter. |

### Solving Real Problems with About.Me Phone Number Scraper 💼

If you’re tired of slow, manual outreach list building, this actor helps you standardize discovery for About.Me contact outreach:

- 🎯 **Outbound prospecting at scale**: turn **scrape About.me phone numbers** requests into a dataset you can act on immediately
- 📞 **About.Me direct contact lists**: find phone contacts tied to your niche using **About.Me contact number scraper** workflows
- 🔬 **Targeted research by geography**: improve relevance by pairing `location` with `country` targeting
- ⚙️ **Automated pipeline for analysts and operators**: integrate results from an **About.me phone number extraction tool** into your broader lead enrichment process
- 📈 **Segment-ready data**: the dataset includes `keyword`, profile `title`, `description`, and the source `url` so records are easier to qualify

### What Sets About.Me Phone Number Scraper Apart? 🏆

Here’s why teams use this instead of ad-hoc, one-off scripts when they need an **About.me phone number database**:

- 💾 **Structured dataset output** designed for fast filtering, exporting, and analysis (not messy copy-paste)
- 🔁 **Deduplication within the run** to keep your output cleaner for downstream use
- 🎯 **Better targeting controls** via `keywords`, optional `location`, and dial-code aligned `country`
- 🛡️ **Built-in proxy support for reliable scraping** during larger batches
- 🚀 **Incremental dataset pushing**: records are saved to the dataset as they’re found

### Search Limits and Capacity 📈

This actor supports bulk extraction with a practical run-time guardrail:

- Use `maxPhoneNumbers` (integer, min `1`, max `10000`) to cap how many phone contacts you want per run (default: `20`).
- For large scraping tasks, you can adjust timeout in **Run Options** (default: `3600s / 1hr`).
- If you’re not getting enough results, the input guidance is simple: broaden `keywords` and/or try different `country` settings.

### Is It Legal to Scrape About.Me? ⚖️

This actor is designed to work with **publicly available sources** on About.Me—without accessing private profiles or restricted data. It’s your responsibility to ensure compliance with applicable laws (including privacy and anti-spam requirements) and About.Me’s Terms of Service. If you have compliance questions or need data-related assistance, contact <scrapidocontact@gmail.com>.

### Ending Note ✉️

Don’t waste hours manually searching About.Me for **phone number extraction**. **About.Me Phone Number Scraper** delivers consistent, dataset-ready records—so you can build outreach lists faster with fewer steps. Give it a try on Apify and export your results right away. ✅

### FAQ — About.Me Phone Number Scraper ❓

#### How Does the About.Me Phone Number Scraper Work?

You provide `keywords`, an optional `location`, and a target `country`. The actor scrapes relevant About.Me profile content, extracts matching phone numbers, normalizes and de-duplicates them within the run, and saves each match as a structured record in your Apify dataset.

#### What Types of About.Me Profiles Can I Target?

The actor targets About.Me profiles, bios, and post content. It uses your `keywords` and your selected `country` targeting to help focus results on the contacts you’re most likely to use for outreach and research.

#### How Did the About.Me Phone Number Scraper Perform in Our Tests?

Performance depends heavily on the relevance of your `keywords` and the `country` selection. The actor also supports longer runs via adjustable timeout in Run Options, but if results are fewer than expected, the recommended next step is to try broader keywords or different country settings.

#### Why Scrape About.Me Instead of Buying a List?

Scraped data from publicly available sources is typically more niche-specific and easier to refresh for targeted campaigns. With **About.Me phone number scraping software**, you can control the inputs (`keywords`, optional `location`, and `country`) so the output is aligned to your go-to-market needs.

#### How Much Does About.Me Phone Number Scraper Cost?

Pricing follows Apify’s pay-per-result model: the actor pushes results with `charged_event_name="result"`. To control output volume (and spending), set `maxPhoneNumbers`.

#### Top Benefits of the About.Me Phone Number Scraper

You get keyword-led discovery, country targeting with dial-code context, clean structured dataset output, built-in proxy support for reliability, and a configurable stop condition via `maxPhoneNumbers`. This makes it a practical **About.me lead generation phone scraper** for teams that need speed and consistency.

#### What Are the Disadvantages of Scraping About.Me?

Not every profile includes a publicly listed phone number, so yield varies. If your keywords are too narrow—or if the selected `country` dial code has fewer public phone listings—you may need to broaden your search terms or adjust country targeting.

#### How to Choose the Best About.Me Scraper

Look for tools with clean dataset structure, input controls that match your targeting (keywords, `location`, `country`), and reliable scraping support for larger tasks. This actor provides those core capabilities, making it a strong choice for an **About.me phone number extraction tool** workflow. For help, contact <scrapidocontact@gmail.com>.

### 🆘 Support & Feedback

Have a question or want help improving your **About.Me phone number API**-style workflow?

Please email <scrapidocontact@gmail.com>.

### Multiple Phone Type

**Phone Types** replaces the old single Number Type choice: select as many kinds
of line as you want and the run collects all of them.

| Type | Kept when the number is |
| --- | --- |
| Mobile | A confirmed mobile |
| Landline | A confirmed fixed line |
| Toll-Free | A freephone number |
| VoIP | An internet-telephony number |
| Premium-Rate | A premium-rate number |
| Shared-Cost | A shared-cost number |

Leave it empty for every type. Each number is checked against its *real* line
type before being kept, so the filter is enforced rather than merely requested.
Numbers on ranges where mobile and landline genuinely cannot be told apart (the
US, Canada and Mexico) are kept rather than silently dropped - discarding them
would quietly lose good leads.

### Outreach links

| Field | Meaning |
| --- | --- |
| `telLink` | A clickable `tel:` link, so a row can be dialled straight from a spreadsheet or CRM |
| `whatsappLink` | A `wa.me` chat link, or empty for a confirmed landline or a number that failed validation |
| `whatsappCapable` | Whether the number is on a line WhatsApp can run on |

`whatsappCapable` is a plain yes/no you can filter on. It never claims the
person actually uses WhatsApp - only that the number is of a kind that could.
Switch the links off with **Include WhatsApp links**; the capability flag is
still reported.

# Actor input Schema

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

Enter keywords to search for (e.g., 'Target Keyword').

## `location` (type: `string`):

Filter by location (e.g., 'London', 'California'). Leave empty for global search.

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

Select the country to target for phone numbers.

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

Stop scraping after this many phone numbers are found. Setting a higher limit extends the scraping duration.

## `numberType` (type: `string`):

Restrict results to a specific line type, classified offline via libphonenumber. Any keeps every valid match.

## `phoneTypes` (type: `array`):

Which kinds of line to collect. Pick as many as you like - each number is checked against its real line type before it is kept. Leave empty for every type. Numbers on ranges where mobile and landline cannot be told apart (the US, Canada and Mexico) are always kept rather than silently dropped.

## `includeWhatsappLinks` (type: `boolean`):

Add a ready-made wa.me chat link for numbers on a line WhatsApp can run on. The link means the number is in a form WhatsApp accepts - not proof that an account exists.

## Actor input object example

```json
{
  "keywords": [
    "coach",
    "consultant"
  ],
  "country": "United States (+1)",
  "maxPhoneNumbers": 20,
  "numberType": "Any",
  "phoneTypes": [
    "Mobile"
  ],
  "includeWhatsappLinks": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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": [
        "coach",
        "consultant"
    ],
    "phoneTypes": [
        "Mobile"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapido/aboutme-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": [
        "coach",
        "consultant",
    ],
    "phoneTypes": ["Mobile"],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapido/aboutme-phone-number-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "coach",
    "consultant"
  ],
  "phoneTypes": [
    "Mobile"
  ]
}' |
apify call scrapido/aboutme-phone-number-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapido/aboutme-phone-number-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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