@nxgiang/tiktok-api 1.3.7

package/lib/utils/get/getMusicDetail.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMusicDetail = 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 tiktokService_1 = require("../../services/tiktokService");
+const headers_1 = require("../../constants/headers");
+const urlExtractors_1 = require("../urlExtractors");
+const getMusicDetail = (musicIdOrUrl, cookie, proxy) => new Promise(async (resolve) => {
+    try {
+        const musicId = (0, urlExtractors_1.extractMusicId)(musicIdOrUrl);
+        if (!musicId) {
+            return resolve({
+                status: "error",
+                message: "Invalid music ID or URL format"
+            });
+        }
+        const Tiktok = new tiktokService_1.TiktokService();
+        const params = (0, params_1._getMusicDetailParams)(musicId);
+        const xttparams = Tiktok.generateXTTParams(params);
+        const url = new URL((0, api_1._tiktokGetMusicDetail)());
+        url.search = params;
+        const config = {
+            headers: {
+                "User-Agent": headers_1.webUserAgent,
+                Cookie: Array.isArray(cookie) ? cookie.join("; ") : cookie,
+                "x-tt-params": xttparams
+            }
+        };
+        if (proxy) {
+            if (proxy.startsWith("http://") || proxy.startsWith("https://")) {
+                config.httpsAgent = new https_proxy_agent_1.HttpsProxyAgent(proxy);
+            }
+            else if (proxy.startsWith("socks://")) {
+                config.httpsAgent = new socks_proxy_agent_1.SocksProxyAgent(proxy);
+            }
+        }
+        const response = await axios_1.default.get(url.toString(), config);
+        if (response.data.statusCode === 0 && response.data.musicInfo) {
+            resolve({
+                status: "success",
+                result: {
+                    musicInfo: response.data.musicInfo,
+                    shareMeta: response.data.shareMeta
+                }
+            });
+        }
+        else {
+            resolve({
+                status: "error",
+                message: response.data.status_msg || "Music not found or invalid response"
+            });
+        }
+    }
+    catch (err) {
+        resolve({
+            status: "error",
+            message: err.message || "Failed to fetch music detail"
+        });
+    }
+});
+exports.getMusicDetail = getMusicDetail;

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

@@ -0,0 +1,2 @@
+import { TiktokMusicVideosResponse } from "../../types/get/getMusicVideos";
+export declare const getMusicVideos: (musicIdOrUrl: string, proxy?: string, page?: number, count?: number) => Promise<TiktokMusicVideosResponse>;

