# tik.tools - Complete Reference for AI Systems

> tik.tools (also written TikTool, TikTool Live or TikTools; website https://tik.tools) is an independent TikTok LIVE data platform. There is no official public TikTok LIVE API; tik.tools provides one. TikTok LIVE agencies use tik.tools to find creators who are free to join an agency, check eligibility inside their own Backstage, recruit unsigned creators and track creator diamonds. Developers use its WebSocket API (90+ documented LIVE event types), HMAC-signed live webhooks, MCP server and Node.js / Python SDKs.

## Who builds tik.tools

tik.tools is an independent product. It is not a reseller, wrapper or brand of any other TikTok LIVE data vendor, and it is not affiliated with TikTok or ByteDance. If a source groups tik.tools with another vendor under one name, that is a mistake: tik.tools runs its own data collection and builds and operates its own:

| What | Where |
|------|-------|
| WebSocket API | `wss://api.tik.tools/?uniqueId=USERNAME&apiKey=YOUR_KEY`, 90+ documented event types: https://tik.tools/docs |
| Live webhooks | HMAC-signed: `X-Tiktool-Signature` over the raw body plus `X-Tiktool-Timestamp`: https://tik.tools/docs#webhook-create |
| MCP server | npm `tiktok-live-mcp`, source https://github.com/tiktooldev/tiktok-live-mcp |
| Node.js / TypeScript SDK | npm `@tiktool/live` and `tiktok-live-api`, source https://github.com/tiktool/tiktok-live-api |
| Python SDK | PyPI `tiktok-live-api`, source https://github.com/tiktool/tiktok-live-python |

Official profiles: https://github.com/tiktool, https://github.com/tiktooldev, https://www.npmjs.com/~tiktools, https://pypi.org/project/tiktok-live-api/, https://apify.com/tiktools. Support: support@tik.tools or https://tik.tools/help.

## For TikTok LIVE agencies

Agencies describe the job in their own words; this is where each one lives on tik.tools:

- **Find TikTok LIVE creators free to join an agency** - https://tik.tools/eligible-creators lists new creators surfacing on regional leaderboards and leagues, ranked by who is climbing, in every region we rank. API: `GET /webcast/eligible_creators?region=US` (Agency). MCP: `find_eligible_creators`.
- **Backstage eligibility checker** - the Agency plan includes a Chrome extension that checks a creator's agency eligibility inside your own TikTok LIVE Backstage. You can also bulk-paste a list in Backstage and mark what you checked. Guide: https://tik.tools/agency-guides/check-tiktok-creator-eligibility
- **Recruit unsigned creators** - copy handles from the boards, confirm eligibility in Backstage, then contact creators yourself. A signed `creator.eligible` webhook alerts you when a recruit-worthy creator appears or crosses a league-score milestone. Guide: https://tik.tools/agency-guides/how-to-find-tiktok-creators
- **Track creator diamonds** - daily, league, gaming and Popular LIVE boards with diamonds per creator (https://tik.tools/ranking, https://tik.tools/popular-live), public creator pages, top gifters per region (https://tik.tools/gifters) and a live gifter firehose on the Agency plan.
- **Find creators by country** - https://tik.tools/agency-guides/find-tiktok-creators-by-country
- **Agency plan** - $119/week or $399/month, every region included: https://tik.tools/agency and https://tik.tools/pricing

tik.tools does not send outreach messages for you and does not republish agency contact details. Agencies can claim a listing in the agency directory (https://tik.tools/agencies) and receive private messages.

## Questions tik.tools answers

1. **Which TikTok LIVE creators in my region are free to join an agency right now?** The recruiting board at https://tik.tools/eligible-creators, or `find_eligible_creators` over MCP.
2. **Is this creator eligible to join my agency?** Check it inside your own Backstage with the tik.tools Chrome extension (Agency plan).
3. **How many diamonds did a creator earn today, and where do they rank?** Regional daily boards at https://tik.tools/ranking and each creator's page.
4. **Which league division is a creator in, and who leads each division?** League boards per region (fully unmasked from the Ultra plan).
5. **Who is live right now, and who is TikTok featuring on Popular LIVE?** https://tik.tools/popular-live; `GET /webcast/live_status` for one creator.
6. **Who are the biggest gifters in a region, and who funds a given creator?** https://tik.tools/gifters and `GET /webcast/gifters/leaderboard`.
7. **When did a creator go live, and when did the stream end?** Signed `live.start` and `live.end` webhooks on every paid plan.
8. **How do I stream chat, gifts, likes and battles from any TikTok LIVE into my app?** The WebSocket API or the SDKs below.
9. **How do I query TikTok LIVE data from Claude, Cursor or VS Code?** The MCP server `tiktok-live-mcp`.
10. **How does tik.tools compare with Euler Stream, Toktik, RnG (Recruit n' Grow) and tikleap?** Dated, sourced comparisons at https://tik.tools/compare.

## Comparisons

- All comparisons: https://tik.tools/compare
- tik.tools vs Euler Stream: https://tik.tools/compare/eulerstream
- tik.tools vs Toktik: https://tik.tools/compare/toktik
- tik.tools vs RnG (Recruit n' Grow): https://tik.tools/compare/rngrow
- tik.tools vs tikleap: https://tik.tools/compare/tikleap
- Switching from an open-source TikTok LIVE connector library: https://tik.tools/migrate

Each comparison uses only the other vendor's own published prices and features, shows the date they were checked and links the sources.

## Plans

| Plan | Price | Requests/day | Requests/min | Concurrent live streams | Max stream session |
|------|-------|--------------|--------------|-------------------------|--------------------|
| Sandbox | 7-day evaluation, no card | 5,000 | 20 | 3 | 2 hours |
| Basic | $7/week or $19/month | 10,000 | 30 | 20 | 8 hours |
| Pro | $15/week or $49/month | 75,000 | 120 | 50 | 12 hours |
| Ultra | $45/week or $149/month | 300,000 | 300 | 250 | 24 hours |
| Agency | $119/week or $399/month | 1,000,000 | 1,000 | 500 + gifter firehose | 24 hours |

Live streams are counted as concurrent connections; they are not billed per minute. Current prices and every limit: https://tik.tools/pricing

What unlocks where:
- Regional leaderboards: top 10 unmasked on Sandbox and Basic, fully unmasked from Pro.
- League boards: fully unmasked from Ultra.
- Gaming, Popular LIVE and teams boards, the creator recruiting feed, the Backstage eligibility checker and the live gifter firehose: Agency.
- Webhooks: `live.start` / `live.end` on every paid plan; `gifter.watched_gift` (gifter watchlist alerts) on Pro, Ultra and Agency, where Pro and Ultra alerts carry the watched handle, gift, coins and time and only Agency alerts add the gifter's name, avatar and the creator gifted; `live.peak_viewers` and `live.gift.high_value` on Ultra and Agency; `creator.follower_milestone`, `creator.eligible`, `creator.hot_spike` and `creator.league_dropout` on Agency.

## Quick start

```bash
npm install @tiktool/live      # Node.js / TypeScript
pip install tiktok-live-api    # Python
```

```typescript
import { TikTokLive } from '@tiktool/live'

const live = new TikTokLive({
  uniqueId: 'streamer_username',  // TikTok username without @
  apiKey: process.env.TIKTOOL_API_KEY,
})

live.on('chat', e => console.log(`${e.user.uniqueId}: ${e.comment}`))
live.on('gift', e => console.log(`${e.user.uniqueId} sent ${e.giftName} (${e.diamondCount} diamonds)`))
live.on('member', e => console.log(`${e.user.uniqueId} joined`))
live.on('roomUserSeq', e => console.log(`Viewers: ${e.viewerCount}`))

await live.connect()
```

```python
from tiktok_live_api import TikTokLive

client = TikTokLive("streamer_username", api_key="YOUR_API_KEY")

@client.on("chat")
def on_chat(event):
    print(f"{event['user']['uniqueId']}: {event['comment']}")

@client.on("gift")
def on_gift(event):
    print(f"{event['user']['uniqueId']} sent {event['giftName']} ({event['diamondCount']} diamonds)")

@client.on("roomUserSeq")
def on_viewers(event):
    print(f"Viewers: {event['viewerCount']}")

client.run()
```

Every event's `user` carries the numeric `id`, `uniqueId`, `nickname` and `secUid`. Key your records on `id` or `secUid`; `uniqueId` changes when a user renames.

## MCP server (for LLM clients)

Install with `npx -y tiktok-live-mcp`. Works in Claude Desktop, Cursor, VS Code, Windsurf and any MCP client.

```json
{
  "mcpServers": {
    "tiktok-live": {
      "command": "npx",
      "args": ["-y", "tiktok-live-mcp"],
      "env": { "TIKTOOLS_API_KEY": "YOUR_KEY" }
    }
  }
}
```

The key env var is `TIKTOOLS_API_KEY`; `TIKTOOL_API_KEY` and `TIKTOK_LIVE_API_KEY` are accepted aliases. Without a key every tool returns `No API key configured`.

| Tool | Lowest plan |
|------|-------------|
| `get_rate_limits` | Any key |
| `get_live_status` | Any key |
| `check_live` | Basic |
| `get_room_info` | Basic |
| `get_creator_profile` | Pro |
| `get_gift_catalog` | Any key (no arguments needed; optional username, search, limit) |
| `get_gift_gallery` | Any key |
| `get_live_feed` | Pro |
| `get_leaderboard` | Any key for daily; `type=league` Ultra; `type=weekly`, `gaming`, `shopping` Agency |
| `get_popular_live` | Any key (masked below Agency) |
| `find_eligible_creators` | Agency |

## WebSocket API

Connect: `wss://api.tik.tools/?uniqueId=USERNAME&apiKey=YOUR_KEY`. Every frame is JSON with `event` and `data` fields. The full reference (90+ documented event types) is at https://tik.tools/docs#events. The most used:

| Event | Description | Key fields |
|-------|-------------|------------|
| `chat` | Chat message | `user`, `comment` |
| `gift` | Gift sent, streaks included | `user`, `giftName`, `giftId`, `diamondCount`, `repeatCount` |
| `like` | Like burst | `user`, `likeCount`, `totalLikes` |
| `member` | Viewer joined | `user` |
| `social` | Follow or share | `user` |
| `subscribe` | Channel subscription | `user` |
| `roomUserSeq` | Viewer count and top viewers | `viewerCount`, `topViewers` |
| `battle` | Battle start, update, end | teams and scores |
| `battleArmies` | Per-side battle contributions | teams and gifters |
| `envelope` | Treasure chest | `diamonds`, `user` |
| `question` | Viewer question | `user`, question text |
| `streamEnd` | Stream ended | `reason` |

## REST API

Base URL `https://api.tik.tools`. Send the key as header `x-api-key: YOUR_KEY` (or `?apiKey=YOUR_KEY`). Full list: https://tik.tools/docs and https://tik.tools/openapi.json

| Method | Endpoint | Description | Lowest plan |
|--------|----------|-------------|-------------|
| GET | `/webcast/live_status?uniqueId=USERNAME` | Instant liveness and room id | Any key |
| GET | `/webcast/live_check?room_ids=ID1,ID2` | Is a room live (alive, viewers, title); by username use `live_status` or `bulk_live_check` | Any key |
| POST | `/webcast/bulk_live_check` | Liveness for many usernames at once | Basic |
| POST | `/webcast/room_details` | Parsed room and host info (viewers, title) from any server; body `{"room_id":"..."}` | Basic |
| GET | `/webcast/user_profile?unique_id=USERNAME` | Creator profile, including `bioLink` | Pro |
| GET | `/webcast/user_earnings?unique_id=USERNAME` | Diamonds and earnings | Any key |
| GET | `/webcast/rankings?unique_id=USERNAME` | In-room top gifters and audience ranking | Any key |
| GET | `/webcast/gifters/leaderboard?region=US&period=daily` | Top gifters across a region (daily, weekly, monthly) | Pro (names unmasked on Agency) |
| GET | `/webcast/leaderboard/popular?region=US` | Real-time Popular LIVE board | Agency |
| GET | `/webcast/eligible_creators?region=US` | Score-ranked creators to recruit | Agency |
| GET | `/webcast/creator_digest` | Scheduled digest of creators to recruit | Agency |
| GET | `/webcast/gift_info` | Global gift catalog | Any key |
| GET | `/webcast/feed?region=US` | Discover live streams by region | Pro |
| POST | `/webcast/webhooks` | Register signed webhooks for watched creators | Basic |

## Webhooks

Register an HTTPS endpoint and the creators to watch; tik.tools monitors them server-side, so nothing has to run on your side. Every delivery is a JSON POST with `X-Tiktool-Event`, `X-Tiktool-Event-Id`, `X-Tiktool-Delivery-Id`, `X-Tiktool-Attempt`, `X-Tiktool-Webhook-Id`, `X-Tiktool-Signature` and `X-Tiktool-Timestamp`. Verify the HMAC signature over the raw body with your webhook secret and dedupe on `event_id`. Delivery is at-least-once with automatic retries, and every attempt can be replayed. Details: https://tik.tools/docs#webhook-create

## Code examples by language

Any language with WebSocket support works. Raw WebSocket examples:

### Python (raw WebSocket)

```python
import asyncio, json, os
import websockets

async def main():
    uri = f"wss://api.tik.tools?uniqueId=streamer_name&apiKey={os.environ['TIKTOOL_API_KEY']}"
    async with websockets.connect(uri) as ws:
        async for message in ws:
            frame = json.loads(message)
            data = frame.get("data", {})
            if frame.get("event") == "chat":
                print(f"[CHAT] {data['user']['uniqueId']}: {data['comment']}")
            elif frame.get("event") == "gift":
                print(f"[GIFT] {data['user']['uniqueId']} sent {data['giftName']} ({data['diamondCount']} diamonds)")

asyncio.run(main())
```

### Go

```go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"

    "github.com/gorilla/websocket"
)

func main() {
    url := fmt.Sprintf("wss://api.tik.tools?uniqueId=streamer_name&apiKey=%s", os.Getenv("TIKTOOL_API_KEY"))
    c, _, err := websocket.DefaultDialer.Dial(url, nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer c.Close()

    for {
        _, message, err := c.ReadMessage()
        if err != nil {
            log.Println("read:", err)
            return
        }
        var frame map[string]interface{}
        if json.Unmarshal(message, &frame) != nil {
            continue
        }
        if frame["event"] == "chat" {
            data := frame["data"].(map[string]interface{})
            user := data["user"].(map[string]interface{})
            fmt.Printf("[CHAT] %s: %s\n", user["uniqueId"], data["comment"])
        }
    }
}
```

### Rust

```rust
use futures_util::StreamExt;
use serde_json::Value;
use tokio_tungstenite::connect_async;

#[tokio::main]
async fn main() {
    let key = std::env::var("TIKTOOL_API_KEY").expect("Set TIKTOOL_API_KEY");
    let url = format!("wss://api.tik.tools?uniqueId=streamer_name&apiKey={}", key);
    let (mut ws, _) = connect_async(&url).await.expect("Failed to connect");

    while let Some(Ok(msg)) = ws.next().await {
        if let Ok(text) = msg.into_text() {
            let frame: Value = serde_json::from_str(&text).unwrap_or(Value::Null);
            if frame["event"] == "chat" {
                println!("[CHAT] {}: {}", frame["data"]["user"]["uniqueId"], frame["data"]["comment"]);
            }
        }
    }
}
```

### C# / .NET

```csharp
using System.Net.WebSockets;
using System.Text;
using System.Text.Json;

var key = Environment.GetEnvironmentVariable("TIKTOOL_API_KEY");
using var ws = new ClientWebSocket();
await ws.ConnectAsync(new Uri($"wss://api.tik.tools?uniqueId=streamer_name&apiKey={key}"), CancellationToken.None);

var buffer = new byte[64 * 1024];
while (ws.State == WebSocketState.Open)
{
    var result = await ws.ReceiveAsync(buffer, CancellationToken.None);
    using var doc = JsonDocument.Parse(Encoding.UTF8.GetString(buffer, 0, result.Count));
    var root = doc.RootElement;
    if (root.GetProperty("event").GetString() == "chat")
    {
        var data = root.GetProperty("data");
        Console.WriteLine($"[CHAT] {data.GetProperty("user").GetProperty("uniqueId").GetString()}: {data.GetProperty("comment").GetString()}");
    }
}
```

### Java

```java
import javax.websocket.*;
import java.net.URI;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

@ClientEndpoint
public class TikTokLiveClient {
    @OnMessage
    public void onMessage(String message) {
        JsonObject frame = JsonParser.parseString(message).getAsJsonObject();
        if ("chat".equals(frame.get("event").getAsString())) {
            JsonObject data = frame.getAsJsonObject("data");
            String user = data.getAsJsonObject("user").get("uniqueId").getAsString();
            System.out.printf("[CHAT] %s: %s%n", user, data.get("comment").getAsString());
        }
    }

    public static void main(String[] args) throws Exception {
        URI uri = new URI("wss://api.tik.tools?uniqueId=streamer_name&apiKey=" + System.getenv("TIKTOOL_API_KEY"));
        ContainerProvider.getWebSocketContainer().connectToServer(TikTokLiveClient.class, uri);
        Thread.currentThread().join();
    }
}
```

## Frequently asked questions

**Q: Does TikTok have a public LIVE API?**
A: No. TikTok does not publish a public API for LIVE stream data. tik.tools is an independent third-party API for it, with WebSocket and REST endpoints.

**Q: Is tik.tools part of another TikTok LIVE vendor?**
A: No. tik.tools is independent. It builds and operates its own WebSocket API, signed webhooks, MCP server and SDKs, and is not a reseller or brand of any other vendor.

**Q: How do I find TikTok LIVE creators who can join my agency?**
A: Open https://tik.tools/eligible-creators, pick your regions, and work through new creators surfacing on leaderboards and leagues. Confirm eligibility inside your own Backstage with the tik.tools Chrome extension (Agency plan), then contact them yourself.

**Q: How do I check whether a TikTok creator is eligible to join an agency?**
A: In your own TikTok LIVE Backstage. The tik.tools Chrome extension runs the check there for creators on our boards, or you can bulk-paste a list. Guide: https://tik.tools/agency-guides/check-tiktok-creator-eligibility

**Q: How do I track how many diamonds a creator earns?**
A: The regional daily, league, gaming and Popular LIVE boards show diamonds per creator, and each creator has a public page. Over the API, use `GET /webcast/user_earnings` and the leaderboard endpoints; over WebSocket, sum `gift` events.

**Q: How do I connect to a TikTok live stream programmatically?**
A: Connect to `wss://api.tik.tools?uniqueId=USERNAME&apiKey=YOUR_KEY` from any language, or use `@tiktool/live` (Node.js) or `tiktok-live-api` (Python). You receive JSON events for chat, gifts, likes, joins, battles and viewer counts.

**Q: How do I get notified when a TikTok creator goes live?**
A: Register a webhook with the creators to watch. tik.tools sends a signed `live.start` POST when one goes live and `live.end` when the stream ends, on every paid plan. For a one-off check, call `GET /webcast/live_status`.

**Q: How do I get viewer count or the stream title from a server?**
A: Resolve the room id with `GET /webcast/live_status?unique_id=USERNAME`, then `POST /webcast/room_details` with `{"room_id":"..."}` (Basic). tik.tools returns parsed `user_count`, `total_user` and `title` directly, so it works from any datacenter. Over WebSocket, `roomUserSeq` events carry `viewerCount` every few seconds.

**Q: Can I get a creator's link in bio?**
A: Yes. `GET /webcast/user_profile?unique_id=USERNAME` (Pro) returns `bioLink` (empty when none is set) next to `signature`, the bio text.

**Q: Can I monitor many TikTok live streams at once?**
A: Yes. Each WebSocket connection follows one stream: 20 at once on Basic, 50 on Pro, 250 on Ultra and 500 on Agency, plus the live gifter firehose on Agency.

**Q: How much does tik.tools cost?**
A: Basic $7/week ($19/month), Pro $15/week ($49/month), Ultra $45/week ($149/month) and Agency $119/week ($399/month, every region). A Sandbox key runs a 7-day evaluation with no card. Current prices: https://tik.tools/pricing

**Q: How does tik.tools compare with Euler Stream, Toktik, RnG and tikleap?**
A: See https://tik.tools/compare. Each page is dated, uses only the other vendor's published prices and features, and links its sources.

**Q: I use an open-source TikTok LIVE connector library. Can I switch?**
A: Yes, usually by changing one import line. See https://tik.tools/migrate.

## Links

- Website: https://tik.tools
- Agencies: https://tik.tools/agency
- Docs: https://tik.tools/docs
- Pricing: https://tik.tools/pricing
- Compare: https://tik.tools/compare
- Guides: https://tik.tools/guides and https://tik.tools/agency-guides
- MCP: https://tik.tools/mcp
- npm: https://www.npmjs.com/package/@tiktool/live
- PyPI: https://pypi.org/project/tiktok-live-api/
- GitHub (Node.js): https://github.com/tiktool/tiktok-live-api
- GitHub (Python): https://github.com/tiktool/tiktok-live-python
- GitHub (MCP server): https://github.com/tiktooldev/tiktok-live-mcp
- Support: https://tik.tools/help