Node.js module to receive live stream chat events like comments and gifts from TikTok LIVE. 

Node.js module to receive live stream chat events like comments and gifts from TikTok LIVE

zerodytrash

tiktok-live-connector

const { WebcastPushConnection, signatureProvider } = require('tiktok-live-connector');

// signatureProvider.signEvents.on('signSuccess', (data) => console.log(data));

signatureProvider.config.extraParams.apiKey = 'NDA2NDA5OTI3N2M4OTE0OGQ3NWEzOWQxMTg2NzFmODViYTIxN2NkNzYwNDdiYThkZWE3ZGM2';	

// Username of someone who is currently live

// Create a new wrapper object and pass the username

let tiktokLiveConnection = new WebcastPushConnection(tiktokUsername);

// Connect to the chat (await can be used as well)

tiktokLiveConnection.connect().then(state => {

    console.info(`Connected to roomId ${state.roomId}`);

    console.error('Failed to connect', err);

// Define the events that you want to handle

// In this case we listen to chat messages (comments)

tiktokLiveConnection.on('chat', data => {

    console.log(`${data.uniqueId} (userId:${data.userId}) writes: ${data.comment}`);

// And here we receive gifts sent to the streamer

tiktokLiveConnection.on('gift', data => {

    console.log(`${data.uniqueId} (userId:${data.userId}) sends ${data.giftId}`);

function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }

function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }

function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }

function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }

function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }

function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }

function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }

function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }

const TikTokHttpClient = require('./lib/tiktokHttpClient.js');

const WebcastWebsocket = require('./lib/webcastWebsocket.js');

} = require('./lib/webcastDataConverter.js');

const Config = require('./lib/webcastConfig.js');

 * Wrapper class for TikTok's internal Webcast Push Service

var _options = /*#__PURE__*/new WeakMap();

var _uniqueStreamerId = /*#__PURE__*/new WeakMap();

var _roomId = /*#__PURE__*/new WeakMap();

var _roomInfo = /*#__PURE__*/new WeakMap();

var _clientParams = /*#__PURE__*/new WeakMap();

var _httpClient = /*#__PURE__*/new WeakMap();

var _availableGifts = /*#__PURE__*/new WeakMap();

var _websocket = /*#__PURE__*/new WeakMap();

var _isConnecting = /*#__PURE__*/new WeakMap();

var _isConnected = /*#__PURE__*/new WeakMap();

