# TikTok Email Scraper - Creator Emails from Bio & Link Pages (`neverempty/tiktok-email-scraper`) Actor

Paste TikTok usernames and get each creator's business email: from the bio, their link-in-bio page (Linktree, Beacons, Stan) or their own website, with the page it came from. You pay only for creators with an email found.

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

## Pricing

from $12.00 / 1,000 creator with an email founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## TikTok Email Scraper — creator emails from the bio, link-in-bio page and website

Paste a list of TikTok usernames and get back each creator's **business email**, with the exact place it was published: the TikTok bio, their link-in-bio page (Linktree, Beacons, Stan and similar) or a contact page on their own website. **You pay only for creators where an email was found.** Creators with no published email, usernames that do not exist and pages that came back as a bot check get a row with the reason, free.

> **Personal data.** Emails and names can be personal data under the GDPR, the CCPA and similar laws. This Actor only collects addresses that creators published themselves, but **you are responsible for having a lawful reason to store and use them** and for following anti-spam rules (CAN-SPAM, PECR and the like) when you contact anyone.

### Best for

- **Influencer outreach**: turn a list of creators you found on TikTok into a contact list in one run.
- **Agencies and brands** checking which creators in a shortlist accept business enquiries by email.
- **Cleaning a list**: one row per creator, duplicates collapsed, with the source of every email so you can check it yourself.

### How it finds an email

1. **The bio.** If the creator wrote an email in their TikTok bio, that is used (source `bio`).
2. **The bio link.** If the bio has none, the link in the profile is opened and judged by **where it really leads** (short links such as `bit.ly` are followed first).
   - On a **link-in-bio page** (Linktree, Beacons, Stan, lnk.bio and similar) the Actor reads only that one page: the email buttons and the email written on it. It never adds paths such as `/contact` to those sites, because `linktr.ee/contact` is somebody else's page.
   - If that page has no email, the Actor opens the **first link that looks like the creator's own website** (a site with their name in it is preferred) and checks its home page plus up to `maxPagesPerSite` contact or about pages on the same site. If the link points to an inner page (not the site's front page) and the address does not carry the creator's name, only that one page is read, so a page that belongs to somebody else on a shared host is never treated as the creator's.
   - Shops, social networks, music services, payment pages and affiliate links are never treated as the creator's website, so you do not get `support@` addresses of big companies.
3. **A website written in the bio.** If there is no bio link, a website written in the bio text is used the same way, but only when it is written as `https://…` or `www.…`, or when the address contains the creator's name. A handle such as `ja.dey` is not mistaken for the site `ja.de`.

Every email in `emails` has a matching entry in `emailSources` saying where it was found, for example `bio` or `https://creator-site.com/contact`.

### What each row contains

| Column | What it is |
|---|---|
| `username`, `nickname` | TikTok handle and display name |
| `profileUrl` | Link to the TikTok profile |
| `followers` | Follower count shown by TikTok |
| `verified` | Whether TikTok shows the verified badge |
| `signature` | The bio as written (phone numbers removed) |
| `bioLink`, `bioLinkFinalUrl` | The link in the profile and the page it actually led to |
| `emails` | Every published email found, lower-case, no duplicates |
| `emailSources` | Where each email was found, in the same order |
| `websites` | The pages that were checked |
| `pagesCrawled` | How many pages outside TikTok were opened |
| `ok`, `status`, `reason` | `ok: true` when an email was found; otherwise the reason in plain English |
| `checkedAt` | When the row was made |

Example row (made-up values):

```json
{
  "username": "example.creator",
  "nickname": "Example Creator",
  "profileUrl": "https://www.tiktok.com/@example.creator",
  "followers": 48200,
  "verified": false,
  "signature": "Recipes every week | collabs below",
  "bioLink": "linktr.ee/examplecreator",
  "bioLinkFinalUrl": "https://linktr.ee/examplecreator",
  "emails": ["hello@example-creator.test"],
  "emailSources": ["https://linktr.ee/examplecreator"],
  "websites": ["https://linktr.ee/examplecreator"],
  "pagesCrawled": 1,
  "ok": true,
  "status": "ok",
  "reason": null,
  "checkedAt": "2026-10-25T10:00:00.000Z"
}
```

### What you pay for

- One `email-found` charge per creator **with at least one email**, however many emails that creator has.
- The same creator is charged once per run, even if you paste the name three times or as both `@name` and a profile URL.
- Free rows: `no-email`, `no-such-profile`, `blocked`, `unreadable`, `not-a-username`, `duplicate`. If your spending limit is reached, the run stops cleanly with one free row saying so.

### Input

