# Tinder Phone Number Scraper (`scrapers-hub/tinder-phone-number-scraper`) Actor

Tinder Phone Number Scraper collects publicly surfaced phone numbers by keyword, location and country, returning platform, title, description, URL and dial code. ⚠️ Dating-profile data carries GDPR exposure - confirm lawful basis first.

- **URL**: https://apify.com/scrapers-hub/tinder-phone-number-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:**
- **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/actors/running/actors-in-store.md#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

## 📱 Tinder Phone Number Scraper – Public Profile Contact Data & E.164 Number Extraction

The **Tinder Phone Number Scraper** collects publicly indexed Tinder profile pages that contain phone numbers and returns them as structured records — the number in E.164 format, the country and dial code it belongs to, the page title and description it came from, and the source URL. It works by searching public web indexes for Tinder pages matching your keywords and dial code, then parsing and normalising any phone numbers found in the visible result text.

This is a narrow, factual tool. It does not log into Tinder, does not read private profiles, and does not access the Tinder app or its API. It surfaces information that has already been published and indexed publicly. Because the output is personal data by definition, read the disclaimer at the end of this page before you run it — the legal responsibility for what you collect and what you do with it sits entirely with you.

***

### 📊 What Data Can You Extract with This Tinder Phone Number Scraper?

Each record represents one unique phone number found on one indexed page. The eight output fields group as follows.

| Category | Fields | What it gives you |
|---|---|---|
| ☎️ Phone data | `phone_number` | The extracted number, normalised to E.164 international format |
| 🌍 Country context | `country`, `dial_code` | The country the search targeted and the international dial code used |
| 🔗 Source page | `url`, `title` | The page the number was found on and its indexed title |
| 📝 Surrounding text | `description` | The visible text snippet the number appeared in |
| 🏷️ Provenance | `platform`, `keyword` | The platform the record came from and the keyword that produced it |

The `phone_number` field is the reason the actor exists, and its value is that it is already normalised. Numbers appear on pages in every conceivable format — with spaces, dashes, brackets, leading zeros or no country code at all. Returning them in E.164 means every record is directly comparable, deduplicated correctly, and ready for any system that expects a canonical international number.

***

### 🌟 Key Features of the Tinder Phone Number Scraper

| Feature | Description |
|---|---|
| 🔤 Multi-keyword input | Supply a list of keywords; each is turned into its own search and processed in sequence |
| 🌍 Country-aware searching | Choose a country and the scraper applies the matching international dial code to the search and to number parsing |
| 📍 Optional location narrowing | Add a location string to constrain results to pages mentioning that place |
| 📞 E.164 normalisation | Numbers are parsed and normalised to canonical international format rather than returned as raw text |
| 🔁 Automatic deduplication | Numbers already seen in the run are skipped, so each record is a distinct number |
| 💾 Resumable progress | The run stores its keyword cursor and the set of numbers already found, so an interrupted run resumes rather than restarting |
| 🎚️ Result cap | An optional maximum stops the run once you have collected as many numbers as you need |
| 📤 Incremental output | Records are pushed to the dataset as they are found, so partial results are available even if a run is stopped early |
| 🔄 Automatic proxy rotation | Search requests are routed through rotating proxies automatically; no proxy configuration is required |

***

### 🚀 Why Choose This Tinder Phone Number Scraper?

**Numbers arrive in a usable format.** Raw scraped text is close to worthless for phone data — the same number can appear five different ways on five different pages. Normalising to E.164 in `phone_number` means deduplication actually works and the output can be joined against other datasets without a cleanup pass.

**Every record keeps its evidence.** `url`, `title` and `description` are stored alongside the number, so you can always trace where a value came from and verify it yourself. That matters for any use case where you need to justify or audit the data you hold.

**Runs are resumable, not fragile.** The scraper checkpoints its keyword cursor and the set of numbers already seen. If a long run is interrupted, restarting continues from where it stopped instead of re-collecting everything.

**Country handling is explicit.** Selecting a country sets both the dial code used in the search and the region used when parsing numbers, so you get consistent, correctly-attributed results rather than a mixed international jumble.

***

### 📥 Input

```json
{
  "keywords": ["John", "Sarah"],
  "location": "London",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 100
}
```

#### 🔧 Tinder Phone Number Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | array | No | `["John"]` | Keyword strings to search for. Each keyword is processed as a separate search |
| `location` | string | No | `""` | Optional location term added to the search to narrow results geographically |
| `country` | string | No | `"United Kingdom (+44)"` | Country to target. Determines the international dial code applied to the search and to number parsing |
| `maxPhoneNumbers` | integer | No | unlimited | Maximum number of unique phone numbers to collect before the run stops |

