# TikTok Profile Mention Scraper (`maximedupre/tiktok-profile-mention-scraper`) Actor

Find public TikTok videos that mention profile handles. Export captions, engagement metrics, author details, music metadata, media URLs, match evidence, and source links.

- **URL**: https://apify.com/maximedupre/tiktok-profile-mention-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.70 / 1,000 scraped tiktok mention videos

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 mention scraper for public videos

TikTok Profile Mention Scraper finds public [TikTok](https://www.tiktok.com/) videos that mention one or more profile handles. Paste TikTok handles, `@handles`, profile URLs, or a newline-separated list, then export matching videos with captions, engagement metrics, author details, music metadata, media URLs, source links, match evidence, and scrape timestamps.

Use this TikTok profile mention scraper when you need to monitor brand mentions, creator mentions, campaign shoutouts, user-generated content, competitor references, or public videos that mention a TikTok account. Instead of checking TikTok search by hand, you get a clean Apify dataset that can be downloaded as JSON, CSV, Excel, XML, RSS, or HTML, or used through the Apify API, schedules, webhooks, and integrations.

For a quick first run, keep the prefilled `tiktok` target and the default result limits. The Actor runs on public TikTok data only and does not require a TikTok login, cookies, or a TikTok API key.

### ✅ What this Actor does

- Finds public TikTok videos that mention requested profile handles.
- Accepts TikTok handles, `@handles`, TikTok profile URLs, and pasted newline or comma-separated target lists.
- Saves one dataset item per matching TikTok video.
- Adds match evidence so you can see whether the target appeared as an explicit mention, caption text, or a TikTok search match.
- Extracts captions, video URLs, publish time when available, and visible engagement metrics.
- Extracts author details such as handle, display name, bio, avatar URL, verification status, and visible profile stats when TikTok exposes them.
- Extracts music metadata, video dimensions, duration, cover URLs, hashtags, mentions, media URLs, and raw source IDs.
- Stops at your per-profile and total result limits.
- Continues through temporary TikTok search issues without saving failure rows.

This Actor is focused on public profile mention discovery in TikTok video search. It does not scrape private accounts, followers, comments, transcripts, TikTok Shop data, general keyword search, or every video from a profile.

### 📦 Data you can export

Each output item represents one public TikTok video found for one requested profile mention. Core fields include:

- `targetHandle`, `targetProfileUrl`, and `targetInput`
- `matchedTarget`, `matchType`, and `matchEvidence`
- `videoId`, `videoUrl`, `caption`, and `createdAt`
- `playCount`, `likeCount`, `commentCount`, `shareCount`, and `saveCount`
- `author` with handle, display name, bio, avatar, verification, profile URL, and visible stats
- `music` with title, author, original-sound flag, duration, play URL, and cover URL
- `video` with width, height, duration, cover URLs, definition, and format
- `mentions`, `hashtags`, and `mediaUrls`
- `searchUrl`, `resultPosition`, `sourcePlatform`, `sourceSurface`, and `scrapedAt`
- `rawSourceIds` for joining or deduping downstream

Fields can be `null` or empty when TikTok does not expose that value for a public video. The dataset contains usable scraped video rows only; skipped, private, unavailable, or zero-result targets are reported in logs.

### 🚀 Common use cases

- Track TikTok videos that mention your brand account.
- Find user-generated content that references a creator, company, product, or campaign handle.
- Monitor competitor mentions on TikTok.
- Build a TikTok mention dataset for social listening or reporting.
- Collect public engagement metrics for videos that mention a specific profile.
- Export TikTok mention videos to a spreadsheet, dashboard, database, or AI workflow.
- Schedule repeat runs to watch new public mention search results over time.

### ▶️ How to run it

1. Add one or more TikTok handles or profile URLs in **TikTok profiles**.
2. Keep **Videos per profile** at `25` for a small first run.
3. Set **Total video limit** if you want a hard cap across all targets.
4. Start the Actor and open the dataset.
5. Export the results or connect them to your workflow with the Apify API, scheduler, webhooks, or integrations.

Accepted target examples:

```json
{
	"targets": [
		"tiktok",
		"@apifytech",
		"https://www.tiktok.com/@nike"
	],
	"resultsPerTarget": 25,
	"maxResults": 100
}
````

### 🛠️ Input

| Field | What to enter |
| ----- | ------------- |
| `targets` | TikTok handles, `@handles`, TikTok profile URLs, or pasted newline/comma-separated target lists. |
| `resultsPerTarget` | Maximum number of matching videos to save for each profile. Default is `25`. |
| `maxResults` | Maximum number of videos to save across the whole run. Default is `100`. |

Keep limits small for your first run. Raise them once the output shape matches your workflow.

### 🧾 Output example

```json
{
	"targetHandle": "tiktok",
	"targetProfileUrl": "https://www.tiktok.com/@tiktok",
	"matchedTarget": "@tiktok",
	"matchType": "explicit_mention",
	"matchEvidence": "@tiktok",
	"videoId": "7560331146467265847",
	"videoUrl": "https://www.tiktok.com/@ink.dot/video/7560331146467265847",
	"caption": "Public TikTok caption text...",
	"playCount": 1100000,
	"likeCount": 120000,
	"commentCount": 840,
	"shareCount": 2500,
	"saveCount": 9800,
	"author": {
		"handle": "ink.dot",
		"displayName": "Ink Dot",
		"verified": false,
		"profileUrl": "https://www.tiktok.com/@ink.dot"
	},
	"mentions": ["tiktok"],
	"hashtags": ["art", "fyp"],
	"sourcePlatform": "tiktok",
	"sourceSurface": "search_video",
	"scrapedAt": "2026-05-28T15:19:00.000Z"
}
```

The exact fields can vary by public TikTok result. Some videos expose music, media URLs, cover URLs, author stats, and dimensions; others expose less.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each TikTok mention video saved to the dataset. Targets that return no usable public videos are not saved as dataset rows.

The default first run is intentionally small. You can control spend with **Videos per profile** and **Total video limit** before running larger batches.

### ⚠️ Limits and caveats

- Only public TikTok videos can be collected.
- TikTok may return different search results by region, time, or source availability.
- The Actor finds videos through public TikTok video search for the requested handle; it is not a full historical archive of every mention.
- Private, deleted, unavailable, or temporarily blocked results are skipped.
- No TikTok login, cookies, or API key are required.
- The Actor does not scrape comments, replies, transcripts, follower lists, or private account data.

### ❓ FAQ

#### 🔐 Can I scrape TikTok mentions without a TikTok account?

Yes. This Actor works with public TikTok data and does not ask for a TikTok login, cookies, or a TikTok API key.

#### 🎯 What is the difference between a handle and a profile URL?

Both are accepted. You can enter `nike`, `@nike`, or `https://www.tiktok.com/@nike`; the Actor normalizes them to the same TikTok profile target.

#### 💬 Does this scrape comments that mention a profile?

No. The Actor finds public videos returned by TikTok video search for a profile mention. It does not collect video comments or replies.

#### 📅 Can I schedule TikTok mention monitoring?

Yes. You can schedule repeat runs on Apify and export each run through datasets, API calls, webhooks, or integrations. Results reflect what public TikTok search exposes at run time.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~tiktok-profile-mention-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [TikTok Video Downloader ↗](https://apify.com/maximedupre/tiktok-video-downloader) - Download media files from public TikTok video URLs.
- [TikTok Transcript Scraper ↗](https://apify.com/maximedupre/tiktok-transcript-scraper) - Extract public captions and transcripts from TikTok videos.
- [TikTok Keywords Discovery Tool ↗](https://apify.com/maximedupre/tiktok-keywords-discovery-tool) - Collect TikTok autocomplete keyword suggestions for content research.
- [Social Media Stats Checker ↗](https://apify.com/maximedupre/social-media-stats-checker) - Check public profile stats across TikTok and other social platforms.
- [Twitter Scraper ↗](https://apify.com/maximedupre/twitter-scraper) - Search public X/Twitter posts and trending topics.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targets` (type: `array`):

Enter TikTok handles, @handles, profile URLs, or pasted lists. The Actor finds public videos that mention these profiles.

## `resultsPerTarget` (type: `integer`):

Maximum number of matching public videos to save for each TikTok profile.

## `maxResults` (type: `integer`):

Maximum number of videos to save across the whole run. Use this to cap larger batches.

## Actor input object example

```json
{
  "targets": [
    "tiktok"
  ],
  "resultsPerTarget": 25,
  "maxResults": 100
}
```

# Actor output Schema

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

Open the dataset with public TikTok videos that mention the requested profile handles.

# 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 = {
    "targets": [
        "tiktok"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/tiktok-profile-mention-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 = { "targets": ["tiktok"] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/tiktok-profile-mention-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "targets": [
    "tiktok"
  ]
}' |
apify call maximedupre/tiktok-profile-mention-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/tiktok-profile-mention-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Profile Mention Scraper",
        "description": "Find public TikTok videos that mention profile handles. Export captions, engagement metrics, author details, music metadata, media URLs, match evidence, and source links.",
        "version": "0.1",
        "x-build-id": "8GjQ6ZDMbygY51rnZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~tiktok-profile-mention-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-tiktok-profile-mention-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~tiktok-profile-mention-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-tiktok-profile-mention-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~tiktok-profile-mention-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-tiktok-profile-mention-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "TikTok profiles",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "Enter TikTok handles, @handles, profile URLs, or pasted lists. The Actor finds public videos that mention these profiles.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsPerTarget": {
                        "title": "Videos per profile",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of matching public videos to save for each TikTok profile.",
                        "default": 25
                    },
                    "maxResults": {
                        "title": "Total video limit",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of videos to save across the whole run. Use this to cap larger batches.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
