# TikTok LIVE Status & Stream URLs (`automation-lab/tiktok-live-room-stream-urls`) Actor

Check supplied public TikTok creators for current LIVE room status, viewer counters, host metadata, and playback URLs without login or recording.

- **URL**: https://apify.com/automation-lab/tiktok-live-room-stream-urls.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## TikTok LIVE Status & Stream URLs

Check whether supplied public TikTok creators are currently LIVE and export room identity, title, viewer counters, host metadata, and public playback URLs.

This Actor is designed for recurring **TikTok LIVE status** monitoring. It checks only creators you provide; it does not discover streams, log in, download media, or record broadcasts.

### What does TikTok LIVE Status & Stream URLs do?

The Actor accepts public TikTok usernames, profile URLs, and LIVE URLs.

For each accepted creator it:

1. opens the creator's public LIVE page;
2. resolves the public room identifier exposed by TikTok;
3. checks the room's current status;
4. extracts room, host, and audience metadata;
5. returns signed playback variants only when the room is currently LIVE;
6. writes one typed record to the default dataset.

Offline or ended rooms can remain in the dataset, which makes scheduled runs easy to compare.

### Who is it for?

**Brand monitoring teams** can check whether watched creators are broadcasting now.

**Creator managers** can maintain a recurring roster of talent and compare state changes between scheduled runs.

**Live-event operators** can resolve current room IDs and public playback endpoints for authorized internal workflows.

**Data engineers** can send status rows to Sheets, databases, webhooks, or monitoring pipelines.

**Researchers** can capture point-in-time public audience and host metadata without recording video.

Use another product if you need keyword discovery, comments, gifts, chat messages, historical streams, or media recording.

### Why use this Actor?

- No TikTok login or cookies are required for the supported public route.
- Input is creator-specific rather than noisy keyword discovery.
- LIVE and non-LIVE creators use the same stable output shape.
- Signed FLV, HLS, and RTMP variants are grouped by quality and format.
- `includeOffline=false` supports active-room-only exports.
- The Actor uses lightweight direct HTTP rather than a browser or paid residential fallback.
- Strict validation rejects unrelated domains and malformed creator handles.
- The default dataset works with Apify integrations, schedules, API clients, and MCP.

### What TikTok LIVE data can I extract?

| Field | Meaning |
| --- | --- |
| `username` | Normalized creator handle supplied to the run |
| `sourceUrl` | Public TikTok LIVE page checked |
| `profileUrl` | Public creator profile URL |
| `roomId` | Room identifier exposed by TikTok, or `null` |
| `status` | `live`, `offline`, `ended`, or `unknown` |
| `isLive` | Convenient boolean for filters and alerts |
| `title` | Current or most recently exposed room title |
| `viewerCount` | Current viewer counter when available |
| `likeCount` | Room like counter when available |
| `startedAt` | Room creation timestamp when available |
| `hostId` | TikTok host identifier |
| `hostName` | Host display name |
| `hostUsername` | Host public handle |
| `hostAvatarUrl` | Public avatar URL when exposed |
| `hostVerified` | Host verification state when exposed |
| `streamUrls` | Signed FLV/HLS/RTMP variants for an active room |
| `scrapedAt` | UTC timestamp for this check |

A room can expose an old room ID and title after a broadcast ends. Always use `status` or `isLive` to determine current state.

### How to get started

1. Open the Actor input page in Apify Console.
2. Enter one or more handles in **TikTok usernames**.
3. Optionally add profile or LIVE URLs in **TikTok profile or LIVE URLs**.
4. Keep **Include creators who are not LIVE** enabled for monitoring snapshots.
5. Keep **Include public stream URLs** enabled if your workflow needs playback variants.
6. Set **Maximum creators** between 1 and 100.
7. Click **Start**.
8. Open the default dataset and select the **TikTok LIVE status** view.

A small first run with `weathernewslive` demonstrates the current LIVE output shape.

### Input parameters

#### `usernames`

An array of public creator handles.

Both `weathernewslive` and `@weathernewslive` are accepted.

Handles are deduplicated before requests are made.

#### `startUrls`

An array of public TikTok profile or LIVE URLs.

Supported examples:

- `https://www.tiktok.com/@weathernewslive`
- `https://www.tiktok.com/@weathernewslive/live`

Search, video, shortened, and non-TikTok URLs are rejected.

#### `includeOffline`

Defaults to `true`.

When enabled, the Actor emits one row for every checked creator, including ended or unavailable LIVE rooms.

When disabled, only rooms currently reported as LIVE are saved and charged as items.

#### `includeStreamUrls`

Defaults to `true`.

When enabled, active LIVE rows can contain signed playback variants.

When disabled, `streamUrls` is an empty array and the Actor still returns all other status metadata.

#### `maxItems`

Limits the number of unique supplied creators checked in one run.

The accepted range is 1–100 and the default is 25.

### Example input

