@nxgiang/tiktok-api 1.3.7

package/lib/utils/downloader/ssstikDownloader.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSSTik = void 0;
+const axios_1 = __importDefault(require("axios"));
+const async_retry_1 = __importDefault(require("async-retry"));
+const cheerio_1 = require("cheerio");
+const api_1 = require("../../constants/api");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const socks_proxy_agent_1 = require("socks-proxy-agent");
+const constants_1 = require("../../constants");
+const TIKTOK_URL_REGEX = /https:\/\/(?:m|t|www|vm|vt|lite)?\.?tiktok\.com\/((?:.*\b(?:(?:usr|v|embed|user|video|photo)\/|\?shareId=|\&item_id=)(\d+))|\w+)/;
+const USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/111.0";
+const createProxyAgent = (proxy) => {
+    if (!proxy)
+        return {};
+    const isHttpProxy = proxy.startsWith("http") || proxy.startsWith("https");
+    const isSocksProxy = proxy.startsWith("socks");
+    if (!isHttpProxy && !isSocksProxy)
+        return {};
+    return {
+        httpsAgent: isHttpProxy
+            ? new https_proxy_agent_1.HttpsProxyAgent(proxy)
+            : new socks_proxy_agent_1.SocksProxyAgent(proxy)
+    };
+};
+const validateTikTokUrl = (url) => {
+    return TIKTOK_URL_REGEX.test(url);
+};
+const extractTTValue = (html) => {
+    const regex = /s_tt\s*=\s*["']([^"']+)["']/;
+    const match = html.match(regex);
+    return match ? match[1] : null;
+};
+const parseAuthor = ($) => ({
+    avatar: $("img.result_author").attr("src") || "",
+    nickname: $("h2").text().trim()
+});
+const parseStatistics = ($) => ({
+    likeCount: $("#trending-actions > .justify-content-start").text().trim(),
+    commentCount: $("#trending-actions > .justify-content-center").text().trim(),
+    shareCount: $("#trending-actions > .justify-content-end").text().trim()
+});
+const parseImages = ($) => {
+    const images = [];
+    $("ul.splide__list > li").each((_, img) => {
+        const href = $(img).find("a").attr("href");
+        if (href)
+            images.push(href);
+    });
+    return images;
+};
+const createImageResponse = ($, author, statistics, images, music) => ({
+    type: "image",
+    desc: $("p.maintext").text().trim(),
+    author,
+    statistics,
+    images,
+    ...(music && { music: { playUrl: [music] } })
+});
+const createVideoResponse = ($, author, statistics, video, music) => ({
+    type: "video",
+    desc: $("p.maintext").text().trim(),
+    author,
+    statistics,
+    video: { playAddr: [video] },
+    ...(music && { music: { playUrl: [music] } })
+});
+const createMusicResponse = (music, direct) => ({
+    type: "music",
+    music: { playUrl: [music] },
+    direct: direct || ""
+});
+const fetchTT = async (proxy) => {
+    try {
+        const { data } = await (0, axios_1.default)(api_1._ssstikurl, {
+            method: "GET",
+            headers: { "User-Agent": USER_AGENT },
+            ...createProxyAgent(proxy)
+        });
+        const ttValue = extractTTValue(data);
+        if (!ttValue) {
+            return {
+                status: "error",
+                message: constants_1.ERROR_MESSAGES.NETWORK_ERROR
+            };
+        }
+        return {
+            status: "success",
+            result: ttValue
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            message: error instanceof Error ? error.message : constants_1.ERROR_MESSAGES.NETWORK_ERROR
+        };
+    }
+};
+const SSSTik = async (url, proxy) => {
+    try {
+        if (!validateTikTokUrl(url)) {
+            return {
+                status: "error",
+                message: constants_1.ERROR_MESSAGES.INVALID_URL
+            };
+        }
+        const tt = await fetchTT(proxy);
+        if (tt.status !== "success") {
+            return {
+                status: "error",
+                message: tt.message
+            };
+        }
+        const response = await (0, async_retry_1.default)(async () => {
+            const res = await (0, axios_1.default)(api_1._ssstikapi, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+                    Origin: api_1._ssstikurl,
+                    Referer: `${api_1._ssstikurl}/en`,
+                    "User-Agent": USER_AGENT
+                },
+                data: new URLSearchParams({
+                    id: url,
+                    locale: "en",
+                    tt: tt.result
+                }),
+                ...createProxyAgent(proxy)
+            });
+            if (res.status === 200 && res.data) {
+                return res.data;
+            }
+            throw new Error(constants_1.ERROR_MESSAGES.NETWORK_ERROR);
+        }, {
+            retries: 20,
+            minTimeout: 200,
+            maxTimeout: 1000
+        });
+        const $ = (0, cheerio_1.load)(response);
+        const author = parseAuthor($);
+        const statistics = parseStatistics($);
+        const video = $("a.without_watermark").attr("href");
+        const music = $("a.music").attr("href");
+        const direct = $("a.music_direct").attr("href");
+        const images = parseImages($);
+        let result;
+        if (images.length > 0) {
+            result = createImageResponse($, author, statistics, images, music);
+        }
+        else if (video) {
+            result = createVideoResponse($, author, statistics, video, music);
+        }
+        else if (music) {
+            result = createMusicResponse(music, direct);
+        }
+        else {
+            return {
+                status: "error",
+                message: constants_1.ERROR_MESSAGES.NETWORK_ERROR
+            };
+        }
+        return {
+            status: "success",
+            result
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            message: error instanceof Error ? error.message : constants_1.ERROR_MESSAGES.NETWORK_ERROR
+        };
+    }
+};
+exports.SSSTik = SSSTik;