```json
{
  "usernames": ["@creator_one", "creator_two", "https://www.tiktok.com/@creator_three"],
  "followLinks": true,
  "maxPagesPerSite": 3,
  "useProxy": true
}
```

- `usernames`: handles with or without `@`, or profile URLs.
- `followLinks`: turn off to read the TikTok bio only (faster, fewer emails).
- `maxPagesPerSite`: contact or about pages to check on the creator's own website (1–10). The link-in-bio page does not count.
- `useProxy`: TikTok sometimes answers a bot check instead of the profile; with this on, those tries are repeated through Apify Proxy. A creator's website that answers HTTP 403 is also read once more through an Apify datacenter proxy.

### Good to know

- **Only emails the creator published are returned.** Addresses written as `name [at] site com`, hidden behind a contact form or protected by Cloudflare's email obfuscation are deliberately not decoded.
- **Addresses that belong to platforms are dropped**: `noreply@`, `privacy@`, and addresses at Linktree, TikTok, Wix, Shopify and similar.
- **No phone numbers** are collected; they are removed from the bio column too.
- Many creators publish no email at all, so expect a share of free `no-email` rows. You are not charged for them.
- Pages that need a login or a click to reveal an email can not be read.
- The Actor checks one website per creator, not every link on their page.
- Some websites refuse automated visits (HTTP 403) even after one more try through a datacenter proxy. Those creators get a free `no-email` row that says the site blocked the visit.
- For a small share of profiles TikTok answers with its own code (for example 10222) instead of the profile, from any connection. Those rows are free `unreadable` rows with the code in `reason`.

### Questions

**How do I get emails of TikTok creators from a list of usernames?**
Paste the usernames into `usernames` and run. Each creator gets one row; the ones with a published email have it in `emails` with the source in `emailSources`.

**Does it read Linktree?**
Yes. It reads the creator's own Linktree data (their links and email button), not the adverts Linktree adds to the page.

**Will I be charged for creators with no email?**
No. Only rows with at least one email are charged.

**Can it find emails hidden behind "Email" buttons in the TikTok app?**
No. This Actor reads what is public on the web pages of the profile and its links, not buttons inside the TikTok app.

### Thanks for using this Actor

We build these tools for people who run them every day, and we improve them from what users tell us.

- **Missing a field, or need another filter?** Tell us in the **Issues** tab. If the data is there, we add it.
- **Found a bug or a wrong value?** Post the run ID in the **Issues** tab. Wrong data is the thing we fix first.

If this Actor saved you time, a short review helps other people find it.

# Actor input Schema

## `usernames` (type: `array`):

One creator per line: @name, name, or https://www.tiktok.com/@name. The same creator written two ways is read once and charged once. Left empty, the run reads the three example creators shown here.

## `followLinks` (type: `boolean`):

When the bio itself has no email, open the creator's bio link. On a link-in-bio page (Linktree, Beacons, Stan and similar) only that page is read; if it has no email, one link to the creator's own website is checked (a site with their name in the address is preferred). Turn off to read bios only.

## `maxPagesPerSite` (type: `integer`):

How many pages of the creator's own website to read when looking for an email (the home page, then contact or about pages). A link-in-bio page is not counted. 1 to 10.

## `useProxy` (type: `boolean`):

Profiles and websites are read directly first. If TikTok answers with a bot check, the Actor retries through a residential proxy. If a creator's website answers HTTP 403, that page is read once more through a datacenter proxy. Turn off to report those as blocked instead.

## Actor input object example

```json
{
  "usernames": [
    "@thatlittlepuff",
    "emilymariko",
    "https://www.tiktok.com/@drjulie"
  ],
  "followLinks": true,
  "maxPagesPerSite": 3,
  "useProxy": true
}
```

# Actor output Schema

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

One row per TikTok creator: username, display name, profile link, follower count, verified flag, the bio (phone numbers removed), the bio link as typed and where it really leads, every email the creator published with the place it was found (the bio, their link-in-bio page or a page of their own website), and the pages that were checked. Creators with no published email, usernames TikTok returns nothing for and pages that came back as a bot check get their own rows with the reason and are not charged.

# 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 = {
    "usernames": [
        "@thatlittlepuff",
        "emilymariko",
        "https://www.tiktok.com/@drjulie"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/tiktok-email-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 = { "usernames": [
        "@thatlittlepuff",
        "emilymariko",
        "https://www.tiktok.com/@drjulie",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("neverempty/tiktok-email-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 '{
  "usernames": [
    "@thatlittlepuff",
    "emilymariko",
    "https://www.tiktok.com/@drjulie"
  ]
}' |
apify call neverempty/tiktok-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/tiktok-email-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/qUoKoFNIiVYuyvLCC/builds/ZZ77qie5M0a0dSwVh/openapi.json