How is TikTool different from other live stream libraries?

Open-source libraries require you to maintain your own connection infrastructure and frequently break when the platform updates. TikTool is a managed API service - we handle all maintenance, challenge solving, and authentication server-side. Your code stays stable.

What is the latency of the TikTok LIVE API?

TikTool delivers events within 50 milliseconds of them occurring on TikTok. The managed WebSocket connection is optimized for low-latency real-time data delivery.

Can I use TikTok LIVE API for a chat assistant?

Yes. TikTool's real-time chat events include full user info, message text, emotes, and badges. Many developers use it to build interactive chat assistants, moderation tools, and automated responses for TikTok LIVE streams.

Python Node.js WebSocket

TikTok LIVE API

There is no official TikTok LIVE API. TikTool is a managed alternative - connect to any live stream and receive real-time chat, gifts, viewers via WebSocket. Signature server, CAPTCHA solving, and Public Broadcast Telemetry rotation included. No reverse engineering needed.

Get API Key Docs Discord Bot

Live video player

// stream-url.mjs
// Run: node stream-url.mjs                  (all live streams)
//      node stream-url.mjs aljazeeraenglish (filter to one)
// Prints HLS + FLV URLs. No auth. Pipe to mpv / ffplay / vlc.
const WANT = (process.argv[2] || '').replace(/^@/, '');
const r = await fetch('https://api.tik.tools/api/live/top-channels').then(r => r.json());
const list = WANT ? r.channels.filter(c => c.uniqueId === WANT) : r.channels;
if (!list.length) { console.log(WANT ? 'Not in current ticker: ' + WANT : 'No live channels'); process.exit(0); }
for (const c of list) {
  console.log('@' + c.uniqueId, '(' + c.region + ')');
  if (c.streamUrls?.hls) console.log('  HLS:', c.streamUrls.hls);
  if (c.streamUrls?.flv) console.log('  FLV:', c.streamUrls.flv);
  if (!c.streamUrls) console.log('  (no stream URL available)');
}

# stream_url.py
# Run: python stream_url.py                  (all live streams)
#      python stream_url.py aljazeeraenglish (filter to one)
import json, sys, urllib.request
WANT = (sys.argv[1] if len(sys.argv) > 1 else '').lstrip('@')
r = json.loads(urllib.request.urlopen('https://api.tik.tools/api/live/top-channels').read())
items = [c for c in r['channels'] if not WANT or c['uniqueId'] == WANT]
if not items: print('Not in current ticker' if WANT else 'No live channels'); sys.exit(0)
for c in items:
    print(f"@{c['uniqueId']} ({c['region']})")
    su = c.get('streamUrls') or {}
    if su.get('hls'): print('  HLS:', su['hls'])
    if su.get('flv'): print('  FLV:', su['flv'])
    if not su: print('  (no stream URL available)')

