# TikTok Profile Email Scraper (`neuro-data/tiktok-profile-email-scraper`) Actor

TikTok Profile Email Scraper SD - TikTok Profile Email Scraper is a powerful tool that extracts public bio emails, names, bios, avatars and exact follower, following, video and like counts from TikTok profile URLs or usernames - public data only, no login. Verified status via Data source Both.

- **URL**: https://apify.com/neuro-data/tiktok-profile-email-scraper.md
- **Developed by:** [Neuro Data](https://apify.com/neuro-data) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## TikTok Profile Email Scraper

**TikTok Profile Email Scraper** turns keywords, or a list of TikTok profile URLs and handles, into a clean dataset of public contact emails, bios, follower counts and avatars — a TikTok email finder and TikTok profile scraper in one Actor.

There are two ways in. Give this TikTok profile scraper **keywords** and it looks for accounts that publish a contact address, then enriches each one. Give it **profile URLs or usernames** and it goes straight to creators you already know.

A keyword run in the TikTok Profile Email Scraper does not return accounts that merely match a word. It targets pages that publish an address beside it, so most rows arrive with an email attached. Both inputs combine in one run.

The TikTok Profile Email Scraper uses no login, no cookies, no session token, no private or official API, no browser or JavaScript rendering. Only public profile data is collected.

One honest note up front. TikTok's page rate-limits shared proxy pools, so this TikTok email finder asks a public JSON endpoint first and parses the page only when that returns nothing.

Rows the TikTok Profile Email Scraper takes from that endpoint carry the handle, name, bio, avatar, ids and exact follower, following, video and like counts, but leave `isVerified`, `isPrivate` and `externalUrl` empty. **Data source: Both** fills those in.

***

### What the TikTok Profile Email Scraper does

The TikTok Profile Email Scraper both finds the audience and enriches it. It runs in two phases, and the order is the whole design.

**Phase 1 — Google harvest, on the GOOGLE\_SERP proxy.** Given keywords, the TikTok Profile Email Scraper searches Google with an email dork — `site:tiktok.com fitness coach "@gmail.com"` — expanded across keyword x modifier x address domain, paging up to `maxPagesPerKeyword` per query.

Each result block yields the account handle **and** the address published on that page, in one request. Google rarely prints the target URL now, so the handle comes from the site label, breadcrumb, or a `Name (@handle)` title.

This is where the volume and most of the addresses come from. Asking Google for pages that already carry an address is one request per ten accounts; fetching every profile hoping for one is a request each, and most bios have none.

**Phase 2 — profile enrichment, on the RESIDENTIAL proxy.** Every account found is then fetched for its profile data — followers, avatar, bio, verified flag — and merged into one row with the address from phase 1. Accounts you supply skip phase 1 and start here.

The TikTok Profile Email Scraper invents nothing: this is a TikTok contact scraper for addresses creators chose to publish. In order:

1. Reads `keywords` and/or `profileUrls` and `usernames`, then runs phase 1 and queues every handle harvested.
2. Normalises every target to one canonical URL — `https://www.tiktok.com/@username`. A bare handle, an `@handle` and a full URL resolve to the same target, and duplicates are dropped.
3. Fetches each profile through the Apify **residential** proxy, several in parallel, with a fresh exit IP on every retry. The first attempt sends a full browser header set, as a browser asks for a public page; a retry uses a plainer one.
4. Parses the response with a regex-first cascade, each step filling only what the previous could not, then extracts further emails from the bio, display name and external URL and pushes the row.

The cascade runs a regex battery against the raw HTML matching key names directly (`"signature"`, `"follower_count"`, `"is_verified"`), then the TikTok parser, then Open Graph tags. Matching key names rather than object paths is deliberate: platforms move those objects between releases, the key names survive.

***

### Why choose this TikTok Profile Email Scraper

Most tools sold as a TikTok bio email extractor need your logged-in session or hand you raw HTML. The TikTok Profile Email Scraper does neither, and what separates a usable TikTok email finder from a noisy one is filtering, not fetching.

**Obfuscation-aware hygiene.** Creators hide addresses on purpose. The TikTok Profile Email Scraper undoes `[at]`, `(dot)`, spaced `a @ b`, zero-width characters and full-width `＠`.

**Boundary-correct domains.** `@gmail.com` will not match inside `@gmail.company`, so your CRM avoids the malformed addresses a naive TikTok email extractor gives you.

**Junk filtered, role addresses kept.** Placeholders such as `email@`, `yourname@` and `noreply@` are dropped, as are prose words like `the@`. Real role addresses — `hi@`, `hey@`, `hello@` — are kept, because that is what creators publish.

**Every row saved as it lands.** Results stream: the TikTok Profile Email Scraper hands each account to profile enrichment the moment the Google search finds it, so the first rows are saved seconds into a run and keep arriving while the search continues.

Each saved row is logged as it is written, naming the handle, address and counts found, and every row carries the same field set whether it came from a keyword, the endpoint or the page.

***

### How to use the TikTok Profile Email Scraper step by step

Setup takes a minute.

1. **Open the TikTok Profile Email Scraper** on Apify and click **Try for free** or **Start**.
2. **Start from a keyword.** Type a niche or job title into *Search keywords* — `fitness coach`, `creator` — and the harvest finds accounts in it that publish an address. Add a *Location*, or raise *Pages per keyword* to find more.
3. **Or paste your targets** into *TikTok profile URLs*. Full URLs, bare handles and `@handles` all work, and every list is combined and de-duplicated.
4. **Pick your data source.** Leave it on **Auto** for one request per profile, or choose **Both** for `isVerified`, `isPrivate` and `externalUrl`.
5. **Set *Email domains*** to steer which address domains the search asks for, and to filter what is kept.
6. **Toggle *Only save profiles that have an email*** if a row without contact details is useless.
7. **Set *Max profiles*** to cap the run, and *Max concurrency* for parallelism — 1–30, default 10. Lower it if blocks appear.
8. **Leave the proxy on RESIDENTIAL.** Profile pages block datacenter IPs. Add a *Proxy country* only for a specific region.
9. **Click Save & Start.** Rows appear as they land.
10. **Export** to CSV, JSON, Excel or XML, or pull the dataset into your CRM through the Apify API.

At the end of a TikTok Profile Email Scraper run the log reports counts of ok, blocked, not found and errors, so you know what to re-run.

***

### Input schema

Every field the TikTok Profile Email Scraper accepts, nothing invented:

| Field | Type | Default | Meaning |
|---|---|---|---|
| `keywords` | array | prefilled with example terms | Search terms. The Actor finds matching TikTok accounts and scrapes each one. |
| `location` | string | `""` | Added to every keyword search, e.g. `New York`. Keyword search only. |
| `maxPagesPerKeyword` | integer 1–30 | `5` | Google results pages read per query. Raise to find more accounts. Keyword search only. |
| `expandQueries` | boolean | `true` | Search each keyword in several phrasings (keyword + "email", + "contact", …). Keyword search only. |
| `queryModifiers` | array | `email`, `contact`, `business inquiries`, `collab`, `booking`, `dm` | Extra words combined with each keyword when expansion is on. |
| `profileUrls` | array | `[]` | Full TikTok profile URLs. Bare usernames also accepted. |
| `usernames` | array | `[]` | Handles without the URL. Combined with the list above. |
| `customDomains` | array | `[]` | Address domains the search asks Google for, and a filter on the results. Empty searches the common free-mail providers and keeps every address found. |
| `onlyWithEmail` | boolean | `false` | Skip profiles whose public bio contains no address. |
| `maxProfiles` | integer 1–100000 | `100` | Stop after this many profiles are saved. |
| `maxConcurrency` | integer 1–30 | `10` | How many profiles are fetched in parallel, and how many Google searches run at once. Higher is faster; lower it if rows come back blocked. |
| `proxyGroup` | select | `RESIDENTIAL` | `RESIDENTIAL`, `BUYPROXIES94952` or `UNBLOCKER`. |
| `countryCode` | string | `""` | Two-letter proxy country (US, GB, DE…). Empty for any. |
| `dataSource` | select | `auto` | `auto`, `both` or `page`. See the table below. |
| `googleEmailSearch` | boolean | `true` | Run the per-account email search before the profile fetch. Off means a faster run. |

Supply the TikTok Profile Email Scraper with at least one of `keywords`, `profileUrls` or `usernames`; a run with none of them stops and tells you to add one.

#### The `dataSource` input

This input exists only on the TikTok Profile Email Scraper. No other Actor in the family has it, or returns `api` or `api+page` in `dataSource`.

| Value | Behaviour |
|---|---|
| `auto` (default) | Endpoint first; the page only if the endpoint returns nothing. One request per profile. |
| `both` | Endpoint, then the page as well, to fill in `isVerified`, `isPrivate` and `externalUrl`. Two requests per profile. |
| `page` | Skip the endpoint; fetch and parse the page only. |

The endpoint was chosen from a measurement. On a day when TikTok's page rate-limited the residential pool 0 out of 3, it answered 6 out of 6 — and it reports exact follower counts where the page rounds to `2.5M`.

#### Input examples

Starting from keywords, with no list of creators yet:

```json
{
  "keywords": ["fitness coach", "pastry chef"],
  "location": "Austin",
  "maxPagesPerKeyword": 5,
  "expandQueries": true,
  "onlyWithEmail": false,
  "maxProfiles": 500,
  "maxConcurrency": 10,
  "proxyGroup": "RESIDENTIAL",
  "dataSource": "auto"
}
```

Starting from creators you already know, or mixing both ways in one run:

```json
{
  "keywords": ["food creator"],
  "profileUrls": ["https://www.tiktok.com/@bakerjulia", "@paintwithlee"],
  "usernames": ["studioverde"],
  "onlyWithEmail": true,
  "maxProfiles": 500,
  "countryCode": "US",
  "dataSource": "both"
}
```

***

### Finding creators from a keyword

Keyword search in the TikTok Profile Email Scraper is a real search, not a filter over URLs you supplied. Give this TikTok email finder a niche and the harvest finds accounts in it that publish a contact address.

With `expandQueries` on, each keyword is combined with every entry in `queryModifiers` and every address domain, and each combination is paged separately. *Location* narrows it; `maxPagesPerKeyword` sets the depth.

Accounts you supplied are queued first, then whatever the harvest discovers.

***

### Two proxies in one run

The **GOOGLE\_SERP** proxy handles the harvest and the per-account email search; the **RESIDENTIAL** proxy runs the profile fetch. Neither group can do the other's job — Google is reachable only through GOOGLE\_SERP, TikTok needs residential exit IPs.

A TikTok Profile Email Scraper run with only profile URLs uses residential alone, unless the email search is on. A keywords-only run fails without GOOGLE\_SERP; if it also has profile URLs, it warns and continues.

#### The per-account email search

A TikTok-only step controlled by `googleEmailSearch` runs before the profile fetch, looking for an address published on the account's own profile page. Addresses from every route are merged into `emails`.

**What it is worth.** Redundancy rather than volume. Measured on eight accounts it found no address the bio did not already contain — but with the fetch blocked, the row still came back with the correct email and `emailSource: "search"`.

Post pages are excluded because Google indexes their comment sections, so addresses there belong to commenters. The TikTok Profile Email Scraper collects no emails from posts or comments.

***

### Output schema

Every TikTok Profile Email Scraper row has all of these fields:

| Field | Meaning |
|---|---|
| `success` | True when the profile was fetched and parsed, **or** an address was found. A blocked fetch still yields a usable row when an address was found. |
| `network` | Platform name |
| `dataSource` | Which path produced the profile data: `page`, `api` or `api+page` |
| `keyword` | The keyword that found this account, or `null` for a supplied URL |
| `query` | The exact Google query that found it, or `null` |
| `description` | The result snippet Google showed, cleaned of labels and counters |
| `profileUrl` | The canonical profile URL that was requested |
| `url` | The URL actually returned, after redirects |
| `username` | Handle |
| `fullName` | Display/real name as published |
| `displayName` | Handle or title the platform shows |
| `email` | First public email found, or `null` |
| `emails` | Every public email found, deduplicated |
| `emailSource` | Where the addresses came from: `search` (Google), `bio` (the profile), `bio+search`, or `null`. `search` is the common value on a keyword run |
| `bio` | Public bio / description text |
| `followersCount` | Followers, when published |
| `followingCount` | Accounts followed, when published |
| `postsCount` | Videos, when published |
| `likesCount` | Total likes/hearts, when published |
| `isVerified` | Verified badge, when published |
| `isPrivate` | Private account, when published |
| `avatarUrl` | Profile picture URL |
| `externalUrl` | Link published in the bio, when present |
| `userId` | Numeric/string platform id, when published |
| `secUid` | TikTok's secondary id |
| `error` | Why a row failed, or `null` |
| `scrapedAt` | ISO 8601 UTC timestamp |

A field TikTok does not publish is not part of the row at all. Normal, and not hidden.

#### Output example

A realistic TikTok Profile Email Scraper keyword-run row produced with `dataSource: "both"`:

```json
{
  "success": true,
  "network": "TikTok",
  "dataSource": "api+page",
  "keyword": "food creator",
  "query": "site:tiktok.com food creator email \"@gmail.com\"",
  "description": "Home baker in Austin. New recipe every Friday. Business: hello@juliabakes.co",
  "profileUrl": "https://www.tiktok.com/@bakerjulia",
  "url": "https://www.tiktok.com/@bakerjulia",
  "username": "bakerjulia",
  "fullName": "Julia Baker",
  "displayName": "bakerjulia",
  "email": "hello@juliabakes.co",
  "emails": ["hello@juliabakes.co"],
  "emailSource": "bio+search",
  "bio": "Home baker in Austin 🍰 new recipe every Friday | business: hello (at) juliabakes.co",
  "followersCount": 248317,
  "followingCount": 412,
  "postsCount": 619,
  "likesCount": 5138902,
  "isVerified": false,
  "isPrivate": false,
  "avatarUrl": "https://p16-sign-va.tiktokcdn.com/tos-avt-0068/8c1f2a9e.jpeg",
  "externalUrl": "https://linktr.ee/juliabakes",
  "userId": "6812345678901234567",
  "secUid": "MS4wLjABAAAAq1ZP0xw8m2Rr7bK3fH9tYc",
  "error": null,
  "scrapedAt": "2026-08-31T09:41:12.508Z"
}
```

Note `keyword`, `query` and `description`: which search found the account, and the snippet Google printed. The bio wrote the address as `hello (at) juliabakes.co`, normalised before matching.

***

### Use cases for the TikTok Profile Email Scraper

**Influencer marketing outreach.** Search a niche keyword and the TikTok Profile Email Scraper returns creators who publish a contact address, already enriched — the classic TikTok creator email scraper job.

**Agency prospecting.** Run a keyword for the vertical you sell into and build a pipeline of creators publishing a business email: a straightforward TikTok lead generation flow.

**UGC sourcing.** Use it as a TikTok contact scraper to find creators whose audience size matches your budget, then reach them directly.

**Lead enrichment.** You already have handles on your CRM records. Point the TikTok Profile Email Scraper at them and it fills the empty email column.

**Market research.** Measure audience size, video volume and total likes across a peer set — a TikTok profile scraper job with nothing to do with email.

***

### Limitations of the TikTok Profile Email Scraper

Read these before you run. Honest constraints of this TikTok profile scraper.

**Rate limiting is real.** TikTok's own profile page rate-limits shared proxy pools, which is why the TikTok Profile Email Scraper asks a public JSON endpoint first and falls back to the page only when that returns nothing. Some rows still come back blocked — lower `maxConcurrency` and re-run them.

**`auto` leaves three fields empty.** Rows resolved through the endpoint carry the handle, name, bio, avatar, ids and exact follower, following, video and like counts — but `isVerified`, `isPrivate` and `externalUrl` are empty. Choose **Both** to fill them.

**Yield varies, and it is not a promise.** The harvest asks for pages that publish an address, so most rows on a keyword run carry one. How many depends on the niche and how many creators in it publish one at all.

The TikTok Profile Email Scraper still returns a row when only profile data is available, with `email: null` — honest, not a failure. Addresses no longer come only from bios: the harvest, the per-account search and the profile are independent sources, and `emailSource` names the one that answered.

**The harvest needs the GOOGLE\_SERP proxy.** It is the only route to Google. A keywords-only run fails without that proxy group; a run that also has profile URLs logs a warning and carries on with those.

**Public data only.** No login, no cookies, no private or official API, no browser, no JavaScript rendering. Anything a signed-out visitor cannot see is out of reach, private accounts included.

**Retries are bounded.** Up to four attempts per page with backoff and a fresh exit IP; a login redirect counts as rate limiting, not a missing profile.

**Free plan cap.** On a free Apify account a run stops at 100 profiles; paid plans are uncapped. Platforms also change their markup: this TikTok bio email extractor is built to survive that, not to be immune.

***

### Pricing and run behaviour of the TikTok Profile Email Scraper

The TikTok Profile Email Scraper uses pay-per-event billing: `actor-start` once per run, and `profile-scraped` for each saved row.

Runs are resumable. Progress is keyed to a hash of the input, so a migrated or restarted run continues instead of refetching. Changing the input starts a clean run.

***

### FAQ

**How does keyword search work?**
In two phases. A Google harvest on the GOOGLE\_SERP proxy searches with an email dork — `site:tiktok.com fitness coach "@gmail.com"` — expanded across your keywords, `queryModifiers` and address domains, each result returning a handle with the address published beside it. Every account found is then fetched on the RESIDENTIAL proxy for its profile data, and the two are merged into one row.

**Why does a row have `success: true` when the fetch was blocked?**
Because `success` now means the run produced something usable: the profile was fetched, or an address was found. A blocked profile still yields a row with the email, and `error` records what happened.

**Do profile URLs and usernames still work?**
Yes, unchanged. Keywords are an additional way in, not a replacement, and both combine in one run — supplied accounts are queued first, then whatever the harvest discovers.

**Does it need my TikTok login, cookies or an API key?**
No. The TikTok Profile Email Scraper never logs in, never uses cookies or a session, and never touches a private or official API. It reads only public profile data.

**Why are `isVerified`, `isPrivate` and `externalUrl` empty on some rows?**
Those rows were resolved through the JSON endpoint under `auto`. Set **Data source** to **Both** to fetch the page as well.

**What does the per-account email search do, and can I turn it off?**
It runs through the GOOGLE\_SERP proxy, looking for an address published on the account's own profile page — a second route to the same email that still returns one when the fetch is blocked. It is not a way to find extra addresses; set `googleEmailSearch` to `false` to skip it.

**Will it find an email that was never made public?**
No. This TikTok email finder reads public pages — bio, display name, external URL, plus what Google indexed. Addresses never published stay out of reach.

**What if a creator wrote `name (at) domain (dot) com`?**
It is still matched. The TikTok Profile Email Scraper undoes obfuscation before extraction, including `[at]`, `(dot)`, spaced `a @ b`, zero-width characters and full-width `＠`.

**How many profiles can one run process?**
Free Apify plans are capped at 100 per run. On paid plans the TikTok Profile Email Scraper accepts a `maxProfiles` of up to 100000.

**Can I filter to only business domains?**
Yes. List them in `customDomains`. That steers which domains the search asks Google for and keeps only addresses on them.

**Does it work as a general TikTok lead generation tool?**
Yes. Start the TikTok Profile Email Scraper from a keyword and the harvest builds the list, then enrichment fills it in; or supply handles.

**Which platforms have a sibling Actor?**
Twenty-nine below — same engine, platform-specific parser.

***

### Related Actors

| Actor | Link |
|---|---|
| Facebook Profile Email Scraper | https://apify.com/neuro-data/facebook-profile-email-scraper |
| Instagram Profile Email Scraper | https://apify.com/neuro-data/instagram-profile-email-scraper |
| YouTube Profile Email Scraper | https://apify.com/neuro-data/youtube-profile-email-scraper |
| X Profile Email Scraper | https://apify.com/neuro-data/x-profile-email-scraper |
| Pinterest Profile Email Scraper | https://apify.com/neuro-data/pinterest-profile-email-scraper |
| Snapchat Profile Email Scraper | https://apify.com/neuro-data/snapchat-profile-email-scraper |
| Threads Profile Email Scraper | https://apify.com/neuro-data/threads-profile-email-scraper |
| Tumblr Profile Email Scraper | https://apify.com/neuro-data/tumblr-profile-email-scraper |
| Telegram Profile Email Scraper | https://apify.com/neuro-data/telegram-profile-email-scraper |
| Twitch Profile Email Scraper | https://apify.com/neuro-data/twitch-profile-email-scraper |
| Kick Profile Email Scraper | https://apify.com/neuro-data/kick-profile-email-scraper |
| Substack Profile Email Scraper | https://apify.com/neuro-data/substack-profile-email-scraper |
| Patreon Profile Email Scraper | https://apify.com/neuro-data/patreon-profile-email-scraper |
| Behance Profile Email Scraper | https://apify.com/neuro-data/behance-profile-email-scraper |
| Dribbble Profile Email Scraper | https://apify.com/neuro-data/dribbble-profile-email-scraper |
| DeviantArt Profile Email Scraper | https://apify.com/neuro-data/deviantart-profile-email-scraper |
| SoundCloud Profile Email Scraper | https://apify.com/neuro-data/soundcloud-profile-email-scraper |
| Mixcloud Profile Email Scraper | https://apify.com/neuro-data/mixcloud-profile-email-scraper |
| Mastodon Profile Email Scraper | https://apify.com/neuro-data/mastodon-profile-email-scraper |
| Bluesky Profile Email Scraper | https://apify.com/neuro-data/bluesky-profile-email-scraper |
| Linktree Profile Email Scraper | https://apify.com/neuro-data/linktree-profile-email-scraper |
| Gumroad Profile Email Scraper | https://apify.com/neuro-data/gumroad-profile-email-scraper |
| Buy Me a Coffee Profile Email Scraper | https://apify.com/neuro-data/buy-me-a-coffee-profile-email-scraper |
| GitHub Profile Email Scraper | https://apify.com/neuro-data/github-profile-email-scraper |
| GitLab Profile Email Scraper | https://apify.com/neuro-data/gitlab-profile-email-scraper |
| Hugging Face Profile Email Scraper | https://apify.com/neuro-data/hugging-face-profile-email-scraper |
| DEV Community Profile Email Scraper | https://apify.com/neuro-data/dev-to-profile-email-scraper |
| Hashnode Profile Email Scraper | https://apify.com/neuro-data/hashnode-profile-email-scraper |
| Flipboard Profile Email Scraper | https://apify.com/neuro-data/flipboard-profile-email-scraper |

***

### Support

Questions about the TikTok Profile Email Scraper, a bug report, or a custom TikTok lead generation build? Write to <neurodata.apify@gmail.com> with your run ID and input. Feature requests welcome too.

You are responsible for how you use the data this TikTok profile scraper returns, including compliance with privacy and marketing law where you operate.

# Actor input Schema

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

Search terms - a niche, job title or industry. The Actor finds TikTok accounts matching each term, then scrapes every account it finds. Use this when you do not already have a list of accounts. You can combine keywords with the profile URLs below.

## `location` (type: `string`):

Added to every keyword search, e.g. `New York`. Leave empty to search everywhere. Only applies to keyword search.

## `profileUrls` (type: `array`):

Full TikTok profile URLs, e.g. `https://www.tiktok.com/@username`. Bare usernames also work. Use this when you already know which accounts you want.

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

TikTok handles without the URL. Combined with the list above.

## `customDomains` (type: `array`):

Domains the keyword search asks Google for, e.g. `@gmail.com`. Also filters results to these domains. Empty searches the common free-mail providers and keeps every address found.

## `onlyWithEmail` (type: `boolean`):

Skip profiles whose public bio contains no contact address.

## `maxProfiles` (type: `integer`):

Stop after this many profiles have been saved.

## `maxPagesPerKeyword` (type: `integer`):

How many Google results pages to read per search query. Raise it to find more accounts. Keyword search only.

## `expandQueries` (type: `boolean`):

Search each keyword in several phrasings (keyword + "email", + "contact", ...) to reach accounts a single query misses. Keyword search only.

## `queryModifiers` (type: `array`):

Extra words combined with each keyword when query expansion is on. Leave empty to use the defaults for this platform.

## `maxConcurrency` (type: `integer`):

How many profiles are fetched in parallel, and how many Google searches run at once. Raise it for speed, lower it if you see blocked rows.

## `proxyGroup` (type: `string`):

RESIDENTIAL is recommended. Profile pages block datacenter IPs.

## `countryCode` (type: `string`):

Two-letter country code for the proxy (e.g. US, GB, DE). Empty for any.

## `dataSource` (type: `string`):

Auto asks a public JSON endpoint first and only falls back to the profile page when that returns nothing - fastest and least likely to be blocked. Both also fetches the page to fill in isVerified, isPrivate and externalUrl (two requests per profile). Page skips the endpoint entirely.

## `googleEmailSearch` (type: `boolean`):

Before each profile is fetched, search Google through the GOOGLE\_SERP proxy for addresses published next to that handle on TikTok. Finds emails that are indexed outside the bio the profile page renders. The profile itself is still fetched through the residential proxy. Turn it off for a faster, single-request-per-profile run.

## Actor input object example

```json
{
  "keywords": [
    "creator",
    "founder"
  ],
  "location": "",
  "profileUrls": [],
  "usernames": [],
  "customDomains": [],
  "onlyWithEmail": false,
  "maxProfiles": 100,
  "maxPagesPerKeyword": 5,
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "business inquiries",
    "collab",
    "booking",
    "dm"
  ],
  "maxConcurrency": 10,
  "proxyGroup": "RESIDENTIAL",
  "countryCode": "",
  "dataSource": "auto",
  "googleEmailSearch": true
}
```

# Actor output Schema

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

Records produced by TikTok Profile Email 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": [
        "creator",
        "founder"
    ],
    "location": "",
    "countryCode": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("neuro-data/tiktok-profile-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 = {
    "keywords": [
        "creator",
        "founder",
    ],
    "location": "",
    "countryCode": "",
}

# Run the Actor and wait for it to finish
run = client.actor("neuro-data/tiktok-profile-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 '{
  "keywords": [
    "creator",
    "founder"
  ],
  "location": "",
  "countryCode": ""
}' |
apify call neuro-data/tiktok-profile-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neuro-data/tiktok-profile-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/TNg2u30TBcP2x962L/builds/9KOqOrac2s4obbU0N/openapi.json