The `country` value is supplied in the form `Country Name (+code)` and covers a wide list of countries with their international dial codes. The scraper splits the name from the code and uses both.

#### 💡 Input Examples

**Small validation run**

```json
{
  "keywords": ["Emma"],
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 25
}
```

**Multiple keywords, no location filter**

```json
{
  "keywords": ["Alex", "Jordan", "Sam"],
  "country": "Canada (+1)",
  "maxPhoneNumbers": 200
}
```

**Location-narrowed search**

```json
{
  "keywords": ["Maria"],
  "location": "Barcelona",
  "country": "Spain (+34)",
  "maxPhoneNumbers": 50
}
```

***

### 📤 Output

A representative record built from the actual output fields:

```json
{
  "platform": "Tinder",
  "keyword": "Emma",
  "title": "Emma, 27 – Tinder profile",
  "description": "Emma, 27. London. Message me on whatsapp +44 7700 900123 ...",
  "url": "https://tinder.com/@example-profile",
  "phone_number": "+447700900123",
  "country": "United Kingdom",
  "dial_code": "+44"
}
```

#### 🧾 Tinder Phone Number Output Fields

| Field | Type | Description |
|---|---|---|
| `platform` | string | Platform the item came from |
| `keyword` | string | Keyword that produced this item |
| `title` | string | Title of the indexed page the number was found on |
| `description` | string | Long-form description text surrounding the number |
| `url` | string | Canonical URL of the scraped item |
| `phone_number` | string | Phone number found for the item, normalised to E.164 |
| `country` | string | Country targeted by the search |
| `dial_code` | string | International dial code used |

***

### 💻 How to Use the Tinder Phone Number Scraper (Step by Step)

#### Step 1: Confirm you have a lawful basis

Before configuring anything, be clear about why you are collecting this data and under what legal basis. Phone numbers tied to dating profiles are sensitive personal data in most jurisdictions, and unsolicited contact based on scraped numbers is restricted or prohibited in many of them. The most defensible uses are narrow — verification, security research, or investigating misuse of your own platform. If you cannot articulate a lawful basis, do not run the scraper.

#### Step 2: Choose your keywords

`keywords` accepts a list of strings and defaults to `["John"]`. Each keyword becomes its own search, processed one after another, and every resulting record carries the keyword that produced it in the `keyword` field. Keep the list short at first — one or two keywords is enough to see what the output looks like before committing to a longer job.

#### Step 3: Select the country

`country` defaults to `"United Kingdom (+44)"` and is supplied in the `Country Name (+code)` format. This does two things: it inserts the dial code into the search so that pages containing numbers from that country are more likely to match, and it sets the region used when parsing and normalising numbers into E.164. Getting this wrong is the most common cause of an empty run, because a mismatched dial code will simply not appear on the pages you are looking for.

#### Step 4: Add a location if you need one

`location` is optional and defaults to empty. When you provide a value it is appended to the search as an additional constraint, so only pages mentioning that place are considered. This narrows results significantly — useful when you need geographic precision, counterproductive when you are trying to establish whether a keyword returns anything at all.

#### Step 5: Set a result cap

`maxPhoneNumbers` limits how many unique numbers the run collects before stopping. Leave it unset for an uncapped run, or set a specific number when you only need a sample. Because numbers are deduplicated as they are found, the cap counts distinct numbers rather than total pages processed.

#### Step 6: Run and watch the log

Start the run. The log announces each keyword as it begins, prints a line for every number found and pushed, and reports the running total. If the scraper collects fewer numbers than your target, it says so explicitly at the end rather than finishing silently — that message is your signal to broaden the keyword list or drop the location filter.

#### Step 7: Review and handle the output responsibly

Open the Dataset tab to see the collected records. Each row pairs a normalised `phone_number` with the `url`, `title` and `description` it came from, so you can verify any value against its source. Whatever you export, apply the same care you would to any personal data set: restrict access, set a retention limit, and delete it when the purpose you collected it for has been served.

***

### 🔌 API Access & Integrations

Run the Tinder phone number scraper over HTTP and get the dataset items back in the same call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~tinder-phone-number-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["Emma"],
    "location": "London",
    "country": "United Kingdom (+44)",
    "maxPhoneNumbers": 50
  }'