package/lib/utils/downloader/tiktokAPIDownloader.d.ts

@@ -0,0 +1,3 @@
+import { TiktokAPIResponse } from "../../types/downloader/tiktokApiDownloader";
+export declare const handleRedirect: (url: string, proxy?: string) => Promise<string>;
+export declare const TiktokAPI: (url: string, proxy?: string, showOriginalResponse?: boolean) => Promise<TiktokAPIResponse>;

package/lib/utils/downloader/tiktokAPIDownloader.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TiktokAPI = exports.handleRedirect = void 0;
+const axios_1 = __importDefault(require("axios"));
+const async_retry_1 = __importDefault(require("async-retry"));
+const api_1 = require("../../constants/api");
+const params_1 = require("../../constants/params");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const socks_proxy_agent_1 = require("socks-proxy-agent");
+const constants_1 = require("../../constants");
+const TIKTOK_URL_REGEX = /https:\/\/(?:m|t|www|vm|vt|lite)?\.?tiktok\.com\/((?:.*\b(?:(?:usr|v|embed|user|video|photo)\/|\?shareId=|\&item_id=)(\d+))|\w+)/;
+const USER_AGENT = "com.zhiliaoapp.musically/300904 (2018111632; U; Android 10; en_US; Pixel 4; Build/QQ3A.200805.001; Cronet/58.0.2991.0)";
+const createProxyAgent = (proxy) => {
+    if (!proxy)
+        return {};
+    const isHttpProxy = proxy.startsWith("http") || proxy.startsWith("https");
+    const isSocksProxy = proxy.startsWith("socks");
+    if (!isHttpProxy && !isSocksProxy)
+        return {};
+    return {
+        httpsAgent: isHttpProxy
+            ? new https_proxy_agent_1.HttpsProxyAgent(proxy)
+            : new socks_proxy_agent_1.SocksProxyAgent(proxy)
+    };
+};
+const validateTikTokUrl = (url) => {
+    return TIKTOK_URL_REGEX.test(url);
+};
+const extractVideoId = (responseUrl) => {
+    const matches = responseUrl.match(/\d{17,21}/g);
+    return matches ? matches[0] : null;
+};
+const parseStatistics = (content) => ({
+    commentCount: content.statistics.comment_count,
+    likeCount: content.statistics.digg_count,
+    shareCount: content.statistics.share_count,
+    playCount: content.statistics.play_count,
+    downloadCount: content.statistics.download_count
+});
+const parseAuthor = (content) => ({
+    uid: content.author.uid,
+    username: content.author.unique_id,
+    uniqueId: content.author.unique_id,
+    nickname: content.author.nickname,
+    signature: content.author.signature,
+    region: content.author.region,
+    avatarThumb: content.author?.avatar_thumb?.url_list || [],
+    avatarMedium: content.author?.avatar_medium?.url_list || [],
+    url: `${api_1._tiktokDesktopUrl}/@${content.author.unique_id}`
+});
+const parseMusic = (content) => ({
+    id: content.music.id,
+    title: content.music.title,
+    author: content.music.author,
+    album: content.music.album,
+    playUrl: content.music?.play_url?.url_list || [],
+    coverLarge: content.music?.cover_large?.url_list || [],
+    coverMedium: content.music?.cover_medium?.url_list || [],
+    coverThumb: content.music?.cover_thumb?.url_list || [],
+    duration: content.music.duration,
+    isCommerceMusic: content.music.is_commerce_music,
+    isOriginalSound: content.music.is_original_sound,
+    isAuthorArtist: content.music.is_author_artist
+});
+const parseVideo = (content) => ({
+    ratio: content.video.ratio,
+    duration: content.video.duration,
+    playAddr: content.video?.play_addr?.url_list || [],
+    downloadAddr: content.video?.download_addr?.url_list || [],
+    cover: content.video?.cover?.url_list || [],
+    dynamicCover: content.video?.dynamic_cover?.url_list || [],
+    originCover: content.video?.origin_cover?.url_list || []
+});
+const parseTiktokData = (ID, data) => {
+    const content = data?.aweme_list?.find((v) => v.aweme_id === ID);
+    if (!content)
+        return { content: null };
+    return {
+        content,
+        statistics: parseStatistics(content),
+        author: parseAuthor(content),
+        music: parseMusic(content)
+    };
+};
+const fetchTiktokData = async (ID, proxy) => {
+    try {
+        const response = await (0, async_retry_1.default)(async () => {
+            const res = await (0, axios_1.default)((0, api_1._tiktokvFeed)((0, params_1._tiktokApiParams)({ aweme_id: ID })), {
+                method: "OPTIONS",
+                headers: { "User-Agent": USER_AGENT },
+                ...createProxyAgent(proxy)
+            });
+            if (res.data && res.data.status_code === 0) {
+                return res.data;
+            }
+            throw new Error(constants_1.ERROR_MESSAGES.NETWORK_ERROR);
+        }, {
+            retries: 20,
+            minTimeout: 200,
+            maxTimeout: 1000
+        });
+        return parseTiktokData(ID, response);
+    }
+    catch (error) {
+        console.error("Error fetching TikTok data:", error);
+        return null;
+    }
+};
+const createImageResponse = (content, author, statistics, music) => ({
+    status: "success",
+    result: {
+        type: "image",
+        id: content.aweme_id,
+        createTime: content.create_time,
+        desc: content.desc,
+        isTurnOffComment: content.item_comment_settings === 3,
+        hashtag: content.text_extra
+            .filter((x) => x.hashtag_name !== undefined)
+            .map((v) => v.hashtag_name),
+        isADS: content.is_ads,
+        author,
+        statistics,
+        images: content.image_post_info.images?.map((v) => v?.display_image?.url_list[0]) || [],
+        music
+    }
+});
+const createVideoResponse = (content, author, statistics, music) => ({
+    status: "success",
+    result: {
+        type: "video",
+        id: content.aweme_id,
+        createTime: content.create_time,
+        desc: content.desc,
+        isTurnOffComment: content.item_comment_settings === 3,
+        hashtag: content.text_extra
+            .filter((x) => x.hashtag_name !== undefined)
+            .map((v) => v.hashtag_name),
+        isADS: content.is_ads,
+        author,
+        statistics,
+        video: parseVideo(content),
+        music
+    }
+});
+const handleRedirect = async (url, proxy) => {
+    try {
+        const response = await (0, axios_1.default)(url, {
+            method: "HEAD",
+            maxRedirects: 5,
+            validateStatus: (status) => status >= 200 && status < 400,
+            ...createProxyAgent(proxy)
+        });
+        const finalUrl = response.request.res.responseUrl;
+        return finalUrl.split("?")[0];
+    }
+    catch (error) {
+        console.error("Error handling redirect:", error);
+        return url;
+    }
+};
+exports.handleRedirect = handleRedirect;
+const TiktokAPI = async (url, proxy, showOriginalResponse) => {
+    try {
+        if (!validateTikTokUrl(url)) {
+            return {
+                status: "error",
+                message: constants_1.ERROR_MESSAGES.INVALID_URL
+            };
+        }
+        url = url.replace("https://vm", "https://vt");
+        const request = await (0, axios_1.default)(url, {
+            method: "GET",
+            maxRedirects: 0,
+            headers: {
+                "User-Agent": USER_AGENT,
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.9",
+            },
+            ...createProxyAgent(proxy),
+            validateStatus: (status) => status >= 200 && status < 400,
+        });
+        const redirectUrl = request.headers.location ??
+            request.request?.res?.responseUrl ??
+            url;
+        const videoId = extractVideoId(redirectUrl);
+        if (!videoId) {
+            return {
+                status: "error",
+                message: constants_1.ERROR_MESSAGES.INVALID_URL
+            };
+        }
+        const data = await fetchTiktokData(videoId, proxy);
+        if (!data?.content) {
+            return {
+                status: "error",
+                message: constants_1.ERROR_MESSAGES.NETWORK_ERROR
+            };
+        }
+        const { content, author, statistics, music } = data;
+        const response = content.image_post_info
+            ? createImageResponse(content, author, statistics, music)
+            : createVideoResponse(content, author, statistics, music);
+        if (showOriginalResponse) {
+            return {
+                status: "success",
+                resultNotParsed: data
+            };
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            status: "error",
+            message: error instanceof Error ? error.message : constants_1.ERROR_MESSAGES.NETWORK_ERROR
+        };
+    }
+};
+exports.TiktokAPI = TiktokAPI;

