# TikTok Search Scraper — Fast Video & Creator Data (`artistic_elevator/tiktok-search-scraper`) Actor

Search TikTok by keyword and get video data, creator profiles, stats, hashtags, music. 50 results in 8s, 10K in 2min. Deduplicated. No API key needed. Managed proxy included. Export JSON/CSV/Excel.

- **URL**: https://apify.com/artistic\_elevator/tiktok-search-scraper.md
- **Developed by:** [Naruto Lee](https://apify.com/artistic_elevator) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0015 / result (own proxy)

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/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 Search Scraper — Fast Bulk Export

**Scrape thousands of TikTok search results in minutes.** No proxy setup needed —
managed residential proxy routing is built in.

Enter a keyword like `street food` or `iPhone review`, set the target count, and
get structured video metadata, creator profiles, engagement stats, hashtags,
music info, and direct video URLs. Large jobs (10k–100k) are batched
automatically for maximum reliability.

### ⚡ Why This Scraper Is Different

| | This Actor | Typical TikTok scrapers |
| :--- | :--- | :--- |
| **Speed** | **60–100 results/sec** sustained | 1–10 results/sec |
| **Proxy** | **Included** — zero config | You buy and configure separately |
| **Scale** | Up to **100,000** videos per run | Often limited or unstable at scale |
| **Data fields** | **26 fields** per video | 5–10 basic fields |
| **Reliability** | Auto-retry, auto-batch, stream resume | Manual restarts on failure |
| **Proxy cost** | **Included in price** | $50–200+/month proxy subscription |

### Benchmark

Tested with 30 concurrent sessions on warm pool:

| Request | Time | Rate |
| :--- | :--- | :--- |
| 1,000 videos | ~15 sec | ~65 items/sec |
| 5,000 videos | ~60 sec | ~83 items/sec |
| 10,000 videos | ~2 min | ~90 items/sec |

Speed depends on TikTok API response, network conditions, and pool warmth.
First run may be slower while sessions warm up.

### What Data Do You Get?

Every result includes **26 structured fields** covering video, creator, engagement, and music data:

#### Video Metadata
| Field | Description |
| :--- | :--- |
| `id` | TikTok video ID |
| `video_id` | Internal video identifier |
| `url` | Permanent video page URL |
| `desc` | Video description / caption |
| `cover` | Video thumbnail URL |
| `play_url` | Direct video stream URL |
| `download_url` | Downloadable video URL |
| `duration` | Video duration in seconds |
| `create_time` | Publish timestamp (Unix) |
| `hashtags` | Array of hashtag strings |
| `keyword` | Search keyword that returned this result |

#### Creator Info
| Field | Description |
| :--- | :--- |
| `author` | Creator unique ID (handle) |
| `nickname` | Creator display name |
| `author_id` | Numeric user ID |
| `author_sec_uid` | Secure user ID (for API lookups) |
| `author_avatar` | Profile picture URL |
| `author_signature` | Creator bio text |
| `author_verified` | Whether the account is verified |

#### Engagement Stats
| Field | Description |
| :--- | :--- |
| `plays` | Play / view count |
| `likes` | Like count |
| `comments` | Comment count |
| `shares` | Share count |
| `collects` | Bookmark / save count |

#### Music Info
| Field | Description |
| :--- | :--- |
| `music_title` | Song / audio title |
| `music_author` | Music artist name |
| `music_id` | Music track ID |

### How To Use

1. Enter a TikTok search keyword (e.g. `street food`, `fitness tips`).
2. Set the target number of videos (up to 100,000).
3. Click **Start** — results stream into the dataset progressively.
4. Export as JSON, CSV, Excel, or connect via the Apify API.

#### Input Example

```json
{
  "keyword": "street food",
  "targetCount": 5000,
  "concurrency": 30
}
````

#### Output Example

```json
{
  "id": "7381234567890123456",
  "url": "https://www.tiktok.com/@foodlover/video/7381234567890123456",
  "desc": "Best street food in Bangkok 🍜 #streetfood #thailand",
  "author": "foodlover",
  "nickname": "Food Lover",
  "author_id": "6912345678901234567",
  "author_sec_uid": "MS4wLjABAAAA...",
  "author_avatar": "https://p16-sign-sg.tiktokcdn.com/...",
  "author_signature": "Food blogger | 500K followers",
  "author_verified": false,
  "plays": 2450000,
  "likes": 185000,
  "comments": 3200,
  "shares": 12500,
  "collects": 45000,
  "cover": "https://p16-sign-sg.tiktokcdn.com/...",
  "play_url": "https://v16-webapp.tiktok.com/...",
  "download_url": "https://v16-webapp.tiktok.com/...",
  "duration": 35,
  "create_time": 1716700800,
  "hashtags": ["streetfood", "thailand", "bangkok"],
  "music_title": "original sound",
  "music_author": "Food Lover",
  "music_id": "7381234567890100000",
  "keyword": "street food"
}
```

### Pricing

| Plan | Price | What's included |
| :--- | :--- | :--- |
| **With built-in proxy** | **$3.00 / 1,000 results** | Scraping + managed residential proxy + auto-batching |
| **Bring your own proxy** | **$1.50 / 1,000 results** | Scraping + auto-batching (you provide proxy) |

No hidden costs. No separate proxy subscription needed when using built-in
proxy. Apify platform compute is billed separately at standard rates.

You are only charged for results actually saved. If the run hits your spending
limit, it stops early — no wasted bandwidth.

### How It Works Under the Hood

| Feature | Benefit |
| :--- | :--- |
| Warm-pool browser sessions | Reuses pre-established TikTok tabs — no cold-start delay |
| Signed API requests | Every request goes through real browser context with valid signatures |
| Per-tab proxy isolation | Each session routes through a unique residential IP |
| Fingerprint isolation | Independent browser fingerprints per session |
| Stream processing | Results save progressively — nothing lost on interruption |
| Auto batching | Large jobs split into reliable chunks with retry logic |
| Resource blocking | Skips images, video, fonts, CSS — lean and fast |

### Use Cases

- **Market research** — discover trending content by keyword
- **Influencer discovery** — find creators in any niche with full profile data
- **Brand monitoring** — track competitor and brand mentions at scale
- **Content analysis** — analyze engagement patterns across thousands of videos
- **Academic research** — structured social media data for studies
- **Lead generation** — identify creators for outreach with contact info
- **Hashtag tracking** — monitor hashtag performance over time
- **Music trend analysis** — discover trending sounds and audio

### FAQ

**Q: How fast is it really?**
A: Sustained throughput is 60–100 results/sec with warm sessions. First run may
start at 30–50/sec while the pool warms up. 10,000 results typically complete
in under 2 minutes.

**Q: Can I scrape 50,000+ videos?**
A: Yes. The Actor splits large requests into batches automatically. Results save
progressively — if interrupted, you keep everything collected so far.

**Q: Do I need to buy a proxy?**
A: **No.** Managed residential proxy routing is included in the $3/1000 price.
If you have your own proxy, use the $1.50/1000 tier.

**Q: Does it need TikTok accounts or login?**
A: No. It scrapes public search results only. No credentials needed.

**Q: What if TikTok blocks the scraper?**
A: The system automatically rotates residential IPs and retries failed requests.
Detection is handled transparently — you just get your data.

**Q: Can I get data about specific users or videos?**
A: Currently this Actor focuses on keyword search. User profile and video
collection scrapers are coming soon.

**Q: How fresh is the data?**
A: Data is fetched in real-time from TikTok's API. Every run returns the latest
search results — no cached or stale data.

# Actor input Schema

## `keyword` (type: `string`):

The keyword to search on TikTok, for example: iPhone review, street food, or fitness tips.

## `targetCount` (type: `integer`):

Target number of videos to collect. Large requests (10,000+) are automatically split into batches for reliability. The Actor stops when it reaches this number, runs out of usable results, hits runtime limits, or reaches your Apify spending limit.

## `webhookUrl` (type: `string`):

Optional URL to notify when the task completes. The Actor posts a JSON summary with total results and duration.

## `concurrency` (type: `integer`):

Internal warm-pool parallelism. Higher values are faster but use more proxy bandwidth.

## `preset` (type: `string`):

Task type — tt\_search is pre-selected for TikTok scraping

## Actor input object example

```json
{
  "keyword": "iPhone",
  "targetCount": 500,
  "webhookUrl": "",
  "concurrency": 30,
  "preset": "tt_search"
}
```

# 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 = {
    "keyword": "iPhone"
};

// Run the Actor and wait for it to finish
const run = await client.actor("artistic_elevator/tiktok-search-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 = { "keyword": "iPhone" }

# Run the Actor and wait for it to finish
run = client.actor("artistic_elevator/tiktok-search-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 '{
  "keyword": "iPhone"
}' |
apify call artistic_elevator/tiktok-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Search Scraper — Fast Video & Creator Data",
        "description": "Search TikTok by keyword and get video data, creator profiles, stats, hashtags, music. 50 results in 8s, 10K in 2min. Deduplicated. No API key needed. Managed proxy included. Export JSON/CSV/Excel.",
        "version": "0.7",
        "x-build-id": "7KKfiQiTr1fpidlsv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/artistic_elevator~tiktok-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-artistic_elevator-tiktok-search-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/artistic_elevator~tiktok-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-artistic_elevator-tiktok-search-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/artistic_elevator~tiktok-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-artistic_elevator-tiktok-search-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": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "The keyword to search on TikTok, for example: iPhone review, street food, or fitness tips."
                    },
                    "targetCount": {
                        "title": "How Many Videos",
                        "minimum": 10,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Target number of videos to collect. Large requests (10,000+) are automatically split into batches for reliability. The Actor stops when it reaches this number, runs out of usable results, hits runtime limits, or reaches your Apify spending limit.",
                        "default": 500
                    },
                    "webhookUrl": {
                        "title": "Webhook Notification URL",
                        "type": "string",
                        "description": "Optional URL to notify when the task completes. The Actor posts a JSON summary with total results and duration.",
                        "default": ""
                    },
                    "concurrency": {
                        "title": "Parallel Sessions",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Internal warm-pool parallelism. Higher values are faster but use more proxy bandwidth.",
                        "default": 30
                    },
                    "preset": {
                        "title": "Task Type",
                        "type": "string",
                        "description": "Task type — tt_search is pre-selected for TikTok scraping",
                        "default": "tt_search"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```