# Twitter Phone Number Scraper (`solid-scraper/twitter-phone-number-scraper`) Actor

📱 Twitter Phone Number Scraper extracts verified phone numbers from public profiles for faster lead building. Perfect for sales, agencies & recruiters—find targeted contacts by keywords and filters, then export instantly. 🚀

- **URL**: https://apify.com/solid-scraper/twitter-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 $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

### Twitter Phone Number Scraper 🔍

**Twitter Phone Number Scraper** is an Apify actor that scrapes **phone numbers** from **Twitter** content using your chosen keywords and a country dial code. If you’re searching for a *twitter phone number scraper*, a *twitter contact scraper*, or a *twitter phone number finder*, this tool helps you quickly identify publicly available phone numbers associated with relevant profiles and posts—at scale, saving you hours of manual work.

Whether you’re a marketer, recruiter, lead researcher, or data analyst, this **twitter email and phone number scraper** is designed for practical prospecting and list building.

***

### Why choose Twitter Phone Number Scraper?

| Feature | Benefit |
|---|---|
| ✅ Keyword-driven phone extraction | Finds phone numbers tied to your keywords from Twitter bios, profiles, and posts |
| ✅ Country dial code targeting | Filters results by the selected country format (dial code) to improve relevance |
| ✅ Reliability-focused scraping engine choice | Lets you choose between “Cost Effective (New)” and “Legacy” engines |
| ✅ Structured output dataset | Saves consistent, JSON records you can import into CRMs and workflows |
| ✅ Scale-friendly limits | Use `maxPhoneNumbers` to cap results and control run time |
| ✅ Proxy support via Apify settings | Works with your configured proxy setup for more stable scraping |

***

### Key features

- 📌 **Keyword-based Twitter phone number harvesting:** Uses your `keywords` to target relevant Twitter bios, profiles, and posts
- 📍 **Country dial code targeting:** Extracts phone numbers aligned to your selected country dialing format
- 🔄 **Engine selection for different performance needs:** Choose **Cost Effective (New)** for faster/cheaper runs or **Legacy** for another reliability option
- 🛡️ **Proxy configuration support:** Works with your `proxyConfiguration` to improve scraping stability
- 💾 **Real-time saving during the run:** Each found phone number record is pushed immediately to the output dataset
- 🎯 **Hard stopping at your max limit:** Respects `maxPhoneNumbers` to stop collecting once the limit is reached
- 📊 **Duplicate protection:** Avoids re-collecting phone numbers you’ve already seen during the run

***

### Input

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

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

#### Input Fields

| Field | Required | Description |
|---|---|---|
| `keywords` | ✅ Yes | A list of keywords to search for. For example: `marketing`, `founder`, or names like `John`. The scraper uses these to find relevant Twitter bios, profiles, and posts. |
| `platform` | ❌ No | Select platform. In this actor, the only available option is `Twitter` (default: `Twitter`). |
| `country` | ✅ Yes | Select a country to scrape related phone numbers. The selected country determines the dial code used for phone number extraction (default: `United Kingdom (+44)`). |
| `maxPhoneNumbers` | ❌ No | Maximum number of phone numbers to collect. The scraper stops once this limit is reached (default: `20`, min: `1`, max: `10000`). |
| `engine` | ❌ No | Choose scraping engine. `cost-effective` is labeled **Cost Effective (New)**, while `legacy` is labeled **Legacy** (default: `legacy`). |
| `proxyConfiguration` | ❌ No | Configure proxies for this Actor. Use this when you want custom proxy behavior instead of the default settings. |

***

### Output

The actor saves each result as a JSON object in the dataset (via `Actor.push_data(row)`).

Example output record:

```json
{
  "platform": "Twitter",
  "keyword": "marketing",
  "title": "No data",
  "description": "No data",
  "url": "https://example.com",
  "phone_number": "+447700900123",
  "country": "United Kingdom",
  "dial_code": "+44",
  "proxyGroups": [
    "legacy"
  ]
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `platform` | string | The platform label for this actor (always `Twitter`) |
| `keyword` | string | The keyword currently being searched |
| `title` | string | The title text associated with the matched page/content |
| `description` | string | The description or snippet text used for phone number extraction |
| `url` | string | The URL pointing to the matched source page/content |
| `phone_number` | string | The extracted phone number in E.164 format (e.g. `+447...`) |
| `country` | string | The selected country name used for dialing/validation |
| `dial_code` | string | The dial code selected for the country (e.g. `+44`) |
| `proxyGroups` | array | The proxy configuration value used during the run (as provided by the actor input/engine logic) |

Note: output is saved per discovered phone number record during execution, so you can export results as JSON or CSV from the Apify dataset UI after the run.

***

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

1. **Open Apify Console**: Log in at [console.apify.com](https://console.apify.com) and go to the **Actors** tab.
2. **Find Twitter Phone Number Scraper**: Search for the actor and open its details page.
3. **Configure the INPUT form**:
   - Add your **`keywords`** (required)
   - Pick a **`country`** (required)
   - Optionally set **`maxPhoneNumbers`** to control how many results you want
   - Optionally choose an **`engine`** (`cost-effective` or `legacy`)
   - Optionally configure **`proxyConfiguration`**
4. **Start the run**: Click **Run** to begin scraping.
5. **Monitor logs & progress**: Watch for status messages as the actor finds and pushes phone number records.
6. **Review the OUTPUT dataset**: When the run finishes (or reaches `maxPhoneNumbers`), open the dataset in the **OUTPUT** tab.
7. **Export data**: Export your dataset to **JSON** or **CSV** to use in outreach, research, or lead-generation workflows.

No coding required—get your Twitter phone number harvesting results in minutes.

***

### Advanced features & SEO optimization

- ⚙️ **Built specifically for “twitter phone number scraper” use cases:** Engineered to extract phone numbers from Twitter bios, profiles, and posts related to your keywords
- 🔎 **Keyword + dial code targeting:** Using `keywords` and a selected country dial code improves how relevant the extracted phone numbers are
- ⏱️ **Run-time control via `maxPhoneNumbers`:** Helps manage performance for large searches by stopping at your chosen limit
- 🧩 **Engine flexibility:** Switch between **Cost Effective (New)** and **Legacy** modes based on your priorities (speed vs reliability)
- 💾 **Structured, CRM-friendly records:** Each output row includes `phone_number`, source `url`, and the matched `keyword`

***

### Best use cases

- 📈 **Lead generation teams building prospecting lists:** Collect phone numbers for outreach from relevant Twitter-related public content using focused keywords
- 🧠 **Market researchers mapping regional contact signals:** Extract numbers tied to a selected country dial code for analysis and reporting
- ✉️ **Sales ops enriching contact databases:** Add `phone_number` entries alongside the source `url` and matched `keyword`
- 🎓 **Recruiters and talent sourcers:** Find phone numbers from publicly available Twitter content tied to roles, brands, or founders
- 🧰 **Data analysts researching contact patterns:** Use structured JSON exports (`phone_number`, `country`, `dial_code`) for downstream processing
- 💻 **Automation workflows and CRM integrations:** Feed dataset exports into pipelines that require phone-number-centric lead data

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of strings
  - ✅ `country` as a selected country dial code entry
  - ✅ Optional: `platform` (fixed to `Twitter`), `maxPhoneNumbers`, `engine`, `proxyConfiguration`

- **Proxy Support**
  - ✅ Supports proxy configuration via `proxyConfiguration`
  - ✅ Actor also supports the `engine` choice labeled **Cost Effective (New)** vs **Legacy**

- **Retry Mechanism**
  - ✅ Includes retries and fallbacks for resilience when results are limited or blocked

- **Dataset Structure**
  - ✅ Saves one record per discovered phone number using fields: `platform`, `keyword`, `title`, `description`, `url`, `phone_number`, `country`, `dial_code`, `proxyGroups`

- **Rate Limits & Performance**
  - ✅ Uses `maxPhoneNumbers` to cap results and stop once the limit is reached
  - ✅ Larger runs (more keywords / higher limits) may take longer

- **Limitations**
  - ❌ Only extracts phone numbers that are present in publicly available Twitter content
  - ❌ Results are not guaranteed to reach `maxPhoneNumbers` (it depends on what the public content contains and what matches your filters)

***

### FAQ

#### What does the Twitter Phone Number Scraper extract?

✅ The actor extracts **phone numbers** from publicly available Twitter bios, profiles, and posts that are related to your provided `keywords`. It outputs the results with fields like `phone_number`, `url`, `country`, and `dial_code`.

#### Do I need to provide keywords?

✅ Yes. `keywords` is a required input field. You can include names, roles, or topical terms (for example: marketing, founder) to guide which Twitter content to target.

#### How does the country setting affect results?

✅ The `country` input selects a dial code and helps the actor focus on phone numbers relevant to that country dialing format. This improves targeting for your **twitter user phone number search** workflows.

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

✅ `maxPhoneNumbers` is the cap for how many unique phone numbers the scraper will collect. Once the limit is reached, scraping stops. This is especially helpful for budget control and predictable run durations.

#### Can I choose different engines?

✅ Yes. Use the `engine` field to select between **Cost Effective (New)** (`cost-effective`) and **Legacy** (`legacy`). This lets you balance different priorities for your scraping runs.

#### What output format do I get?

✅ The actor saves results as JSON records in the Apify dataset. Each record includes fields such as `platform`, `keyword`, `phone_number`, `url`, `country`, and `dial_code`.

#### Does the actor require login or special credentials?

✅ No login credentials are part of the provided actor inputs. It scrapes from publicly available sources and focuses on extracting phone numbers found in that public content.

#### Is it legal to scrape this data?

✅ You should ensure your usage complies with applicable laws (including GDPR/CCPA considerations), spam regulations, and Twitter’s and any related sites’ terms. Always use the data responsibly and ethically.

***

### Support & feature requests

Have questions about the **Twitter Phone Number Scraper**, or want to suggest improvements for your twitter contact scraper workflow? 💬

- 💡 **Feature Requests:** For example, request enhancements like better export control, additional output fields, or custom matching behaviors for twitter lead generation tool phone numbers use cases.
- 📧 **Contact:** Reach out at <dataforleads@gmail.com>.

Your feedback directly shapes the roadmap for this Twitter phone number extraction tool.

***

### Closing CTA / Final thoughts

*If you need a fast, structured way to run Twitter phone number harvesting at scale, the* **Twitter Phone Number Scraper** *is built for exactly that—engineered for real lead-generation and research workflows.*

***

### Disclaimer

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

You are responsible for ensuring your use complies with applicable laws (including GDPR and CCPA), spam regulations, and platform terms. If you need data removal or have a takedown request, contact <dataforleads@gmail.com>.

Please use this actor 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": "Twitter",
  "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/twitter-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/twitter-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/twitter-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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