package/lib/utils/get/getCollection.d.ts

@@ -0,0 +1,7 @@
+import { TiktokCollectionResponse } from "../../types/get/getCollection";
+export declare const getCollection: (collectionId: string, proxy?: string, page?: number, count?: number) => Promise<TiktokCollectionResponse>;
+export declare const Collection: (collectionIdOrUrl: string, options?: {
+    page?: number;
+    proxy?: string;
+    count?: number;
+}) => Promise<TiktokCollectionResponse>;

package/lib/utils/get/getCollection.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = exports.getCollection = void 0;
+const axios_1 = __importDefault(require("axios"));
+const api_1 = require("../../constants/api");
+const params_1 = require("../../constants/params");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const socks_proxy_agent_1 = require("socks-proxy-agent");
+const constants_1 = require("../../constants");
+const async_retry_1 = __importDefault(require("async-retry"));
+const tiktokAPIDownloader_1 = require("../downloader/tiktokAPIDownloader");
+const urlExtractors_1 = require("../urlExtractors");
+const createProxyAgent = (proxy) => {
+    if (!proxy)
+        return {};
+    if (proxy.startsWith("socks")) {
+        return {
+            httpsAgent: new socks_proxy_agent_1.SocksProxyAgent(proxy)
+        };
+    }
+    return {
+        httpsAgent: new https_proxy_agent_1.HttpsProxyAgent(proxy)
+    };
+};
+const getCollection = async (collectionId, proxy, page = 1, count = 5) => {
+    try {
+        const response = await (0, async_retry_1.default)(async () => {
+            const res = await (0, axios_1.default)((0, api_1._tiktokGetCollection)((0, params_1._getCollectionParams)(collectionId, page, count)), {
+                method: "GET",
+                headers: {
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+                    Accept: "*/*",
+                    "Accept-Language": "en-US,en;q=0.7",
+                    Referer: "https://www.tiktok.com/",
+                    Origin: "https://www.tiktok.com"
+                },
+                ...createProxyAgent(proxy)
+            });
+            if (res.data && res.data.statusCode === 0) {
+                return res.data;
+            }
+            throw new Error(constants_1.ERROR_MESSAGES.NETWORK_ERROR);
+        }, {
+            retries: 20,
+            minTimeout: 200,
+            maxTimeout: 1000
+        });
+        return {
+            status: "success",
+            result: {
+                hasMore: response.hasMore,
+                itemList: response.itemList || [],
+                extra: response.extra
+            }
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            message: error instanceof Error ? error.message : constants_1.ERROR_MESSAGES.NETWORK_ERROR
+        };
+    }
+};
+exports.getCollection = getCollection;
+const Collection = async (collectionIdOrUrl, options) => {
+    try {
+        const processedUrl = collectionIdOrUrl.startsWith("http")
+            ? await (0, tiktokAPIDownloader_1.handleRedirect)(collectionIdOrUrl, options?.proxy)
+            : collectionIdOrUrl;
+        const collectionId = (0, urlExtractors_1.extractCollectionId)(processedUrl);
+        if (!collectionId) {
+            return {
+                status: "error",
+                message: "Invalid collection ID or URL format"
+            };
+        }
+        const response = await (0, axios_1.default)((0, api_1._tiktokGetCollection)((0, params_1._getCollectionParams)(collectionId, options.page, options.count)), {
+            method: "GET",
+            headers: {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+                Accept: "*/*",
+                "Accept-Language": "en-US,en;q=0.7",
+                Referer: "https://www.tiktok.com/",
+                Origin: "https://www.tiktok.com"
+            },
+            ...createProxyAgent(options?.proxy)
+        });
+        if (response.data && response.data.status_code === 0) {
+            const data = response.data;
+            return {
+                status: "success",
+                result: {
+                    itemList: data.itemList || [],
+                    hasMore: data.hasMore
+                }
+            };
+        }
+        return {
+            status: "error",
+            message: constants_1.ERROR_MESSAGES.NETWORK_ERROR
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            message: error instanceof Error ? error.message : constants_1.ERROR_MESSAGES.NETWORK_ERROR
+        };
+    }
+};
+exports.Collection = Collection;