```json
{
  "usernames": [
    "weathernewslive",
    "tiktok",
    "espn"
  ],
  "includeOffline": true,
  "includeStreamUrls": true,
  "maxItems": 3
}
```

You may combine `usernames` and `startUrls`. Duplicate creators still produce one row.

### Example output

The values below illustrate the real output shape; signed URLs are shortened because they expire.

```json
{
  "username": "weathernewslive",
  "sourceUrl": "https://www.tiktok.com/@weathernewslive/live",
  "profileUrl": "https://www.tiktok.com/@weathernewslive",
  "roomId": "7671689032328776469",
  "status": "live",
  "isLive": true,
  "title": "Weather News LIVE",
  "viewerCount": 1721,
  "likeCount": null,
  "startedAt": "2026-08-14T10:00:00.000Z",
  "hostId": "7000000000000000000",
  "hostName": "Weather News LIVE",
  "hostUsername": "weathernewslive",
  "hostAvatarUrl": "https://p16-sign.tiktokcdn.com/...",
  "hostVerified": true,
  "streamUrls": [
    {
      "format": "hls",
      "quality": "default",
      "url": "https://pull-f5.tiktokcdn.com/...m3u8"
    }
  ],
  "scrapedAt": "2026-08-14T20:10:00.000Z"
}
```

Counters and room state are point-in-time values. Null means TikTok did not expose that field for the checked room.

### How much does it cost to check TikTok LIVE creators?

Pricing uses one small `start` event per run plus one `item` event for every dataset row.

The item event has six volume tiers. The applicable tier is shown in Apify Console before a run starts.

At the initial **$0.004 start fee** and BRONZE item rate of **$0.00304 per saved creator**:

- 1 saved creator costs about **$0.00704** total;
- 10 saved creators cost about **$0.0344** total;
- 100 saved creators cost about **$0.308** total.

Creators skipped with `includeOffline=false` do not create or charge an item event.

Platform spending controls such as maximum total charge can cap a run. Always review the live Console pricing because future tier changes are shown there first.

### Monitor creator status with schedules

Create an Apify schedule for recurring checks.

A monitoring workflow can:

1. run every few minutes;
2. export every supplied creator, including offline creators;
3. compare `status`, `roomId`, and `viewerCount` with the prior dataset;
4. trigger a webhook only when `isLive` changes;
5. refresh expiring playback URLs with the newest successful run.

This Actor produces snapshots. It does not keep hidden state or send alerts by itself.

### Export to spreadsheets and data pipelines

Use the default dataset with:

- Google Sheets integration;
- webhook automation;
- Zapier or Make;
- REST API clients;
- JavaScript and Python SDKs;
- scheduled dataset exports;
- your own warehouse ingestion job.

Filter `isLive=true` downstream for active-room views.

Store `roomId` and `scrapedAt` together when comparing changes over time.

Do not treat a signed playback URL as a durable identifier; use `roomId` instead.

### Run with the Apify API

Replace `<APIFY_TOKEN>` with your token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~tiktok-live-room-stream-urls/runs?token=<APIFY_TOKEN>&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"usernames":["weathernewslive"],"includeOffline":true,"includeStreamUrls":true,"maxItems":1}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tiktok-live-room-stream-urls').call({
  usernames: ['weathernewslive', 'tiktok'],
  includeOffline: true,
  includeStreamUrls: true,
  maxItems: 2,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation-lab/tiktok-live-room-stream-urls").call(run_input={
    "usernames": ["weathernewslive", "tiktok"],
    "includeOffline": True,
    "includeStreamUrls": True,
    "maxItems": 2,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/tiktok-live-room-stream-urls"
```

#### Claude Desktop, Cursor, and VS Code setup

Use this equivalent JSON configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/tiktok-live-room-stream-urls"
    }
  }
}
```

#### Example prompts

After connecting the Apify MCP server, try:

- “Use the Apify MCP TikTok LIVE Status tool to check whether weathernewslive is currently LIVE.”
- “Use MCP to check this creator list and return only active TikTok LIVE rooms.”
- “Run the TikTok LIVE Actor through MCP and export current viewer counts and playback qualities to a table.”

MCP uses your Apify access and the same Actor input contract.

### Tips for reliable runs

- Supply canonical public handles rather than display names.
- Keep the initial batch small when validating a new watchlist.
- Enable offline rows for change detection.
- Refresh stream URLs immediately before an authorized playback workflow.
- Use schedules and downstream comparisons rather than assuming one snapshot is permanent.
- Inspect `status`, not merely the presence of `roomId`.
- Retry later if TikTok temporarily challenges or rate-limits public traffic.

The Actor intentionally avoids an automatic residential proxy fallback, so it cannot create surprise proxy transfer charges.

### Limitations and failure behavior

TikTok can change embedded page state and undocumented public room endpoints without notice.

A creator may have no room ID, an ended room, or a room that changes while the run is executing.

Viewer and like counters are source-reported point-in-time values and may lag the public UI.

