# Threads Phone Number Scraper (`socialdataapi/threads-phone-number-scraper`) Actor

Threads Phone Number Scraper searches public Threads pages for phone numbers matching your keywords and country: number in international format, link, title and text. No Threads account or login. Export as JSON, CSV or Excel, or use the API.

- **URL**: https://apify.com/socialdataapi/threads-phone-number-scraper.md
- **Developed by:** [Social Data API](https://apify.com/socialdataapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.18 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Threads Phone Number Scraper — Numbers, Profiles and Page Links

Threads Phone Number Scraper searches public Threads pages for phone numbers that match your keywords and the country you choose. Each result returns the number in international format, the page link, the title and the public text the number appears in. Every response is structured JSON — ready to pass directly to an LLM, index into a vector store, or feed a lead-generation pipeline. **No Threads account or login needed** to run a search. Add more keywords to search more pages in one run.

![Threads Phone Number Scraper: every page and phone number from Threads as JSON](https://api.apify.com/v2/key-value-stores/WYkyEfqs10huyXYxr/records/j-threads-phone-hero.webp)

***

### What data can I extract with Threads Phone Number Scraper?

Using this Threads phone number API, you will be able to extract the following Threads phone number data:

| 📱 Platform | 🔑 Keyword searched | 📝 Page title | 📰 Page description |
| --- | --- | --- | --- |
| 🔗 Page URL | 📞 Phone number (E.164) | 🌍 Country | ☎️ Dial code |

***

### How to use Threads Phone Number Scraper

Marketers, recruiters and lead-generation teams use this actor to find phone numbers on Threads without opening the app.

**Copy to your AI assistant:**

```text
Threads Phone Number Scraper is an Apify Actor that returns phone numbers found on public Threads pages as structured JSON: platform, keyword, page title, page description, page URL, phone number, country and dial code. Use it whenever someone needs to find phone numbers on Threads without cookies, a login, or a browser - for threads phone number lead generation, to scrape threads profile phone numbers at scale, or to build recruiter outreach lists. Inputs: keywords (array of search terms, "@usernames" or threads.net/threads.com URLs, required), country (select from 194 countries or "Global", required), maxPhoneNumbers (integer 1-10000, default 10, how many numbers to collect per keyword), engine (select "legacy", default "legacy"), proxyConfiguration (object, defaults to Apify Proxy). Each keyword stops once maxPhoneNumbers is reached, its results run out, or 3 result pages in a row add no new number; up to 30 pages are checked per keyword per search engine, and the free Apify plan caps results at 20 per run in total (all keywords together) and 200 per month.
```

#### Step by step

1. [Create a free Apify account](https://console.apify.com/sign-up).
2. Open [**Threads Phone Number Scraper**](https://apify.com/socialdataapi/threads-phone-number-scraper) in the Apify Store.
3. Enter one or more keywords, `@usernames` or `threads.net`/`threads.com` URLs, plus the country whose numbers you want.
4. Click **Start**.
5. Download or stream your results in JSON, CSV or Excel.

#### How to scale Threads Phone Number Scraper to bulk

`keywords` takes a list, so add every search term, `@username` or `threads.net`/`threads.com` URL you want covered in one Input field — up to 3 keywords are processed at the same time, each with its own `maxPhoneNumbers` budget. To cover more ground over time, schedule the Actor to run on a recurring basis with a rotating keyword list, or call it from the Apify API with a different `keywords`/`country` pair per run.

***

### ✨ Features

Threads Phone Number Scraper is, at its core, a threads.net phone number finder: point it at a keyword and a country, and it fetches clean, structured matches from public Threads pages ⚡ at low cost 💸. It's ideal for lead generation, local-market research, recruiter outreach and B2B prospecting.

It extracts, per match:

- **Phone number** – the number in E.164 international form.
- **Page title** – the result's title as shown in the search listing.
- **Page description** – the public text the number appears in.
- **Country / dial code** – the country the number was matched against.
- **Page URL** – the profile or post link, without tracking parameters.

⚡ Country-aware validation checks the number's digit count and, where known, its national numbering plan, so dates, prices and other digit runs that only look like a phone number never make it into the dataset. The search also covers both `threads.net` and `threads.com`, since Meta serves Threads under either domain.

***

### Use cases 💡

- **Sales rep** — build a call list of page owners by keyword and country in one run.
- **Recruiter** — search niche keywords to find a business's listed contact number.
- **Local-market researcher** — use it as a threads contact phone number extractor to map every number for one city.
- **Growth marketer** — seed a cold-outreach list from public profiles and posts for one city or niche.
- **AI agent builder** — feed matched numbers straight into a CRM-enrichment or lead-scoring pipeline with no parsing step.

***

### Why choose this actor?

- **Find threads business phone number matches in one pass.** A recorded run returned 1 number for `real estate`/India in 10.2 seconds and another for `contact`/United Kingdom in 17.4 seconds, both run locally without a proxy.
- **Eight fields per match, every one checked.** Each row carries the page title and the public text the number appeared in, plus the matched country and dial code — no username field is invented for a platform whose public pages don't surface one here.
- **A threads public profile phone number scraper across two domains.** Numbers are checked against 194 countries' dial codes (plus a Global catch-all), and the actor watches both `threads.net` and `threads.com` in the same search.

***

### ⬇️ Input

![Threads Phone Number Scraper input: keywords, country and max phone numbers](https://api.apify.com/v2/key-value-stores/WYkyEfqs10huyXYxr/records/j-threads-phone-input.webp)

Enter one or more keywords, `@usernames` or `threads.net`/`threads.com` URLs (required) and the country whose numbers you want (required); the rest is optional and has a working default.

| Parameter | Required | Type | Description | Example value |
| --- | --- | --- | --- | --- |
| `keywords` | Yes | Array of strings | Keywords, `@usernames` or `threads.net`/`threads.com` URLs. Each one is searched on its own and gets its own budget of `maxPhoneNumbers`; usernames/URLs are reduced to the page name and duplicates are dropped. | `["real estate", "property"]` |
| `country` | Yes | String (select) | Country whose phone numbers you want, from 194 countries, or `Global` for no filter (only `+`/`00`-prefixed numbers are kept). | `"India (+91)"` |
| `maxPhoneNumbers` | No | Integer | How many phone numbers to collect per keyword (1–10,000, default 10). Free-plan runs are capped at 20 per run in total (all keywords together) and 200 per month. | `50` |
| `engine` | No | String (select) | Processing engine. There is one engine (`legacy`). | `"legacy"` |
| `proxyConfiguration` | No | Object | Proxy used for the searches. Defaults to Apify Proxy; the actor still runs without one, usually with fewer results. | `{"useApifyProxy": true}` |

#### Free plan limits

Users on the Apify free plan can fetch up to 20 phone numbers per run (all keywords together) and 200 phone numbers per month. When the limit is reached, the run finishes successfully with a status message explaining the limit. Upgrade to any paid Apify plan to remove these limits.

#### Example input

```json
{
  "keywords": ["real estate", "property"],
  "country": "India (+91)",
  "maxPhoneNumbers": 50,
  "engine": "legacy",
  "proxyConfiguration": { "useApifyProxy": true }
}
```

***

### ⬆️ Output

![Threads Phone Number Scraper output: one row per number with platform, keyword, phone number and country](https://api.apify.com/v2/key-value-stores/WYkyEfqs10huyXYxr/records/j-threads-phone-output.webp)

Every match is one typed, normalized JSON item with the same schema on every run; pages are de-duplicated per keyword by URL, so the same number can appear on more than one row when different pages show it. Export as JSON, CSV or Excel.

#### Example output

```json
{
  "platform": "Threads.net",
  "keyword": "real estate",
  "title": "Sawera Townships - Open Plots Telangana (@saweratownships ...",
  "description": "66 Followers • 39 Threads • \"Welcome to Sawera Townships India Private Ltd, Leading Real Estate Company In Telangana, Hyderabad. Contact Us (+ 91 -9885444044). See the latest conversations with...",
  "url": "https://www.threads.com/@saweratownships",
  "phone_number": "+919885444044",
  "country": "India",
  "dial_code": "+91"
}
```

***

### How does it work?

Threads Phone Number Scraper doesn't log into Threads at all. For every keyword it runs a public web search (automatically retrying through a fallback path if the first attempt is blocked) for public `threads.net`/`threads.com` pages — profiles and posts — that mention a phone number matching your chosen country. As a threads bio phone number finder, it only ever opens pages any logged-out visitor could already see: it never follows a private profile or reads a login-gated post. The number is read from the page's own public title and text, then normalised to international E.164 form and checked against the country's real dial code and, where known, its national numbering-plan length. Requests rotate through fresh proxy sessions when blocked, so results stay stable even as Threads' pages and the public web's search results change.

***

### How do you integrate Threads Phone Number Scraper into your stack?

Threads Phone Number Scraper works with what you already use: call it from any language over a REST API, or wire it into a no-code tool without writing a scraper yourself.

#### No-code tools (n8n, Make, LangChain)

In n8n, use the Apify node's **Run an Actor** action, or the HTTP Request node pointed at the Actor's run-sync endpoint with your Apify token. In Make, use the Apify app's **Run an Actor** module followed by **Get Dataset Items**. In LangChain, install `langchain-apify` and call `ApifyActorsTool()` to let an agent run it as a tool.

***

### Is it legal to scrape Threads data?

Scraping publicly available data, including public Threads pages, is generally permitted; the legal risk sits mostly in how the data is stored and used afterward, not in the act of reading a public page. Threads Phone Number Scraper returns only publicly available data — what any logged-out visitor already sees. If you operate in the EU, GDPR still applies to storing and using numbers you collect: keep records you can justify and delete them when asked to. In countries with telemarketing or anti-spam rules, outreach to a number found this way is still subject to those rules — the Actor finds public numbers, it does not grant permission to contact them. Consult legal counsel if your use case involves bulk storage of personal data.

***

### Frequently asked questions

#### What fields does Threads Phone Number Scraper return?

Threads Phone Number Scraper returns the phone number, the page title, the page URL and the matched country for every page it finds. See [the data fields section](#what-data-can-i-extract-with-threads-phone-number-scraper) for the full list.

#### Does Threads Phone Number Scraper require a Threads account or login?

No. Only public profile and post pages are read — the kind any logged-out visitor can already open — and no Threads credentials are ever requested.

#### How fast does Threads Phone Number Scraper run?

It depends on the keyword and country, but a recorded local run returned 1 number for `real estate`/India in 10.2 seconds, and another returned 1 number for `contact`/United Kingdom in 17.4 seconds — live data, never cached.

#### What happens if a Threads page is private or doesn't exist?

No row is produced for a keyword with no public page showing a matching-country number. The Actor never opens private profiles or login-gated posts, so a private account simply contributes nothing to the results.

#### Can I scrape multiple Threads pages at once?

Yes. `keywords` takes a list, so you can run a threads app phone number scraper search across many terms in one call, with up to 3 keywords processed at the same time.

#### Does Threads Phone Number Scraper return data in a format LLMs can use directly?

Yes. Every result is typed, normalized JSON with consistent field names — no HTML parsing, no selectors. Pass it straight to an LLM, index it into a vector store, or feed it to an agent tool with no transformation step.

#### What happens when Threads changes its layout or updates its anti-bot system?

This actor reads general page text rather than one fixed selector, so most layout changes don't break it outright. When Threads makes a bigger change, the actor is updated and your calls keep returning the same JSON schema on your end.

#### Can I use Threads Phone Number Scraper without managing proxies or browser infrastructure?

Yes. Proxy rotation and retry handling run on the Actor's side — plain HTTP requests, no headless browser to install or maintain. You send one request and get structured JSON back.

#### Which Threads Phone Number Scraper fields work best for AI training data and RAG indexing?

For RAG: index the page title and the page description, since that's the text the number was actually found in. For training data or filtering: the country and dial code fields are typed strings you can group and join on directly, no normalization needed.

***

### Your feedback

Found a bug or missing a field? Let us know through the Issues tab on this actor's Apify Store page. Every report is read and feeds into the next fix.

# Actor input Schema

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

Keywords, usernames (@username) or threads.net URLs. Usernames and URLs are reduced to the page name. Each entry is searched on its own and gets its own budget of maxPhoneNumbers results. The keyword field of every row keeps the value exactly as you entered it; duplicates are dropped.

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

Country whose phone numbers you want. Its dialling code narrows the search and every number is normalised to international form (E.164) for this country; numbers that cannot belong to it are dropped. Global = no country filter: only numbers written with an explicit +/00 country code are kept.

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

How many phone numbers to collect for each keyword (1-10000). A keyword stops earlier when the results run out, or after 3 result pages in a row without a new number. Free plan users are limited to 20 items per run in total (across all keywords) and 200 items per month; paid plans have no limit.

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

Processing engine. There is one engine; the values saved by earlier versions of this actor are still accepted and run the same engine.

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

Proxy used for the searches. Apify Proxy is recommended: blocked requests are retried up to 3 times, each with a new proxy session. Without a proxy the actor still runs, usually with fewer results.

## Actor input object example

```json
{
  "keywords": [
    "whatsapp"
  ],
  "country": "India (+91)",
  "maxPhoneNumbers": 10,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

## `results` (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": [
        "whatsapp"
    ],
    "country": "India (+91)",
    "maxPhoneNumbers": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "GOOGLE_SERP"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("socialdataapi/threads-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": ["whatsapp"],
    "country": "India (+91)",
    "maxPhoneNumbers": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["GOOGLE_SERP"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("socialdataapi/threads-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": [
    "whatsapp"
  ],
  "country": "India (+91)",
  "maxPhoneNumbers": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}' |
apify call socialdataapi/threads-phone-number-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,socialdataapi/threads-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/SG00fkgcTCJhbTZv8/builds/Dh5GoSBSIVPXOMIm5/openapi.json