var _isPollingEnabled = /*#__PURE__*/new WeakMap();

  let webcastResponse = await _classPrivateFieldGet(this, _httpClient).getDeserializedObjectFromWebcastApi('im/fetch/', _classPrivateFieldGet(this, _clientParams), 'WebcastResponse', isInitial);

  let upgradeToWsOffered = !!webcastResponse.wsUrl && !!webcastResponse.wsParam;

  let upgradeToWsOffered = !!webcastResponse.wsUrl;

      throw new Error('Missing cursor in initial fetch response.');

      _classPrivateMethodGet(this, _handleError, _handleError2).call(this, null, 'Missing cursor in fetch response.');

  } // Set cursor and internal_ext param to continue with the next request

  if (webcastResponse.cursor) _classPrivateFieldGet(this, _clientParams).cursor = webcastResponse.cursor;

  if (webcastResponse.internalExt) _classPrivateFieldGet(this, _clientParams).internal_ext = webcastResponse.internalExt;

    // Upgrade to Websocket offered? => Try upgrade

    if (_classPrivateFieldGet(this, _options).enableWebsocketUpgrade && upgradeToWsOffered) {

      await _classPrivateMethodGet(this, _tryUpgradeToWebsocket, _tryUpgradeToWebsocket2).call(this, webcastResponse);

  } // Skip processing initial data if option disabled

  if (isInitial && !_classPrivateFieldGet(this, _options).processInitialData) {

  _classPrivateMethodGet(this, _processWebcastResponse, _processWebcastResponse2).call(this, webcastResponse);

async function _tryUpgradeToWebsocket2(webcastResponse) {

      imprp: webcastResponse.wsParam.value,

      imprp: ((_webcastResponse$wsPa = webcastResponse.wsParam) === null || _webcastResponse$wsPa === void 0 ? void 0 : _webcastResponse$wsPa.value) || '',

    }; // Wait until ws connected, then stop request polling

    await _classPrivateMethodGet(this, _setupWebsocket, _setupWebsocket2).call(this, webcastResponse.wsUrl, wsParams);

    _classPrivateFieldSet(this, _isWsUpgradeDone, true);

    _classPrivateFieldSet(this, _isPollingEnabled, false);

    this.emit(ControlEvents.WSCONNECTED, _classPrivateFieldGet(this, _websocket));

    _classPrivateMethodGet(this, _handleError, _handleError2).call(this, err, 'Upgrade to websocket failed');

async function _setupWebsocket2(wsUrl, wsParams) {

  return new Promise((resolve, reject) => {

    _classPrivateFieldSet(this, _websocket, new WebcastWebsocket(wsUrl, _classPrivateFieldGet(this, _httpClient).cookieJar, _classPrivateFieldGet(this, _clientParams), wsParams, _classPrivateFieldGet(this, _options).websocketHeaders, _classPrivateFieldGet(this, _options).websocketOptions));

    _classPrivateFieldGet(this, _websocket).on('connect', wsConnection => {

      wsConnection.on('error', err => _classPrivateMethodGet(this, _handleError, _handleError2).call(this, err, 'Websocket Error'));

    _classPrivateFieldGet(this, _websocket).on('connectFailed', err => reject(`Websocket connection failed, ${err}`));

    _classPrivateFieldGet(this, _websocket).on('webcastResponse', msg => _classPrivateMethodGet(this, _processWebcastResponse, _processWebcastResponse2).call(this, msg));

    _classPrivateFieldGet(this, _websocket).on('messageDecodingFailed', err => _classPrivateMethodGet(this, _handleError, _handleError2).call(this, err, 'Websocket message decoding failed')); // Hard timeout if the WebSocketClient library does not handle connect errors correctly.

    setTimeout(() => reject('Websocket not responding'), 30000);

function _processWebcastResponse2(webcastResponse) {

  // Emit raw (protobuf encoded) data for a use case specific processing

  webcastResponse.messages.forEach(message => {

    this.emit(ControlEvents.RAWDATA, message.type, message.binary);

  }); // Process and emit decoded data depending on the the message type

  webcastResponse.messages.filter(x => x.decodedData).forEach(message => {

    var _simplifiedObj$displa, _simplifiedObj$displa2;

    let simplifiedObj = simplifyObject(message.decodedData);

    this.emit(ControlEvents.DECODEDDATA, message.type, simplifiedObj, message.binary);

        // 4 = Stream terminated by platform moderator (ban)

        const action = message.decodedData.action;

          this.emit(ControlEvents.STREAMEND, {

        this.emit(MessageEvents.ROOMUSER, simplifiedObj);

        this.emit(MessageEvents.CHAT, simplifiedObj);

        this.emit(MessageEvents.MEMBER, simplifiedObj);

        // Add extended gift info if option enabled

        if (Array.isArray(_classPrivateFieldGet(this, _availableGifts)) && simplifiedObj.giftId) {

          simplifiedObj.extendedGiftInfo = _classPrivateFieldGet(this, _availableGifts).find(x => x.id === simplifiedObj.giftId);

        this.emit(MessageEvents.GIFT, simplifiedObj);

        this.emit(MessageEvents.SOCIAL, simplifiedObj);

        if ((_simplifiedObj$displa = simplifiedObj.displayType) !== null && _simplifiedObj$displa !== void 0 && _simplifiedObj$displa.includes('follow')) {

          this.emit(CustomEvents.FOLLOW, simplifiedObj);

        if ((_simplifiedObj$displa2 = simplifiedObj.displayType) !== null && _simplifiedObj$displa2 !== void 0 && _simplifiedObj$displa2.includes('share')) {

          this.emit(CustomEvents.SHARE, simplifiedObj);

//# sourceMappingURL=webcastConfig.d.ts.map

  TIKTOK_URL_WEB: 'https://www.tiktok.com/',

  TIKTOK_URL_WEBCAST: 'https://webcast.tiktok.com/webcast/',

  TIKTOK_HTTP_ORIGIN: 'https://www.tiktok.com',

    browser_version: '5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36',

    root_referer: 'https://www.tiktok.com/',

    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36',

    Accept: 'text/html,application/json,application/protobuf',

const Config = require('./webcastConfig.js');

var _handleEvents = /*#__PURE__*/new WeakSet();

var _handleMessage = /*#__PURE__*/new WeakSet();

var _sendPing = /*#__PURE__*/new WeakSet();

var _sendAck = /*#__PURE__*/new WeakSet();

class WebcastWebsocket extends websocket.client {

  constructor(wsUrl, cookieJar, clientParams, wsParams, customHeaders, websocketOptions) {

    _classPrivateMethodInitSpec(this, _sendAck);

    _classPrivateMethodInitSpec(this, _sendPing);

    _classPrivateMethodInitSpec(this, _handleMessage);

    _classPrivateMethodInitSpec(this, _handleEvents);

    this.wsUrlWithParams = `${wsUrl}?${new URLSearchParams(this.wsParams)}`;

      Cookie: cookieJar.getCookieString(),

    _classPrivateMethodGet(this, _handleEvents, _handleEvents2).call(this);

    this.connect(this.wsUrlWithParams, 'echo-protocol', Config.TIKTOK_URL_WEBCAST, this.wsHeaders, websocketOptions);

    this.connect(this.wsUrlWithParams, '', Config.TIKTOK_URL_WEB, this.wsHeaders, websocketOptions);

    this.pingInterval = setInterval(() => _classPrivateMethodGet(this, _sendPing, _sendPing2).call(this), 10000);

    wsConnection.on('message', message => {

        _classPrivateMethodGet(this, _handleMessage, _handleMessage2).call(this, message);

async function _handleMessage2(message) {

    let decodedContainer = await deserializeWebsocketMessage(message.binaryData);

      _classPrivateMethodGet(this, _sendAck, _sendAck2).call(this, decodedContainer.id);

    } // Emit 'WebcastResponse' from ws message container if decoding success

    if (typeof decodedContainer.webcastResponse === 'object') {

      this.emit('webcastResponse', decodedContainer.webcastResponse);

    this.emit('messageDecodingFailed', err);

  this.connection.sendBytes(Buffer.from('3A026862', 'hex'));

  let ackMsg = serializeMessage('WebcastWebsocketAck', {

  "description": "Node.js module to receive live stream chat events like comments and gifts from TikTok LIVE",

    "test": "echo \"Error: no test specified\" && exit 1",

    "format": "prettier --write src/**/*.js",

    "build": "babel src -d dist --copy-files && npx tsc"

    "url": "git+https://github.com/zerodytrash/TikTok-Live-Connector.git"

      "url": "https://www.patreon.com/zerody"

    "url": "https://github.com/zerodytrash/TikTok-Live-Connector/issues"

  "homepage": "https://github.com/zerodytrash/TikTok-Live-Connector#readme",

		@@ -5,4 +5,6 @@ const { WebcastPushConnection, signatureProvider } = require('tiktok-live-connector');

		signatureProvider.config.extraParams.apiKey = 'NDA2NDA5OTI3N2M4OTE0OGQ3NWEzOWQxMTg2NzFmODViYTIxN2NkNzYwNDdiYThkZWE3ZGM2';

		// Username of someone who is currently live
		let tiktokUsername = "curlyyy14";
		let tiktokUsername = "deryaoffiziell";

		@@ -9,0 +11,0 @@ // Create a new wrapper object and pass the username

		@@ -573,3 +573,3 @@ "use strict";
		let webcastResponse = await _classPrivateFieldGet(this, _httpClient).getDeserializedObjectFromWebcastApi('im/fetch/', _classPrivateFieldGet(this, _clientParams), 'WebcastResponse', isInitial);
		let upgradeToWsOffered = !!webcastResponse.wsUrl && !!webcastResponse.wsParam;
		let upgradeToWsOffered = !!webcastResponse.wsUrl;

		@@ -605,5 +605,7 @@ if (!webcastResponse.cursor) {
		try {
		var _webcastResponse$wsPa;

		// Websocket specific params
		let wsParams = {
		imprp: webcastResponse.wsParam.value,
		imprp: ((_webcastResponse$wsPa = webcastResponse.wsParam) === null \|\| _webcastResponse$wsPa === void 0 ? void 0 : _webcastResponse$wsPa.value) \|\| '',
		compress: 'gzip'
		@@ -610,0 +612,0 @@ }; // Wait until ws connected, then stop request polling

		@@ -32,2 +32,3 @@ export const TIKTOK_URL_WEB: string;
		const root_referer: string;
		const host: string;
		const version_code: number;
		@@ -34,0 +35,0 @@ const webcast_sdk_version: string;

		@@ -22,3 +22,3 @@ "use strict";
		from_page: 'user',
		history_len: 4,
		history_len: 0,
		is_fullscreen: false,
		@@ -36,3 +36,4 @@ is_page_visible: true,
		root_referer: 'https://www.tiktok.com/',
		version_code: 180800,
		host: 'https://webcast.tiktok.com',
		version_code: 270000,
		webcast_sdk_version: '1.3.0',
		@@ -39,0 +40,0 @@ update_version_code: '1.3.0'

		{
		"name": "tiktok-live-connector",
		"version": "1.1.3",
		"version": "1.1.4",
		"description": "Node.js module to receive live stream chat events like comments and gifts from TikTok LIVE",
		@@ -5,0 +5,0 @@ "main": "index.js",

		@@ -51,3 +51,3 @@ "use strict";

		this.connect(this.wsUrlWithParams, 'echo-protocol', Config.TIKTOK_URL_WEBCAST, this.wsHeaders, websocketOptions);
		this.connect(this.wsUrlWithParams, '', Config.TIKTOK_URL_WEB, this.wsHeaders, websocketOptions);
		}
		@@ -54,0 +54,0 @@

Improved metrics