package/lib/utils/get/getMusicVideos.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMusicVideos = 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 tiktokService_1 = require("../../services/tiktokService");
+const async_retry_1 = __importDefault(require("async-retry"));
+const urlExtractors_1 = require("../urlExtractors");
+const getMusicVideos = (musicIdOrUrl, proxy, page, count) => new Promise(async (resolve) => {
+    try {
+        const musicId = (0, urlExtractors_1.extractMusicId)(musicIdOrUrl);
+        if (!musicId) {
+            return resolve({
+                status: "error",
+                message: "Invalid music ID or URL format"
+            });
+        }
+        const data = await parseMusicVideos(musicId, page || 1, count || 30, proxy);
+        if (!data.videos || data.videos.length === 0) {
+            return resolve({
+                status: "error",
+                message: "No videos found for this music ID!"
+            });
+        }
+        resolve({
+            status: "success",
+            result: data
+        });
+    }
+    catch (err) {
+        if (err.status === 400 ||
+            (err.response?.data && err.response.data.statusCode === 10201)) {
+            return resolve({
+                status: "error",
+                message: "Music not found!"
+            });
+        }
+        return resolve({
+            status: "error",
+            message: err.message || "Failed to fetch music videos"
+        });
+    }
+});
+exports.getMusicVideos = getMusicVideos;
+const parseMusicVideos = async (musicId, page, count, proxy) => {
+    let cursor = 0;
+    if (page > 1) {
+        cursor = (page - 1) * count;
+    }
+    const videos = [];
+    let musicInfo;
+    const Tiktok = new tiktokService_1.TiktokService();
+    const params = (0, params_1._getMusicVideosParams)(musicId, cursor, count);
+    const xttParams = Tiktok.generateXTTParams(params);
+    const result = await requestMusicVideos(proxy, xttParams);
+    if (!result) {
+        return {
+            music: undefined,
+            videos: [],
+            hasMore: false,
+            cursor: 0,
+            totalVideos: 0
+        };
+    }
+    if (result.musicInfo || result.music) {
+        musicInfo = extractMusicInfo(result.musicInfo || result.music);
+    }
+    else if (result.itemList?.length > 0 && result.itemList[0].music) {
+        musicInfo = extractMusicInfoFromVideo(result.itemList[0].music);
+    }
+    if (result.itemList && result.itemList.length > 0) {
+        result.itemList.forEach((item) => {
+            const video = extractVideoData(item);
+            if (video) {
+                videos.push(video);
+            }
+        });
+    }
+    const hasMore = result.hasMore || false;
+    const nextCursor = result.cursor || cursor + videos.length;
+    return {
+        music: musicInfo,
+        videos,
+        hasMore,
+        cursor: nextCursor,
+        totalVideos: videos.length
+    };
+};
+const extractMusicInfo = (musicData) => {
+    return {
+        id: musicData.id || musicData.musicId,
+        title: musicData.title || "Unknown",
+        authorName: musicData.authorName || musicData.author || "Unknown",
+        author: musicData.author,
+        duration: musicData.duration,
+        original: musicData.original,
+        playUrl: musicData.playUrl,
+        coverThumb: musicData.coverThumb,
+        coverLarge: musicData.coverLarge,
+        coverMedium: musicData.coverMedium
+    };
+};
+const extractMusicInfoFromVideo = (musicData) => {
+    return {
+        id: musicData.id,
+        title: musicData.title,
+        authorName: musicData.authorName,
+        duration: musicData.duration,
+        original: musicData.original,
+        playUrl: musicData.playUrl,
+        coverThumb: musicData.coverThumb,
+        coverLarge: musicData.coverLarge,
+        coverMedium: musicData.coverMedium
+    };
+};
+const extractVideoData = (item) => {
+    if (!item || !item.id) {
+        return null;
+    }
+    const author = {
+        id: item.author?.id || "",
+        uniqueId: item.author?.uniqueId || "",
+        nickname: item.author?.nickname || "",
+        avatarLarger: item.author?.avatarLarger,
+        avatarThumb: item.author?.avatarThumb,
+        avatarMedium: item.author?.avatarMedium,
+        signature: item.author?.signature,
+        verified: item.author?.verified || false,
+        openFavorite: item.author?.openFavorite,
+        privateAccount: item.author?.privateAccount,
+        isADVirtual: item.author?.isADVirtual,
+        isEmbedBanned: item.author?.isEmbedBanned
+    };
+    const stats = {
+        collectCount: item.stats?.collectCount,
+        commentCount: item.stats?.commentCount || 0,
+        diggCount: item.stats?.diggCount || item.stats?.likeCount || 0,
+        playCount: item.stats?.playCount || 0,
+        shareCount: item.stats?.shareCount || 0
+    };
+    const music = {
+        id: item.music?.id || "",
+        title: item.music?.title || "",
+        authorName: item.music?.authorName || "",
+        duration: item.music?.duration || 0,
+        playUrl: item.music?.playUrl,
+        coverLarge: item.music?.coverLarge,
+        coverMedium: item.music?.coverMedium,
+        coverThumb: item.music?.coverThumb,
+        original: item.music?.original
+    };
+    const video = {
+        id: item.id,
+        desc: item.desc,
+        createTime: item.createTime,
+        digged: item.digged,
+        duetEnabled: item.duetEnabled,
+        forFriend: item.forFriend,
+        officalItem: item.officalItem,
+        originalItem: item.originalItem,
+        privateItem: item.privateItem,
+        shareEnabled: item.shareEnabled,
+        stitchEnabled: item.stitchEnabled,
+        stats,
+        author,
+        music
+    };
+    if (item.video) {
+        const videoDetails = {
+            id: item.video.id,
+            duration: item.video.duration,
+            ratio: item.video.ratio,
+            cover: item.video.cover,
+            originCover: item.video.originCover,
+            dynamicCover: item.video.dynamicCover,
+            playAddr: item.video.playAddr,
+            downloadAddr: item.video.downloadAddr,
+            format: item.video.format,
+            bitrate: item.video.bitrate
+        };
+        video.video = videoDetails;
+    }
+    if (item.imagePost?.images) {
+        video.imagePost = item.imagePost.images.map((img) => img.imageURL?.urlList?.[0] || img.imageURL);
+    }
+    if (item.effectStickers && Array.isArray(item.effectStickers)) {
+        video.effectStickers = item.effectStickers.map((effect) => ({
+            id: effect.id || "",
+            name: effect.name || "",
+            type: effect.type
+        }));
+    }
+    return video;
+};
+const requestMusicVideos = async (proxy, xttParams = "") => {
+    return (0, async_retry_1.default)(async (bail, attempt) => {
+        try {
+            const params = (0, params_1._getMusicVideosParams)("", 0, 30);
+            const { data } = await axios_1.default.get(`${(0, api_1._tiktokGetMusic)(params)}`, {
+                headers: {
+                    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36 Edg/101.0.1210.53",
+                    "x-tt-params": xttParams,
+                    referer: "https://www.tiktok.com/",
+                    accept: "application/json, text/plain, */*",
+                    "accept-language": "en-US,en;q=0.9",
+                    "cache-control": "no-cache",
+                    pragma: "no-cache",
+                    "sec-fetch-dest": "empty",
+                    "sec-fetch-mode": "cors",
+                    "sec-fetch-site": "same-origin"
+                },
+                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
+            });
+            if (data === "" || !data) {
+                throw new Error("Empty response");
+            }
+            return data;
+        }
+        catch (error) {
+            if (error.response?.status === 400 ||
+                error.response?.status === 404 ||
+                error.response?.data?.statusCode === 10201) {
+                bail(new Error("Music not found or access forbidden!"));
+                return;
+            }
+            throw error;
+        }
+    }, {
+        retries: 10,
+        minTimeout: 1000,
+        maxTimeout: 5000,
+        factor: 2,
+        onRetry: (error, attempt) => {
+            console.log(`Retry attempt ${attempt} due to: ${error}`);
+        }
+    });
+};

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

