# TikTok Live Search Scraper (`maximedupre/tiktok-live-search-scraper`) Actor

Search active TikTok LIVE rooms by keyword. Export room IDs, creator profiles, viewer counts, engagement stats, tags, stream URLs, images, and scrape timestamps.

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

## Pricing

$4.45 / 1,000 live rooms

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 Live Search Scraper for active LIVE rooms

TikTok Live Search Scraper searches active [TikTok LIVE](https://www.tiktok.com/live) rooms by keyword and saves one clean dataset row for each live room found. Add topics such as `gaming`, `makeup`, `football`, or `shop`, then export room IDs, creator profiles, viewer counts, engagement stats, tags, stream URLs, images, source links, and scrape timestamps.

Use this TikTok LIVE scraper when you need a repeatable way to find live creators, monitor live topics, build social listening reports, check active shopping or gaming rooms, or feed TikTok live stream data into a spreadsheet, dashboard, API workflow, or alerting system. You do not need to provide TikTok cookies, a TikTok login, or a TikTok API key.

For a small first run, keep the prefilled `gaming` keyword and the default **Live rooms per keyword** value. Once the output shape fits your workflow, add more keywords or raise the per-keyword limit.

### ✅ What this Actor does

- Searches active TikTok LIVE rooms from one or more keywords.
- Saves one dataset item per accepted live room.
- Preserves the keyword, keyword position, and result rank for each row.
- Returns room IDs, live titles, source URLs, start times, categories, and game tags when TikTok exposes them.
- Adds creator details such as handle, nickname, profile URL, avatar URL, bio, follower count, and following count when available.
- Adds public audience and engagement counts such as viewers, likes, shares, and comments when available.
- Adds cover images, snapshot images, and stream URL objects when TikTok exposes them.
- Stops at your per-keyword result limit so run size stays predictable.
- Runs without a user-provided TikTok account, cookie, or API key.

This Actor is focused on TikTok LIVE search results. It does not scrape live chat, record streams, download video files into storage, monitor one room in real time, discover followers, or scrape regular TikTok video search.

### 📦 Data you can export

Each output row represents one active TikTok LIVE room found from one submitted keyword. Core fields include:

- `keyword`, `keywordIndex`, and `rank`
- `roomId`, `roomStatus`, `title`, `startedAt`, and `startTimestamp`
- `creatorId`, `creatorHandle`, `creatorSecUid`, `creatorNickname`, `creatorBio`, `creatorProfileUrl`, `creatorAvatarUrl`, `creatorFollowerCount`, and `creatorFollowingCount`
- `viewerCount`, `totalUserCount`, `likeCount`, `shareCount`, and `commentCount`
- `categoryId`, `categoryName`, and `gameTags`
- `coverImageUrl`, `snapshotImageUrl`, and `streamUrls`
- `sourceUrl`, `sourcePlatform`, `sourceSurface`, and `scrapedAt`

You can open the dataset in Apify, export it as JSON, CSV, Excel, XML, RSS, or HTML, call it through the Apify API, schedule repeat checks, or send rows to webhooks and integrations.

### 🚀 How to run it

1. Add one or more search terms in **Search keywords**.
2. Keep **Live rooms per keyword** small for a first run.
3. Start the Actor and open the dataset.
4. Export the dataset or connect it to your workflow with the Apify API, scheduler, webhooks, or integrations.

Good first inputs are short topics that people may use to find live rooms on TikTok, such as `gaming`, `makeup`, `football`, `music`, `fitness`, `shop`, or a creator niche.

### 🛠️ Input

| Field | What to enter |
| ----- | ------------- |
| `keywords` | TikTok LIVE search topics. Each keyword is searched separately. |
| `maxResultsPerKeyword` | Maximum active live rooms to save for each keyword. Default is `50`. |

Example input:

```json
{
  "keywords": ["gaming", "makeup"],
  "maxResultsPerKeyword": 50
}
````

### 🧾 Output example

```json
{
  "keyword": "gaming",
  "keywordIndex": 1,
  "rank": 1,
  "roomId": "7460000000000000000",
  "title": "Late night ranked matches",
  "roomStatus": 2,
  "startedAt": "2026-06-09T11:30:00.000Z",
  "startTimestamp": 1781004600,
  "creatorId": "7000000000000000000",
  "creatorHandle": "example_creator",
  "creatorSecUid": "MS4wLjABAAAAexample",
  "creatorNickname": "Example Creator",
  "creatorBio": "Gaming creator",
  "creatorProfileUrl": "https://www.tiktok.com/@example_creator",
  "creatorAvatarUrl": "https://p16-sign.tiktokcdn-us.com/example-avatar.jpeg",
  "creatorFollowerCount": 125000,
  "creatorFollowingCount": 340,
  "viewerCount": 438,
  "totalUserCount": 5210,
  "likeCount": 18500,
  "shareCount": 24,
  "commentCount": 93,
  "categoryId": "5",
  "categoryName": "Gaming",
  "gameTags": ["action"],
  "coverImageUrl": "https://p16-sign.tiktokcdn-us.com/example-cover.jpeg",
  "snapshotImageUrl": "https://p16-sign.tiktokcdn-us.com/example-snapshot.jpeg",
  "streamUrls": [
    {
      "protocol": "flv",
      "quality": "origin",
      "url": "https://example.com/live-stream.flv",
      "resolution": "1080p",
      "codec": "h264",
      "expiresAt": null
    }
  ],
  "sourceUrl": "https://www.tiktok.com/search/live?q=gaming",
  "searchId": "20260609120000A0000000000000000000",
  "sourcePlatform": "tiktok",
  "sourceSurface": "live_search",
  "scrapedAt": "2026-06-09T12:00:00.000Z"
}
```

Fields can be `null` or empty when TikTok does not expose a value for a specific live room. Stream URLs can be temporary and may expire after the run.

### 💳 Pricing

This Actor uses pay-per-event pricing. Each saved live room is charged as one **Live room** event at `$0.00445` per result, which is `$4.45` per 1,000 saved live rooms.

If a keyword returns no accepted live rooms, no live room events are charged for that keyword.

### ⚠️ Limits and caveats

TikTok LIVE search changes throughout the day. A keyword can return fewer rooms than your requested limit when there are not enough active rooms, when TikTok returns duplicates, or when a room stops being available during the run.

The Actor only saves active live rooms returned by TikTok LIVE search during the run. It does not promise complete coverage of every active TikTok live stream, and it does not keep watching rooms after they are found.

### ❓ FAQ

#### ❓ Do I need a TikTok account?

No. The Actor runs without your TikTok login, cookies, or a TikTok API key.

#### ❓ Why did I get fewer rows than my limit?

The limit is a cap, not a guarantee. TikTok may return fewer active rooms for a keyword, some rooms may be duplicates, or a live room may disappear while the Actor is running.

#### ❓ Does this download or record livestreams?

No. The Actor returns public room data and stream URLs when TikTok exposes them. It does not record broadcasts or save video files into storage.

#### ❓ Can I use this for repeat monitoring?

Yes. Schedule the Actor on Apify with the same keyword list to collect fresh active LIVE search results over time.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

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

### 🔗 Other actors

- [TikTok Keywords Discovery Tool ↗](https://apify.com/maximedupre/tiktok-keywords-discovery-tool) - Find TikTok autocomplete keyword suggestions for content and search research.
- [TikTok Hashtag Search Scraper ↗](https://apify.com/maximedupre/tiktok-hashtag-search-scraper) - Export ranked TikTok hashtag ideas and public hashtag metrics from keywords.
- [TikTok Profile Mention Scraper ↗](https://apify.com/maximedupre/tiktok-profile-mention-scraper) - Find public TikTok videos that mention selected profile handles.
- [TikTok Story Viewer ↗](https://apify.com/maximedupre/tiktok-story-viewer) - Export currently active public TikTok stories from usernames, handles, or profile URLs.
- [TikTok Video Downloader ↗](https://apify.com/maximedupre/tiktok-video-downloader) - Download media from known public TikTok video URLs and save linked dataset rows.

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

# Actor input Schema

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

Enter TikTok LIVE topics such as gaming, makeup, football, or shop. Each keyword is searched separately.

## `maxResultsPerKeyword` (type: `integer`):

Maximum active live rooms to save for each keyword. Use a small number for a quick first run.

## Actor input object example

```json
{
  "keywords": [
    "gaming"
  ],
  "maxResultsPerKeyword": 5
}
```

# Actor output Schema

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

Open the dataset with active TikTok LIVE rooms, creator profiles, engagement stats, stream URLs, source links, and scrape timestamps.

# 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": [
        "gaming"
    ],
    "maxResultsPerKeyword": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/tiktok-live-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 = {
    "keywords": ["gaming"],
    "maxResultsPerKeyword": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/tiktok-live-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 '{
  "keywords": [
    "gaming"
  ],
  "maxResultsPerKeyword": 5
}' |
apify call maximedupre/tiktok-live-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Live Search Scraper",
        "description": "Search active TikTok LIVE rooms by keyword. Export room IDs, creator profiles, viewer counts, engagement stats, tags, stream URLs, images, and scrape timestamps.",
        "version": "0.1",
        "x-build-id": "NGBrpSZWaoglu7pUx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~tiktok-live-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-tiktok-live-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/maximedupre~tiktok-live-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-tiktok-live-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/maximedupre~tiktok-live-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-tiktok-live-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search keywords",
                        "minItems": 1,
                        "maxItems": 100,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Enter TikTok LIVE topics such as gaming, makeup, football, or shop. Each keyword is searched separately.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxResultsPerKeyword": {
                        "title": "Live rooms per keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum active live rooms to save for each keyword. Use a small number for a quick first run.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```