```

With the Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/tinder-phone-number-scraper").call(run_input={
    "keywords": ["Alex", "Jordan"],
    "country": "Canada (+1)",
    "maxPhoneNumbers": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["phone_number"], item["dial_code"], item["keyword"])
    print("  source:", item["url"])
```

Results can also be routed into Zapier, Make, Google Sheets or Slack, or delivered to your own endpoint using an Apify webhook on run completion.

***

### 💡 Best Use Cases for This Phone Number Data

#### 🛡️ Platform Trust and Safety Investigation

Trust and safety teams investigating scam networks often need to know which contact numbers are being circulated across dating platforms. Grouping records by `phone_number` and inspecting the associated `url` and `description` values shows whether a single number appears across many profiles — a strong signal of coordinated inauthentic behaviour.

#### 🔍 Fraud and Scam Pattern Research

Researchers studying romance fraud can use the combination of `keyword`, `country` and `dial_code` to map which regions and name patterns a scam campaign targets. Because `description` preserves the surrounding text, you can also study the scripted language used to move conversations off-platform.

#### 🧾 Exposure Auditing for Your Own Data

Individuals and organisations sometimes need to know whether a number they control has been published on public dating-related pages. Running a narrow search and checking whether a specific number appears in the results, along with the `url` that exposed it, is a legitimate self-audit use.

#### 📊 Public Data Exposure Studies

Academic and policy researchers studying how much personal contact data leaks into public web indexes can use aggregate counts by `country` and `dial_code` — without retaining the numbers themselves — to quantify exposure across regions. Aggregate-only retention is the privacy-safest way to work with this output.

#### 🕵️ Investigative Journalism and OSINT

Journalists verifying claims about a network or an individual sometimes need to establish whether a contact number appears in publicly indexed material. `url`, `title` and `description` provide the citable evidence trail that a bare number would not.

#### 🧪 Search-Index Coverage Testing

Security and privacy teams can use the actor to test how effectively removal requests have worked. If a page was supposed to be delisted, re-running a targeted search and checking whether the corresponding `url` still surfaces is a direct way to confirm.

***

### ⚙️ Tips for Better Phone Number Scraping Results

- **Match the country to the numbers you expect.** The dial code from `country` is used in the search itself. A mismatched country is the most common reason a run returns nothing at all.
- **Start without a `location` filter.** Adding a location narrows results sharply. Establish that a keyword returns anything first, then add the location to refine.
- **Use several keywords rather than one broad term.** Each keyword runs as its own search, and the `keyword` field keeps them separable in the output, so there is no downside to running a handful.
- **Set `maxPhoneNumbers` deliberately.** An uncapped run can search for a long time. A cap gives you a predictable stopping point and a sample you can evaluate before scaling up.
- **Let interrupted runs resume.** Progress is checkpointed, so restarting continues from the stored cursor rather than re-collecting from scratch. Do not clear state unless you intend a fresh run.
- **Verify before you act on any number.** Always check `url` and `description` before treating a value as accurate. Numbers extracted from page text can be typos, examples or unrelated to the profile they appear beside.

***

### 🛠️ Troubleshooting

**The run finished with zero numbers.**
The most likely cause is a country mismatch — the dial code from `country` is part of the search, so it must correspond to the numbers you expect to find. After that, check whether a `location` value is over-narrowing the search, and try a broader or more common keyword.

**I collected far fewer numbers than `maxPhoneNumbers`.**
The scraper logs this explicitly when the run ends below target. It means the available indexed pages for your keyword, country and location combination were exhausted. Add more keywords or remove the location constraint.

**The same number appears with different keywords.**
Deduplication is applied per run using the E.164 value, so a number should appear once. If you see near-duplicates, check whether they are genuinely different numbers that only look similar once normalised.

**A number in the output is clearly not a real contact.**
The extractor pulls numbers from visible page text, which can include example numbers, unrelated digits or misparsed strings. The `description` and `url` fields exist precisely so you can verify. Treat unverified numbers as leads, not facts.

**My results were capped unexpectedly.**
Free Apify plans are limited to a maximum of 100 phone numbers per run. The log states clearly when this limit has been applied and what the originally requested limit was.

***

### ❓ Frequently Asked Questions About Tinder Phone Number Scraping

**What does the Tinder Phone Number Scraper actually do?**
It searches publicly indexed pages for Tinder-related content matching your keywords and country dial code, extracts any phone numbers present in the visible text, normalises them to E.164, and writes them to a dataset alongside the source URL, title and description.