Playback URLs are signed, can expire quickly, can be geo-restricted, and may require a compatible media client.

The Actor does not bypass login, CAPTCHA, private-account, age, geographic, or entitlement controls.

The Actor checks at most 100 unique creators per run.

Malformed input and unrecognized/challenge pages fail visibly rather than returning misleading empty success.

### Responsible use and legality

Use this Actor only for public data that you are authorized to access.

Follow TikTok's terms, applicable laws, contractual restrictions, and platform policies.

Do not use status or audience data for harassment, stalking, unlawful surveillance, discrimination, or attempts to bypass access controls.

Do not redistribute playback URLs as permanent media links. Respect creator rights and regional media restrictions.

You are responsible for retention, combination, and downstream use of exported data.

### Troubleshooting

#### Why did an offline creator return a room ID and title?

TikTok can leave metadata for the most recent ended room in public application state. Use `status` and `isLive` for current state.

#### Why is `streamUrls` empty?

The room may not be LIVE, `includeStreamUrls` may be disabled, or TikTok may not expose public playback variants for that room.

#### Why did my run fail on a public creator?

Confirm that the input is a public handle or canonical TikTok profile/LIVE URL. TikTok may also be returning a temporary challenge or changed page shape; inspect the run log and retry later.

#### Why does a saved stream URL no longer work?

Signed URLs expire. Run the Actor again and use the newest active-room row.

#### Can this Actor record TikTok LIVE video or chat?

No. It exports public status and playback metadata only. It does not download video, collect chat, or record a broadcast.

### Related Automation Lab Actors

- [TikTok Profile Scraper](https://apify.com/automation-lab/tiktok-profile-scraper) for public profile identity and audience metadata.
- [TikTok Creator Analytics Scraper](https://apify.com/automation-lab/tiktok-creator-analytics-scraper) for broader public creator statistics and recent engagement.
- [TikTok Video Records Scraper](https://apify.com/automation-lab/tiktok-video-records-scraper) for supplied public video metadata.

These products complement creator status checks. They do not replace this Actor's current LIVE room and playback URL output.

### FAQ

#### Does it require TikTok login or cookies?

No, the supported public creator route does not require user credentials.

#### Does it search TikTok for LIVE creators?

No. Supply the creators you already want to monitor.

#### Does one input always produce one dataset row?

Yes when `includeOffline=true`, subject to valid source responses. With `includeOffline=false`, non-LIVE creators are intentionally omitted.

#### Are offline rows charged?

Yes when they are saved as dataset items. Disable `includeOffline` if your workflow needs active-room rows only.

#### Can I schedule frequent checks?

Yes. Choose a responsible interval and compare `status`, `roomId`, and `scrapedAt` downstream.

#### Is the output real time?

It is a point-in-time check of TikTok's public room response during the run, not a continuous socket or guaranteed real-time feed.

# Actor input Schema

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

Public creator handles, with or without the @ prefix. You can combine these with profile URLs below.

## `startUrls` (type: `array`):

Public URLs such as https://www.tiktok.com/@weathernewslive/live. Other domains and unsupported TikTok pages are rejected.

## `includeOffline` (type: `boolean`):

When enabled, emit one status row for every supplied creator. Disable it to export active LIVE rooms only.

## `includeStreamUrls` (type: `boolean`):

Include currently exposed signed FLV, HLS, and RTMP playback variants for active LIVE rooms. URLs can expire and should be refreshed with a new run.

## `maxItems` (type: `integer`):

Maximum number of unique supplied creators to check in this run.

## Actor input object example

```json
{
  "usernames": [
    "weathernewslive",
    "tiktok",
    "espn"
  ],
  "startUrls": [
    {
      "url": "https://www.tiktok.com/@weathernewslive/live"
    }
  ],
  "includeOffline": true,
  "includeStreamUrls": true,
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Typed creator, room, status, audience, host, and stream URL records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "usernames": [
        "weathernewslive",
        "tiktok",
        "espn"
    ],
    "startUrls": [
        {
            "url": "https://www.tiktok.com/@weathernewslive/live"
        }
    ],
    "includeOffline": true,
    "includeStreamUrls": true,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tiktok-live-room-stream-urls").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "usernames": [
        "weathernewslive",
        "tiktok",
        "espn",
    ],
    "startUrls": [{ "url": "https://www.tiktok.com/@weathernewslive/live" }],
    "includeOffline": True,
    "includeStreamUrls": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tiktok-live-room-stream-urls").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "usernames": [
    "weathernewslive",
    "tiktok",
    "espn"
  ],
  "startUrls": [
    {
      "url": "https://www.tiktok.com/@weathernewslive/live"
    }
  ],
  "includeOffline": true,
  "includeStreamUrls": true,
  "maxItems": 20
}' |
apify call automation-lab/tiktok-live-room-stream-urls --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/tiktok-live-room-stream-urls"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hhmUUQUPKo2EGrxPL/builds/yq65NCwJTH2HuqUc8/openapi.json