<!DOCTYPE html>
<!-- Save as live-video.html and double-click. Public endpoint, no signup. -->
<meta charset="utf-8">
<title>Tik.Tools live video</title>
<style>
  body{margin:0;background:#000;color:#fff;font:14px system-ui}
  video{width:100%;max-width:900px;display:block;margin:0 auto;background:#000}
  .bar{display:flex;gap:8px;justify-content:center;padding:10px}
  input,button{font:inherit;background:#14141a;color:#fff;border:1px solid #333;border-radius:6px;padding:6px 10px}
  button{background:linear-gradient(135deg,#ff0085,#a935f1);border:none;cursor:pointer;font-weight:700}
  #info{padding:6px;text-align:center;color:#cbd5e1}
</style>
<div class="bar">
  <input id="u" placeholder="username (empty = random live)" />
  <button id="go">Play</button>
</div>
<div id="info">Pick any TikTok LIVE creator or leave empty for a random one.</div>
<video id="v" controls playsinline autoplay muted></video>
<script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
<script>
const API = 'https://api.tik.tools';
go.onclick = async () => {
  const wanted = u.value.trim().replace(/^@/, '');
  const r = await fetch(API + '/api/live/top-channels').then(r => r.json());
  let pick = null;
  if (wanted) {
    pick = (r.channels || []).find(c => c.uniqueId === wanted) || null;
    if (!pick) { info.textContent = '@' + wanted + ' not in current ticker. Try empty for random.'; return; }
  } else {
    pick = (r.channels || []).find(c => c.streamUrls && c.streamUrls.hls) || null;
    if (!pick) { info.textContent = 'No streams available right now.'; return; }
  }
  if (!pick.streamUrls || !pick.streamUrls.hls) { info.textContent = 'No stream URL for @' + pick.uniqueId; return; }
  info.textContent = '@' + pick.uniqueId + ' - LIVE';
  const hls = pick.streamUrls.hls;
  if (v.canPlayType('application/vnd.apple.mpegurl')) { v.src = hls; v.play(); }
  else if (window.Hls) { const h = new Hls(); h.loadSource(hls); h.attachMedia(v); }
};
go.click();
</script>

Write a minimal one-file program that plays a live TikTok stream in a <video> tag (HTML) or prints stream URLs (Node/Python) using the Tik.Tools public ticker. The program must:

1. Accept an optional CLI argument / input: TikTok username. If empty, pick the first channel from the ticker that has streamUrls.hls.
2. Call: GET https://api.tik.tools/api/live/top-channels (no auth, no signup, public). Response: {channels:[{uniqueId, displayName, region, roomId, streamUrls:{hls, flv}}], generatedAt, cachedFor}
3. For HTML, load hls.js from https://cdn.jsdelivr.net/npm/hls.js@latest. Safari plays HLS natively; Chrome/Firefox need hls.js.
4. The public ticker cache is 60s with 1 call per 5 min per IP. For per-creator live URLs without ticker-rate-limit, sign up free at https://tik.tools and use POST /webcast/room_video with a real API key.

Pick the language I asked for. One file. Zero dependencies (Safari) or one hls.js CDN script (Chrome). Stupid simple. Comment the username swap line.

Stream offlineEnter a live TikTok username above

Live events monitor

// live-events.mjs
// Run: node live-events.mjs                  (random live creator)
//      node live-events.mjs aljazeeraenglish (specific channel)
// Requires Node 22+ (native WebSocket). Zero npm install.

const KEY  = 'your_api_key';   // <- swap for your free key at https://tik.tools
const USER = (process.argv[2] || '').replace(/^@/, '');
const API  = 'https://api.tik.tools', WS = 'wss://api.tik.tools';

let user = USER;
if (!user) {
  const r = await fetch(API + '/api/live/top-channels').then(r => r.json());
  user = r.channels?.[0]?.uniqueId;
  if (!user) { console.log('No live creators right now.'); process.exit(0); }
  console.log('Random live pick:', user);
}

const j = await fetch(API + '/authentication/jwt?apiKey=' + KEY, {
  method: 'POST', headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ allowed_creators: [user], expire_after: 600, max_websockets: 1 }),
}).then(r => r.json());
const token = j.data?.token;
if (!token) { console.log('Auth failed:', j); process.exit(1); }

console.log('Connecting to @' + user);
const ws = new WebSocket(`${WS}?uniqueId=${user}&jwtKey=${encodeURIComponent(token)}`);
ws.onmessage = ev => {
  const e = JSON.parse(ev.data);
  if (e.event === 'roomInfo') return;
  const d = e.data || {};
  console.log(`[${e.event}]`, d.user?.nickname || d.user_unique_id || '', d.comment || d.giftName || '');
};
ws.onclose = ev => { console.log('Closed:', ev.reason || ev.code); };

# live_events.py
# Run: pip install websockets
#      python live_events.py                  (random live creator)
#      python live_events.py aljazeeraenglish (specific channel)
import asyncio, json, sys, urllib.request, websockets

KEY  = 'your_api_key'  # <- swap for your free key at https://tik.tools
USER = (sys.argv[1] if len(sys.argv) > 1 else '').lstrip('@')
API  = 'https://api.tik.tools'; WS = 'wss://api.tik.tools'

def call(url, body=None):
    req = urllib.request.Request(url, method='POST' if body else 'GET',
        headers={'Content-Type': 'application/json'},
        data=json.dumps(body).encode() if body else None)
    return json.loads(urllib.request.urlopen(req).read())

async def main():
    user = USER
    if not user:
        r = call(API + '/api/live/top-channels')
        user = (r.get('channels') or [{}])[0].get('uniqueId', '')
        if not user: print('No live creators right now.'); return
        print('Random live pick:', user)
    j = call(API + '/authentication/jwt?apiKey=' + KEY,
             {'allowed_creators': [user], 'expire_after': 600, 'max_websockets': 1})
    token = j.get('data', {}).get('token')
    if not token: print('Auth failed:', j); return
    print('Connecting to @' + user)
    url = f"{WS}?uniqueId={user}&jwtKey={token}"
    async with websockets.connect(url) as ws:
        async for raw in ws:
            e = json.loads(raw)
            if e.get('event') == 'roomInfo': continue
            d = e.get('data', {})
            nm = (d.get('user') or {}).get('nickname') or d.get('user_unique_id') or ''
            text = d.get('comment') or (f"sent {d['giftName']} x{d.get('repeatCount', 1)}" if d.get('giftName') else '')
            print(f"[{e.get('event')}] {nm} {text}")

asyncio.run(main())

<!DOCTYPE html>
<!-- Save as live-events.html and double-click. No build step. No signup. -->
<meta charset="utf-8">
<title>Tik.Tools live events</title>
<style>
  body{font:14px ui-monospace,Menlo,monospace;background:#0a0a0c;color:#e4e4e7;padding:24px;max-width:760px;margin:0 auto}
  h1{font-size:18px;margin:0 0 8px}
  .bar{display:flex;gap:8px;margin:8px 0 14px}
  input,button{font:inherit;background:#14141a;color:#fff;border:1px solid #333;border-radius:6px;padding:6px 10px}
  button{background:linear-gradient(135deg,#ff0085,#a935f1);border:none;cursor:pointer;font-weight:700}
  .row{padding:6px 10px;border-bottom:1px solid #222;display:flex;gap:10px;align-items:baseline}
  .type{font-size:11px;text-transform:uppercase;color:#a5b4fc;width:60px;flex-shrink:0}
  .user{color:#fff;font-weight:600}
  .msg{color:#9aa0a6;flex:1;overflow:hidden;text-overflow:ellipsis}
</style>
<h1>Live events monitor</h1>
<div class="bar">
  <input id="u" placeholder="username (empty = random live)" />
  <button id="go">Connect</button>
</div>
<div id="status">Enter a username or click Connect for a random live creator.</div>
<div id="feed"></div>
<script>
const API = 'https://api.tik.tools', WS = 'wss://api.tik.tools';
const KEY = 'your_api_key';   // <- swap for your free key at https://tik.tools

let ws = null;
async function connect() {
  if (ws) try { ws.close(); } catch {}
  feed.innerHTML = '';
  let user = u.value.trim().replace(/^@/, '');
  if (!user) {
    status.textContent = 'Picking a random live creator...';
    try {
      const r = await fetch(API + '/api/live/top-channels').then(r => r.json());
      user = (r.channels && r.channels[0] && r.channels[0].uniqueId) || '';
    } catch {}
    if (!user) { status.textContent = 'No live creators right now, try again in a minute.'; return; }
  }
  status.textContent = 'Connecting to @' + user + '...';

  const j = await fetch(API + '/authentication/jwt?apiKey=' + KEY, {
    method: 'POST', headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ allowed_creators: [user], expire_after: 600, max_websockets: 1 }),
  }).then(r => r.json());
  const token = j.data && j.data.token;
  if (!token) { status.textContent = 'Auth failed - get a free key at https://tik.tools'; return; }

  ws = new WebSocket(WS + '?uniqueId=' + user + '&jwtKey=' + encodeURIComponent(token));
  ws.onopen = () => status.textContent = '@' + user + ' - LIVE';
  ws.onmessage = ev => {
    const e = JSON.parse(ev.data);
    if (e.event === 'roomInfo' || !e.event) return;
    const d = e.data || {}, nm = (d.user && d.user.nickname) || d.user_unique_id || 'someone';
    const text = d.comment || (d.giftName ? 'sent ' + d.giftName + ' x' + (d.repeatCount || 1) : '');
    feed.insertAdjacentHTML('afterbegin',
      '<div class="row"><span class="type">' + e.event + '</span><span class="user">' + nm + '</span><span class="msg">' + text + '</span></div>');
  };
  ws.onclose = ev => { status.textContent = 'Closed: ' + (ev.reason || ev.code); };
}
go.onclick = connect;
// Auto-connect on load so the embedded preview starts streaming immediately.
connect();
</script>

Write me a minimal one-file program that connects to a TikTok LIVE stream using the Tik.Tools API + WebSocket gateway and prints every chat / gift / like / member event to the console. The program must:

1. Accept an optional CLI argument: the TikTok username to watch. If empty, hit GET https://api.tik.tools/api/live/top-channels (no auth, public, returns {channels:[{uniqueId,...}]}) and use channels[0].uniqueId.
2. Mint a short-lived JWT: POST https://api.tik.tools/authentication/jwt?apiKey=your_api_key with body {"allowed_creators":["<user>"],"expire_after":600,"max_websockets":1}. Response: {data:{token:"..."}}.
3. Open a WebSocket: wss://api.tik.tools?uniqueId=<user>&jwtKey=<token>
4. Each WS message is JSON shaped {event, data:{user:{nickname,uniqueId}, comment, giftName, repeatCount, viewerCount}}.

Constraints:
- Zero npm install / pip install except 'websockets' (Python only).
- One file. No build step. Stupid simple to copy/paste and run.
- The API key 'your_api_key' is the public demo - works without signup, 10-min sessions, 1 concurrent WS, strict per-IP daily caps. For production, sign up free at https://tik.tools to get a real key with higher limits + access to /webcast/* endpoints.

Pick the language I asked for and give me ONE working file. Comment the swap-the-key line + the username arg.

<50msLatency

99.9%Uptime

FreeCommunity Tier

What Is the TikTok LIVE API?

TikTok does not offer a public API for live stream data like chat, gifts, or viewer counts. The TikTok Business API only covers ads and shop analytics. To access real-time LIVE data, developers use third-party APIs.

The open-source libraries tiktok-live-connector (Node.js) and TikTokLive (Python) are MIT-licensed and free to use. They delegate TikTok signing to a backend - the default is Euler Stream, the paid signing service built by the same team that maintains those libraries. Euler Stream has its own free tier and paid plans for higher volumes.

TikTool is an independent alternative with its own signing infrastructure. It's a fully managed API where signature generation, CAPTCHA solving, and Public Broadcast Telemetry rotation are all included. One WebSocket connection delivers 18+ event types - chat, gifts, likes, follows, viewers, battles, and more. Official SDKs for Node.js and Python. Free Community tier, no credit card required.

Get Free API Key →WebSocket Docs

How Does the TikTok LIVE API Work?

TikTool sits between your application and TikTok's live streaming infrastructure. Here's the architecture:

Your App Connects

Your app opens a WebSocket to wss://api.tik.tools with a TikTok username and your API key.

TikTool Resolves

TikTool resolves the room ID, handles authentication, solves challenges, and joins the live stream.

Events Flow

Real-time events (chat, gifts, viewers, etc.) stream to your app as clean JSON - parsed, structured, and typed.

You never deal with TikTok's protocol directly. When TikTok changes their internal systems (which happens frequently), TikTool adapts - your code keeps working unchanged.

Quick Start - Node.js / TypeScript

Install the official SDK from npm:

npm install tiktok-live-api

Connect to a live stream and receive events:

import { TikTokLive } from 'tiktok-live-api';

const client = new TikTokLive('streamer_username', {
  apiKey: 'YOUR_API_KEY' // Get free key → https://tik.tools
});

client.on('chat', (event) => {
  console.log(`${event.user.uniqueId}: ${event.comment}`);
});

client.on('gift', (event) => {
  console.log(`🎁 ${event.user.uniqueId} sent ${event.giftName} (${event.diamondCount} 💎)`);
});

client.on('roomUserSeq', (event) => {
  console.log(`👀 ${event.viewerCount} viewers watching`);
});

client.connect();

Full TypeScript support - every event type, field, and parameter is fully typed with autocompletion in your IDE. Read the complete Node.js guide →

Quick Start - Python

Install from PyPI:

pip install tiktok-live-api

Connect and receive events:

import asyncio, websockets, json

async def connect():
    uri = "wss://api.tik.tools?uniqueId=streamer_username&apiKey=YOUR_API_KEY"
    async with websockets.connect(uri) as ws:
        async for message in ws:
            event = json.loads(message)
            if event["event"] == "chat":
                user = event["data"]["user"]["uniqueId"]
                comment = event["data"]["comment"]
                print(f"{user}: {comment}")
            elif event["event"] == "gift":
                user = event["data"]["user"]["uniqueId"]
                gift = event["data"]["giftName"]
                print(f"🎁 {user} sent {gift}")

asyncio.run(connect())

Read the complete Python guide →

Quick Start - Raw WebSocket (Any Language)

Any language with WebSocket support works - Go, Rust, Java, C#, Ruby, PHP, Dart, Kotlin, Swift. Just connect to:

wss://api.tik.tools?uniqueId=TIKTOK_USERNAME&apiKey=YOUR_API_KEY

Every message is a JSON object with event and data fields. Clean, structured data - no binary parsing needed. Full WebSocket API reference →

All Event Types

The TikTok LIVE API streams 18+ real-time events from any live stream:

chat

Chat message from a viewer. Includes user info, comment text, emotes, and badges.

gift

Virtual gift sent by a viewer. Includes gift name, diamond value, repeat count, and combo status.

like

A viewer liked the stream. Includes per-event count and total likes.

member

A viewer joined the live room. Fires when users enter the stream.

follow

A viewer followed the streamer during the live stream.

share

A viewer shared the live stream with their friends.

subscribe

A viewer subscribed to the streamer.

roomUserSeq

Viewer count update. Current viewer count and top viewers list.

battle

Battle/LinkMic event. Battle status, teams, scores, and participants.

battleArmies

Battle armies update with team scores and participant rankings.

roomPin

A chat message was pinned or starred by the streamer.

caption

AI-powered live caption. Real-time speech-to-text with translation support.

envelope

Treasure chest or envelope event in the stream.

emote

Custom emote sent in chat by a viewer.

liveIntro

Stream intro update - title and description changes.

streamEnd

The live stream has ended. Includes the reason code.

connected

Successfully connected to the TikTok live stream.

error

Connection error occurred. Includes error details.

See full event reference with example payloads →

What Can You Build?

🤖

Chat Assistants

Build automated chat assistants that respond to viewer messages, commands, and gifts in real-time.

📊

Analytics

Track viewer counts, engagement rates, gift revenue, and chat activity across streams.

🎮

Interactive Games

Let viewers control game elements with gifts, chat commands, and likes.

🎬

Stream Overlays

Create OBS/Streamlabs overlays showing chat, gift alerts, and viewer stats.

🗣️

Live Captions

AI-powered speech-to-text transcription and real-time translation in 50+ languages.

📱

Mobile Apps

Build mobile apps that monitor and interact with TikTok LIVE streams.

See more use cases →

TikTool vs Euler Stream vs tiktok-live-connector

The open-source tiktok-live-connector (Node.js) and TikTokLive (Python) libraries are maintained by the same team that runs Euler Stream. Together they form a well-supported ecosystem with MIT-licensed clients and a managed signing backend. TikTool is an independent managed alternative with its own signing infrastructure and a different feature focus.

Managed service✓ 99.9% uptimeSelf-hosted clientSelf-hosted client✓ Managed

Node.js SDK✓ Official✗✓ Official✓ eulerstream

Python SDK✓ Official✓ Official✗✓ via TikTokLive

AI Live Captions✓ Speech-to-text✗✗✗

Unreal Engine plugin✓✗✗✗

Gifter intel (LTV, archetypes)✓✗✗✗

Live leaderboards✓ Real-time✗✗✗

Battle history + timeline✓ Per-match✗✗✗

League rankings✓ Diamond Rush✗✗✗

Real-time alerts✓ Discord + Telegram✗✗✗

Sniper Gap (live battle tracker)✓✗✗✗

Agency CRM + watchlists✓✗✗✗

Public profile pages (creator + gifter)✓ Indexed✗✗✗

Free tier✓ 2,500 req/day✓ MIT-licensed✓ MIT-licensed✓ 1,000 req/day

WebSocket API✓ Any languagePython onlyNode.js only✓

CAPTCHA handling✓ Built-inVia signing backendVia signing backend✓ Built-in

See the full comparison →

Pricing & Free Tier

Start building with the TikTok LIVE API for free. No credit card required.

Community15 connections2,500/dayFree Community Tier

Pro50 connections75,000/day$15/week

Ultra250 connections300,000/day$45/week

Agency250 + Firehose300,000/day$119/week

View Plans →Start Free

Frequently Asked Questions

Is there a public API for live stream data?

Is the TikTok LIVE API free?

What programming languages does the TikTok LIVE API support?

How is TikTool different from open-source live stream libraries?

What data can I get from TikTok LIVE streams?

What is the latency?

Can I build a TikTok LIVE chat assistant?

How many streams can I monitor simultaneously?

How does TikTool compare to Euler Stream?

Is TikTool better than TikFinity for developers?

Can I use TikTok LIVE API for stream analytics?

Does the TikTok LIVE API work with OBS and Streamlabs?

Get Started →Free API key in 30 seconds WebSocket Reference →Full event docs