package/lib/utils/get/getComments.d.ts

@@ -0,0 +1,2 @@
+import { TiktokVideoCommentsResponse } from "../../types/get/getComments";
+export declare const getComments: (url: string, proxy?: string, commentLimit?: number) => Promise<TiktokVideoCommentsResponse>;

package/lib/utils/get/getComments.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComments = void 0;
+const axios_1 = __importDefault(require("axios"));
+const api_1 = require("../../constants/api");
+const params_1 = require("../../constants/params");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const socks_proxy_agent_1 = require("socks-proxy-agent");
+const TiktokURLregex = /https:\/\/(?:m|www|vm|vt|lite)?\.?tiktok\.com\/((?:.*\b(?:(?:usr|v|embed|user|video|photo)\/|\?shareId=|\&item_id=)(\d+))|\w+)/;
+const getComments = async (url, proxy, commentLimit) => new Promise(async (resolve) => {
+    if (!TiktokURLregex.test(url)) {
+        return resolve({
+            status: "error",
+            message: "Invalid Tiktok URL. Make sure your url is correct!"
+        });
+    }
+    url = url.replace("https://vm", "https://vt");
+    (0, axios_1.default)(url, {
+        method: "HEAD",
+        httpsAgent: (proxy &&
+            (proxy.startsWith("http") || proxy.startsWith("https")
+                ? new https_proxy_agent_1.HttpsProxyAgent(proxy)
+                : proxy.startsWith("socks")
+                    ? new socks_proxy_agent_1.SocksProxyAgent(proxy)
+                    : undefined)) ||
+            undefined
+    })
+        .then(async ({ request }) => {
+        const { responseUrl } = request.res;
+        let ID = responseUrl.match(/\d{17,21}/g);
+        if (ID === null)
+            return resolve({
+                status: "error",
+                message: "Failed to fetch tiktok url. Make sure your tiktok url is correct!"
+            });
+        ID = ID[0];
+        const resultComments = await parseComments(ID, commentLimit, proxy);
+        if (!resultComments.comments.length)
+            return resolve({
+                status: "error",
+                message: "No comments found!"
+            });
+        return resolve({
+            status: "success",
+            result: resultComments.comments,
+            totalComments: resultComments.total
+        });
+    })
+        .catch((e) => resolve({ status: "error", message: e.message }));
+});
+exports.getComments = getComments;
+const requestComments = async (id, cursor = 0, proxy) => {
+    const { data } = await (0, axios_1.default)((0, api_1._tiktokGetComments)((0, params_1._getCommentsParams)(id, cursor)), {
+        method: "GET",
+        headers: {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36"
+        },
+        httpsAgent: (proxy &&
+            (proxy.startsWith("http") || proxy.startsWith("https")
+                ? new https_proxy_agent_1.HttpsProxyAgent(proxy)
+                : proxy.startsWith("socks")
+                    ? new socks_proxy_agent_1.SocksProxyAgent(proxy)
+                    : undefined)) ||
+            undefined
+    });
+    return data;
+};
+const parseComments = async (id, commentLimit, proxy) => {
+    const comments = [];
+    let cursor = 0;
+    let total = 0;
+    let hasMore = true;
+    while (hasMore) {
+        const result = await requestComments(id, cursor, proxy);
+        hasMore = result.has_more === 1;
+        cursor = hasMore ? result.cursor : 0;
+        if (result.comments) {
+            result.comments.forEach((v) => {
+                const comment = {
+                    cid: v.cid,
+                    text: v.text,
+                    commentLanguage: v.comment_language,
+                    createTime: v.create_time,
+                    likeCount: v.digg_count,
+                    isAuthorLiked: v.is_author_digged,
+                    isCommentTranslatable: v.is_comment_translatable,
+                    replyCommentTotal: v.reply_comment_total,
+                    user: {
+                        uid: v.user.uid,
+                        avatarThumb: v.user.avatar_thumb.url_list,
+                        nickname: v.user.nickname,
+                        username: v.user.unique_id,
+                        isVerified: v.user.custom_verify !== ""
+                    },
+                    url: v.share_info?.url || "",
+                    replyComment: []
+                };
+                if (v.reply_comment !== null) {
+                    v.reply_comment.forEach((v) => {
+                        comment.replyComment.push({
+                            cid: v.cid,
+                            text: v.text,
+                            commentLanguage: v.comment_language,
+                            createTime: v.create_time,
+                            likeCount: v.digg_count,
+                            isAuthorLiked: v.is_author_digged,
+                            isCommentTranslatable: v.is_comment_translatable,
+                            replyCommentTotal: v.reply_comment_total,
+                            user: {
+                                uid: v.user.uid,
+                                avatarThumb: v.user.avatar_thumb.url_list,
+                                nickname: v.user.nickname,
+                                username: v.user.unique_id,
+                                isVerified: v.user.custom_verify !== ""
+                            },
+                            url: v.share_info?.url || "",
+                            replyComment: []
+                        });
+                        total++;
+                    });
+                }
+                total++;
+                comments.push(comment);
+            });
+        }
+        if (commentLimit && comments.length >= commentLimit) {
+            hasMore = false;
+            break;
+        }
+    }
+    const response = commentLimit ? comments.slice(0, commentLimit) : comments;
+    return {
+        total: response.length,
+        comments: response
+    };
+};

package/lib/utils/get/getMusicDetail.d.ts

@@ -0,0 +1,2 @@
+import { TiktokMusicDetailResponse } from "../../types/get/getMusicDetail";
+export declare const getMusicDetail: (musicIdOrUrl: string, cookie: string | any[], proxy?: string) => Promise<TiktokMusicDetailResponse>;