**Does it log into Tinder or use the Tinder app?**
No. It does not authenticate, does not use the Tinder app or its API, and does not access private profiles, matches or messages. It only reads publicly indexed page content.

**Where do the phone numbers come from?**
From the visible text of publicly indexed pages — typically numbers that people have themselves published in profile text or that have been reproduced on public pages. Nothing is taken from a private source.

**What format are the phone numbers returned in?**
E.164 international format, for example `+447700900123`. This makes deduplication reliable and lets the output be joined against other systems without reformatting.

**Can I search for numbers in a specific country?**
Yes. The `country` field takes a value like `Spain (+34)` and applies the matching dial code to both the search and number parsing. A broad list of countries and dial codes is supported.

**Can I narrow results to a city or region?**
Yes, using the optional `location` field. It adds the location term to the search, which constrains results to pages mentioning that place.

**How many phone numbers can I collect in one run?**
Set `maxPhoneNumbers` to whatever you need, or leave it unset for an uncapped run. Free Apify plans are limited to 100 numbers per run; paid plans are not subject to that restriction.

**Are duplicate numbers removed?**
Yes. The scraper tracks numbers already seen within a run and skips repeats, so each dataset row is a distinct number.

**What happens if my run is interrupted?**
Progress is checkpointed — both the keyword cursor and the set of numbers already found are stored — so restarting resumes from where the run stopped rather than beginning again.

**Do I need to set up a proxy?**
No. Proxy rotation for the search requests is handled automatically inside the actor, so there is no proxy field for you to configure.

**Is scraping phone numbers from public pages legal?**
It depends entirely on your jurisdiction, your purpose and what you do next. The data is publicly accessible, but publicly accessible does not mean unrestricted — phone numbers are personal data under GDPR and similar laws, and using them for unsolicited contact is separately regulated. Take your own legal advice.

**Can I use these numbers for marketing or cold outreach?**
You should not. Contacting individuals on the basis of scraped dating-profile numbers is very likely to breach privacy, anti-spam and telecommunications regulations in most jurisdictions, and it is not a use this actor is intended for.

**Why is the `description` field useful?**
It preserves the text the number appeared in, which is your only way to judge whether the extraction is meaningful. It is also what makes scam-pattern research possible, since the surrounding language is often more revealing than the number itself.

**How do I export the results?**
Use the Apify Console dataset export (JSON, CSV, Excel, XML) or call `run-sync-get-dataset-items` via the API to receive the items directly in the response.

**How should I store and retain this data?**
Treat it as sensitive personal data. Restrict access to those who need it, define a retention period tied to your stated purpose, and delete it when that purpose ends. Do not redistribute it.

***

### 🆘 Support & Feedback

If you hit a bug or an unexpected result, open a ticket in the **Issues** tab on the actor page and include the run ID and the input you used so the case can be reproduced.

For custom work — a different search strategy, additional fields, or an integration with your investigation tooling — email **scraperhubapi@gmail.com** with your requirements.

If the actor works well for your use case, a rating and a short review on the actor page is appreciated and helps guide future improvements.

***

### ⚖️ Disclaimer

This Tinder phone number scraper reads only publicly indexed, publicly accessible page content. It does not authenticate to Tinder, does not access private profiles, matches or messages, and does not bypass any access control.

You are entirely responsible for how you use this actor and the data it produces. That includes compliance with the terms of service of Tinder and of any search or indexing service involved, and with all applicable law in your jurisdiction and your subjects' jurisdictions.

Phone numbers, names and profile text are personal data under GDPR, CCPA and comparable privacy regimes, and dating-platform data attracts heightened sensitivity. If you collect this output you are the data controller: you must have a lawful basis, you must minimise what you retain, you must secure it, and you must honour access and erasure requests. Using scraped numbers for unsolicited marketing, harassment, stalking, doxxing or any form of contact the individual has not agreed to is unlawful in most jurisdictions and is not a supported use of this actor. Do not use this data to identify, contact, profile or target individuals without a clear legal basis.

If you believe data collected through this actor should be removed, contact **scraperhubapi@gmail.com** with the details and the request will be actioned.

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

## Actor input object example

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

# Actor output Schema

## `results` (type: `string`):

Records scraped by Tinder Phone Number Scraper, stored in the run's default dataset.

# 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("scrapers-hub/tinder-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("scrapers-hub/tinder-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": [
    "marketing",
    "founder"
  ]
}' |
apify call scrapers-hub/tinder-phone-number-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/tinder-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/Gj8jmBshZdp7dwI6k/builds/zd8el4Wou1gJLqHtV/openapi.json