# Facebook Phone Number Scraper (`solid-scraper/facebook-phone-number-scraper`) Actor

📱 Our Facebook Phone Number Scraper helps you extract verified contact numbers from public profiles fast. 🎯 Ideal for lead gen, sales, and outreach—find targeted prospects quickly, boost conversions, and save hours with automated data capture.

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

## Pricing

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

### Linkedin Phone Number Scraper 🔍

**Linkedin Phone Number Scraper** is an Apify actor that helps you scrape phone numbers from **LinkedIn** using your chosen `keywords` plus a country dial code (`country`). It’s built for people who want a **LinkedIn phone number scraper** workflow for lead generation and contact enrichment—whether you’re a marketer, recruiter, data analyst, or researcher trying to save time on manual prospecting.

With **Linkedin Phone Number Scraper**, you can quickly build a **LinkedIn outreach phone list scraper** from publicly available sources, helping you target the right regions and scale your prospecting without spending hours copying details one-by-one.

Whether you use it as a **LinkedIn data scraper with phone numbers** for campaigns or a **LinkedIn phone number database scraper** for research, this actor is designed to streamline discovery at scale.

***

### Why choose Linkedin Phone Number Scraper?

| Feature | Benefit |
|---|---|
| ✅ **Phone-number focused extraction** | Collects phone numbers tied to the keywords you provide |
| ✅ **Platform selection for Linkedin** | Uses the **Linkedin** target specified in input (`platform`) |
| ✅ **Reliability with fallback engine options** | Choose between **Cost Effective (New)** and **Legacy** engine modes to fit your needs |
| ✅ **Limit control with `maxPhoneNumbers`** | Stops once your requested amount is reached to manage scraping time and cost |
| ✅ **Structured JSON output** | Produces consistent rows (platform, keyword, phone number, context fields) for easy downstream use |
| ✅ **Automation-ready dataset** | Saves each found record immediately, ready for export into your pipeline |

***

### Key features

- 🔍 **Keyword-driven discovery**: Search using your `keywords` array to find relevant publicly available content connected to your target
- 📞 **Country dial-code targeting**: Validates and outputs phone numbers in the E.164 format for the selected `country`
- 🧭 **Engine choice for different tradeoffs**: Switch between **Cost Effective (New)** and **Legacy** to match speed vs. reliability expectations
- 🛡️ **Resilience via built-in retries/fallbacks**: Includes fallback logic when results are blocked or temporarily unavailable
- 💾 **Real-time saving to dataset**: Each discovered phone number is pushed into the output dataset as it’s found
- 🧩 **Rich context fields included**: Each output row contains `title`, `description`, and the `url` where the phone number was found
- 🔁 **Deduplication to reduce noise**: Avoids pushing the same E.164 `phone_number` multiple times within the run
- 🎯 **Hard stop via `maxPhoneNumbers`**: Prevents endless runs by stopping when the limit is reached

***

### Input

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

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

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `keywords` | ✅ | A list of keywords to search for (example: `marketing`, `founder`). The actor uses these to find relevant LinkedIn content tied to your target. |
| `platform` | ❌ | Select platform. In this actor, the only available option is `Linkedin` (default is `Linkedin`). |
| `country` | ✅ | Select a country to scrape related phone numbers. This determines the country dial code used for phone targeting. |
| `maxPhoneNumbers` | ❌ | Maximum number of phone numbers to collect. The scraper stops once this limit is reached (default: `20`). |
| `engine` | ❌ | Choose scraping engine: `cost-effective` (**Cost Effective (New)**) or `legacy` (**Legacy**) (default: `legacy`). |
| `proxyConfiguration` | ❌ | Configure proxies for this Actor. Leave empty or provide your proxy configuration as supported by Apify’s proxy editor. |

***

### Output

The actor pushes each discovered phone number as a JSON row into the output dataset using `Actor.push_data(row)`.

Example output row:

```json
[
  {
    "platform": "Facebook",
    "keyword": "marketing",
    "title": "Example result title",
    "description": "Example result description containing phone text",
    "url": "https://example.com",
    "phone_number": "+447700900123",
    "country": "United Kingdom (+44)",
    "dial_code": "+44",
    "proxyGroups": [],
    "error_message": null
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `platform` | string | The platform value pushed with each row (set in code as `'Facebook'`). |
| `keyword` | string | The keyword currently being processed from your `keywords` input. |
| `title` | string | Title text associated with the result where the phone number was found. |
| `description` | string | Description/snippet text where phone numbers are extracted from. |
| `url` | string | The URL associated with the result where the phone number was found. |
| `phone_number` | string | Extracted phone number in E.164 format (deduplicated within the run). |
| `country` | string | The selected country value from input (e.g., `United Kingdom (+44)`). |
| `dial_code` | string | Country dial code derived from the selected `country`. |
| `proxyGroups` | array | Proxy group information associated with the run (as pushed in the output row). |
| `error_message` | string | Error details when a push fails or if a record cannot be produced (included as a field in output structure where applicable). |

> Note: Output rows are produced as the actor finds phone numbers, so your dataset grows during the run and is ready to export when finished (JSON/CSV depending on Apify exports).

***

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

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and sign in.

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

3. **Add your input**\
   In the **INPUT** panel, fill in the required fields:

   - `keywords` (array of strings)
   - `country` (country dial code selection)

   Optionally set:

   - `maxPhoneNumbers`
   - `platform` (default is `Linkedin`)
   - `engine` (`legacy` or `cost-effective`)
   - `proxyConfiguration`

4. **Configure proxy (optional but recommended for scale)**\
   Use the built-in proxy editor via `proxyConfiguration` to improve consistency in larger runs.

5. **Start the run**\
   Click **Run**. While it executes, you’ll see logs indicating progress, retries/fallback behavior, and when the dataset receives new records.

6. **Monitor output in real time**\
   Each discovered phone number is pushed into the dataset as soon as it’s found (so you can monitor growth while the run continues).

7. **Export results**\
   After completion, open the **OUTPUT** tab, view the dataset, and export it (typically JSON/CSV via Apify’s dataset export options).

No coding required—get accurate phone-number results in minutes with **Linkedin Phone Number Scraper**. 🚀

***

### Advanced features & SEO optimization

- 🔁 **Built for keyword + phone-targeting workflows**: It’s engineered specifically for **Linkedin phone number scraper** use cases like finding lead phone numbers based on your niche keywords.
- 🧰 **Engine flexibility for different operational needs**: Use `engine` to choose **Cost Effective (New)** for speed/cost efficiency or `legacy` for a different reliability profile.
- 🧾 **Phone validation output format**: The actor outputs numbers in E.164 format, making it easier to join, deduplicate, and import into tools that expect international format.
- 💾 **Persistent progress support**: The actor keeps run progress in a key-value store (`progress_li_phone`) so it can track seen numbers and cursor state during execution.
- 📝 **Designed for structured lead lists**: Output rows include contextual fields like `title`, `description`, and `url`, which helps analysts and marketers audit relevance during cleanup.

***

### Best use cases

- 📈 **B2B lead generation teams**: Build a **LinkedIn outreach phone list scraper** dataset from your target keywords to speed up outbound prospecting.
- 🧑‍💼 **Recruiters**: Rapidly compile **LinkedIn business contact phone scraper** lists for roles tied to specific keywords and regions.
- 🏢 **Sales development (SDR/BDR)**: Turn **LinkedIn lead phone number scraper** outputs into call-ready segments for outreach sequences.
- 🔎 **Market researchers**: Enrich samples by extracting phone numbers and result context for teams analyzing company or individual signals.
- 🧠 **Data analysts**: Use a **LinkedIn data scraper with phone numbers** dataset for deduplication, normalization, and regional comparisons.
- 🔧 **Automation builders**: Feed results into your pipeline as a structured JSON dataset for CRM import and enrichment workflows.
- ✉️ **Outreach operations**: Create **LinkedIn outreach phone list scraper** campaigns that combine phone numbers with keyword context for faster QA.

***

### Technical specifications

- **Supported Input Formats** ✅\
  `keywords` (array of strings) and `country` (selected country dial code). Optional: `platform`, `maxPhoneNumbers`, `engine`, `proxyConfiguration`.

- **Proxy Support** ✅\
  Uses Apify proxy configuration via `proxyConfiguration` with support for reliable scraping at scale.

- **Retry Mechanism** ✅\
  Includes retries and fallback behavior when results are blocked or temporarily unavailable.

- **Dataset Structure** ✅\
  Each discovered phone number is saved as a JSON row with fields such as `platform`, `keyword`, `title`, `description`, `url`, `phone_number`, `country`, `dial_code`, and `proxyGroups`.

- **Rate Limits & Performance** ⚠️\
  Large runs or high `maxPhoneNumbers` may take longer depending on conditions and engine choice.

- **Limitations** ❌ / ⚠️\
  Results depend on what phone numbers are present in publicly available sources and on the matching strength of your provided `keywords` and `country` selection.

***

### FAQ

#### Do I need any special login or API keys to run Linkedin Phone Number Scraper?

✅ No special login is required beyond your Apify account to run the actor in Apify Console. You just provide `keywords` and `country` (plus optional tuning fields).

#### What platform does this actor scrape?

✅ This actor is configured for `platform: "Linkedin"`. You can choose `platform` in input, but the schema only lists `Linkedin`.

#### How do I improve the number of phone results I get?

✅ Use specific and relevant `keywords`, and make sure you pick the correct `country` dial code. If results are low, try broader or more related keywords and increase `maxPhoneNumbers`.

#### In what format are phone numbers returned?

✅ Phone numbers are output in E.164 format as `phone_number`, which is helpful for deduplication and integration with lead databases.

#### Can I limit how many phone numbers are collected?

✅ Yes. Set `maxPhoneNumbers` to stop after reaching your desired amount (the actor stops once the limit is reached).

#### Can I use proxies for better reliability at scale?

✅ Yes. You can provide settings via `proxyConfiguration`, and you can also select an `engine` mode to match your operational preferences.

#### What data is included besides the phone number?

✅ Each output row includes contextual fields like `title`, `description`, and `url` along with `keyword`, `country`, and `dial_code` to help with validation and analysis.

#### Is this actor suitable for CRM enrichment and outreach workflows?

✅ Yes. The structured dataset format makes it straightforward to export and import into marketing, recruitment, and sales tooling for **LinkedIn data scraper with phone numbers** use cases.

***

### Support & feature requests

Have questions about **Linkedin Phone Number Scraper** or want to request improvements? Tell us what you’re building and we’ll do our best to help. 💡

- 💡 **Feature Requests**: For example, you can ask for CSV-friendly formatting, additional output context fields, or adjustments to filtering behavior for **Linkedin lead generation phone numbers** workflows.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>

Your feedback helps shape the roadmap for this **Linkedin phone number scraper** and related **LinkedIn outreach phone list scraper** improvements.

***

### Closing CTA / Final thoughts

*If you’re looking for an SEO-optimized way to scale phone discovery from public sources, **Linkedin Phone Number Scraper** is built for exactly that.* Start your next **LinkedIn phone number finder** run and turn keywords into structured phone-number leads faster than manual work.

***

### Disclaimer

**This tool accesses publicly accessible sources only.** It does not access private profiles, authenticated data, or password-protected pages.

You are responsible for complying with applicable laws and regulations (including GDPR/CCPA where relevant), as well as platform terms of service, spam regulations, and any other relevant requirements.

For any data removal requests, contact <dataforleads@gmail.com>. Please use **Linkedin Phone Number Scraper** 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": "Linkedin",
  "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/facebook-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/facebook-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/facebook-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/RAmjcCpMphazu5kIB/builds/GHZzYEa5hqvTCCT9q/openapi.json