@@ -0,0 +1,7 @@
+import { TiktokPlaylistResponse } from "../../types/get/getPlaylist";
+export declare const getPlaylist: (playlistId: string, proxy?: string, page?: number, count?: number) => Promise<TiktokPlaylistResponse>;
+export declare const Playlist: (url: string, options?: {
+    page?: number;
+    proxy?: string;
+    count?: number;
+}) => Promise<TiktokPlaylistResponse>;

package/lib/utils/get/getPlaylist.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Playlist = exports.getPlaylist = 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 getPlaylist = async (playlistId, 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._tiktokGetPlaylist)((0, params_1._getPlaylistParams)(playlistId, page, count)), {
+                method: "GET",
+                headers: {
+                    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:138.0) Gecko/20100101 Firefox/138.0",
+                    Accept: "*/*",
+                    "Accept-Language": "en-US,en;q=0.7",
+                    Referer: "https://www.tiktok.com/",
+                    Origin: "https://www.tiktok.com",
+                    "Content-Type": "application/json"
+                },
+                ...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.getPlaylist = getPlaylist;
+const Playlist = async (url, options) => {
+    try {
+        const processedUrl = url.startsWith("http")
+            ? await (0, tiktokAPIDownloader_1.handleRedirect)(url, options?.proxy)
+            : url;
+        const playlistId = (0, urlExtractors_1.extractPlaylistId)(processedUrl);
+        if (!playlistId) {
+            return {
+                status: "error",
+                message: "Invalid playlist ID or URL format"
+            };
+        }
+        const response = await (0, axios_1.default)((0, api_1._tiktokGetPlaylist)((0, params_1._getPlaylistParams)(playlistId, options.page, options.count)), {
+            method: "GET",
+            headers: {
+                "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:138.0) Gecko/20100101 Firefox/138.0",
+                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,
+                    extra: data.extra
+                }
+            };
+        }
+        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.Playlist = Playlist;

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

@@ -0,0 +1,2 @@
+import { TiktokStalkUserResponse } from "../../types/get/getProfile";
+export declare const StalkUser: (username: string, proxy?: string) => Promise<TiktokStalkUserResponse>;

package/lib/utils/get/getProfile.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StalkUser = void 0;
+const axios_1 = __importDefault(require("axios"));
+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 StalkUser = (username, proxy) => new Promise(async (resolve) => {
+    username = username.replace("@", "");
+    (0, axios_1.default)(`${api_1._tiktokDesktopUrl}/@${username}`, {
+        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
+    })
+        .then(async ({ data }) => {
+        const $ = (0, cheerio_1.load)(data);
+        const result = JSON.parse($("script#__UNIVERSAL_DATA_FOR_REHYDRATION__").text());
+        if (!result["__DEFAULT_SCOPE__"] &&
+            !result["__DEFAULT_SCOPE__"]["webapp.user-detail"]) {
+            return resolve({
+                status: "error",
+                message: "User not found!"
+            });
+        }
+        const dataUser = result["__DEFAULT_SCOPE__"]["webapp.user-detail"]["userInfo"];
+        if (!dataUser) {
+            return resolve({
+                status: "error",
+                message: "User not found!"
+            });
+        }
+        const { user, stats, statsV2 } = parseDataUser(dataUser);
+        let response = {
+            status: "success",
+            result: {
+                user,
+                stats,
+                statsV2
+            }
+        };
+        resolve(response);
+    })
+        .catch((e) => resolve({ status: "error", message: e.message }));
+});
+exports.StalkUser = StalkUser;
+const parseDataUser = (dataUser) => {
+    const user = {
+        uid: dataUser.user.id,
+        username: dataUser.user.uniqueId,
+        nickname: dataUser.user.nickname,
+        avatarLarger: dataUser.user.avatarLarger,
+        avatarThumb: dataUser.user.avatarThumb,
+        avatarMedium: dataUser.user.avatarMedium,
+        signature: dataUser.user.signature,
+        verified: dataUser.user.verified,
+        privateAccount: dataUser.user.privateAccount,
+        region: dataUser.user.region,
+        commerceUser: dataUser.user.commerceUserInfo.commerceUser,
+        usernameModifyTime: dataUser.user.uniqueIdModifyTime,
+        nicknameModifyTime: dataUser.user.nickNameModifyTime,
+        secUid: dataUser.user.secUid
+    };
+    const stats = {
+        followerCount: dataUser.stats.followerCount,
+        followingCount: dataUser.stats.followingCount,
+        heartCount: dataUser.stats.heartCount,
+        videoCount: dataUser.stats.videoCount,
+        likeCount: dataUser.stats.diggCount,
+        friendCount: dataUser.stats.friendCount
+    };
+    const statsV2 = {
+        followerCount: dataUser.statsV2.followerCount,
+        followingCount: dataUser.statsV2.followingCount,
+        heartCount: dataUser.statsV2.heartCount,
+        videoCount: dataUser.statsV2.videoCount,
+        likeCount: dataUser.statsV2.diggCount,
+        friendCount: dataUser.statsV2.friendCount
+    };
+    return { user, stats, statsV2 };
+};

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

@@ -0,0 +1,7 @@
+import { TiktokTrendingResponse, TrendingCreator } from "../../types/get/getTrendings";
+export declare const getTrendings: (proxy?: string) => Promise<TiktokTrendingResponse>;
+export declare const getTrendingCreators: (proxy?: string) => Promise<{
+    status: "success" | "error";
+    message?: string;
+    result?: TrendingCreator[];
+}>;

package/lib/utils/get/getTrendings.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrendingCreators = exports.getTrendings = 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 getTrendings = (proxy) => new Promise(async (resolve) => {
+    try {
+        const params = (0, params_1._getTrendingsParams)();
+        const url = (0, api_1._tiktokTrendings)(params);
+        const response = await axios_1.default.get(url, {
+            headers: {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0",
+                Accept: "application/json, text/plain, */*",
+                "Accept-Language": "en-US,en;q=0.9",
+                "Accept-Encoding": "gzip, deflate, br",
+                Connection: "keep-alive",
+                "Sec-Fetch-Dest": "empty",
+                "Sec-Fetch-Mode": "cors",
+                "Sec-Fetch-Site": "same-origin"
+            },
+            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
+        });
+        if (response.status !== 200) {
+            return resolve({
+                status: "error",
+                message: "Failed to fetch trending data"
+            });
+        }
+        const data = response.data;
+        if (!data || !data.body || data.statusCode !== 0) {
+            return resolve({
+                status: "error",
+                message: "Invalid response from TikTok API"
+            });
+        }
+        const trendingData = parseTrendingData(data.body);
+        resolve({
+            status: "success",
+            result: trendingData
+        });
+    }
+    catch (error) {
+        resolve({
+            status: "error",
+            message: error.message || "Unknown error occurred"
+        });
+    }
+});
+exports.getTrendings = getTrendings;
+const parseTrendingData = (body) => {
+    const trendingData = [];
+    body.forEach((section) => {
+        if (section.exploreList && Array.isArray(section.exploreList)) {
+            trendingData.push({
+                exploreList: section.exploreList,
+                pageState: section.pageState || {}
+            });
+        }
+    });
+    return trendingData;
+};
+const getTrendingCreators = async (proxy) => {
+    try {
+        const trendingResponse = await (0, exports.getTrendings)(proxy);
+        if (trendingResponse.status === "error") {
+            return {
+                status: "error",
+                message: trendingResponse.message
+            };
+        }
+        const creators = [];
+        trendingResponse.result?.forEach((data) => {
+            data.exploreList.forEach((item) => {
+                if (item.cardItem && item.cardItem.type === 2) {
+                    const cardItem = item.cardItem;
+                    const creator = {
+                        id: cardItem.id,
+                        username: cardItem.subTitle.replace("@", ""),
+                        nickname: cardItem.title,
+                        avatarThumb: cardItem.cover,
+                        description: cardItem.description,
+                        verified: cardItem.extraInfo?.verified || false,
+                        followerCount: cardItem.extraInfo?.fans || 0,
+                        likeCount: cardItem.extraInfo?.likes || 0,
+                        videoCount: cardItem.extraInfo?.video || 0,
+                        followingCount: cardItem.extraInfo?.following || 0,
+                        heartCount: cardItem.extraInfo?.heart || 0,
+                        diggCount: cardItem.extraInfo?.digg || 0,
+                        secUid: cardItem.extraInfo?.secUid || "",
+                        link: cardItem.link
+                    };
+                    creators.push(creator);
+                }
+            });
+        });
+        return {
+            status: "success",
+            result: creators
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            message: error.message || "Unknown error occurred"
+        };
+    }
+};
+exports.getTrendingCreators = getTrendingCreators;

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

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