@nxgiang/tiktok-api 1.3.7

package/lib/utils/get/getUserLiked.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserLiked = void 0;
+const axios_1 = __importDefault(require("axios"));
+const api_1 = require("../../constants/api");
+const getProfile_1 = require("./getProfile");
+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 getUserLiked = (username, cookie, proxy, postLimit) => new Promise((resolve) => {
+    if (!cookie) {
+        return {
+            status: "error",
+            message: "Cookie is required!"
+        };
+    }
+    (0, getProfile_1.StalkUser)(username).then(async (res) => {
+        if (res.status === "error") {
+            return resolve({
+                status: "error",
+                message: res.message
+            });
+        }
+        const id = res.result.user.uid;
+        const secUid = res.result.user.secUid;
+        const data = await parseUserLiked(id, secUid, cookie, postLimit, proxy);
+        if (!data.length)
+            return resolve({
+                status: "error",
+                message: "User not found!"
+            });
+        resolve({
+            status: "success",
+            result: data,
+            totalPosts: data.length
+        });
+    });
+});
+exports.getUserLiked = getUserLiked;
+const parseUserLiked = async (id, secUid, cookie, postLimit, proxy) => {
+    let hasMore = true;
+    const favorites = [];
+    let counter = 0;
+    while (hasMore) {
+        let result = null;
+        result = await requestUserLiked(id, secUid, cookie, postLimit, proxy);
+        result?.itemList?.forEach((v) => {
+            const statsAuthor = {
+                likeCount: v.authorStats.diggCount,
+                followerCount: v.authorStats.followerCount,
+                followingCount: v.authorStats.followingCount,
+                friendCount: v.authorStats.friendCount,
+                heartCount: v.authorStats.heartCount,
+                postsCount: v.authorStats.videoCount
+            };
+            const author = {
+                id: v.author.id,
+                username: v.author.uniqueId,
+                nickname: v.author.nickname,
+                avatarLarger: v.author.avatarLarger,
+                avatarThumb: v.author.avatarThumb,
+                avatarMedium: v.author.avatarMedium,
+                signature: v.author.signature,
+                verified: v.author.verified,
+                openFavorite: v.author.openFavorite,
+                privateAccount: v.author.privateAccount,
+                isADVirtual: v.author.isADVirtual,
+                isEmbedBanned: v.author.isEmbedBanned,
+                stats: statsAuthor
+            };
+            const stats = {
+                collectCount: v.statsV2.collectCount,
+                commentCount: v.statsV2.commentCount,
+                diggCount: v.statsV2.diggCount,
+                playCount: v.statsV2.playCount,
+                repostCount: v.statsV2.repostCount,
+                shareCount: v.statsV2.shareCount
+            };
+            const music = {
+                id: v.music.id,
+                title: v.music.title,
+                playUrl: v.music.playUrl,
+                coverThumb: v.music.coverThumb,
+                coverMedium: v.music.coverMedium,
+                coverLarge: v.music.coverLarge,
+                authorName: v.music.authorName,
+                original: v.music.original,
+                album: v.music.album,
+                duration: v.music.duration,
+                isCopyrighted: v.music.isCopyrighted,
+                private: v.music.private
+            };
+            const response = {
+                id: v.id,
+                desc: v.desc,
+                createTime: v.createTime,
+                duetEnabled: v.duetEnabled || false,
+                digged: v.digged || false,
+                forFriend: v.forFriend || false,
+                isAd: v.isAd || false,
+                originalItem: v.originalItem || false,
+                privateItem: v.privateItem || false,
+                officialItem: v.officialItem || false,
+                secret: v.secret || false,
+                shareEnabled: v.shareEnabled || false,
+                stitchEanbled: v.stitchEanbled || false,
+                textTranslatable: v.textTranslatable || false
+            };
+            if (v.imagePost) {
+                const imagePost = [];
+                v.imagePost.images.forEach((image) => {
+                    imagePost.push({
+                        title: image.title,
+                        images: image.imageURL.urlList[0]
+                    });
+                });
+                favorites.push({
+                    ...response,
+                    author,
+                    stats,
+                    imagePost,
+                    music
+                });
+            }
+            else {
+                const video = {
+                    id: v.video.id,
+                    videoID: v.video.id,
+                    duration: v.video.duration,
+                    ratio: v.video.ratio,
+                    cover: v.video.cover,
+                    originCover: v.video.originCover,
+                    dynamicCover: v.video.dynamicCover,
+                    playAddr: v.video.playAddr,
+                    downloadAddr: v.video.downloadAddr,
+                    format: v.video.format,
+                    bitrate: v.video.bitrate,
+                    bitrateInfo: v.video.bitrateInfo
+                };
+                favorites.push({
+                    ...response,
+                    author,
+                    stats,
+                    video,
+                    music
+                });
+            }
+        });
+        hasMore = result.hasMore;
+        counter++;
+        if (postLimit && favorites.length >= postLimit) {
+            hasMore = false;
+            break;
+        }
+    }
+    return postLimit ? favorites.slice(0, postLimit) : favorites;
+};
+const requestUserLiked = async (id, secUid, cookie, postLimit, proxy) => {
+    const Tiktok = new tiktokService_1.TiktokService();
+    const url = new URL((0, api_1._tiktokGetUserLiked)((0, params_1._getUserLikedParams)(id, secUid, postLimit)));
+    const signature = Tiktok.generateSignature(url);
+    url.searchParams.append("_signature", signature);
+    const xbogus = Tiktok.generateXBogus(url, signature);
+    url.searchParams.append("X-Bogus", xbogus);
+    const xttparams = Tiktok.generateXTTParams(url.searchParams.toString());
+    return await (0, async_retry_1.default)(async (bail, attempt) => {
+        try {
+            const { data } = await axios_1.default.get(url.toString(), {
+                headers: {
+                    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 Edg/107.0.1418.35",
+                    cookie: Array.isArray(cookie) ? cookie.join("; ") : cookie,
+                    "x-tt-params": xttparams
+                },
+                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 === "") {
+                throw new Error("Empty response");
+            }
+            return data;
+        }
+        catch (error) {
+            if (attempt === 3) {
+                bail(error);
+            }
+            throw error;
+        }
+    }, {
+        retries: 10,
+        minTimeout: 1000,
+        maxTimeout: 5000,
+        factor: 2
+    });
+};

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

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

package/lib/utils/get/getUserPosts.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserPosts = 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 getProfile_1 = require("../get/getProfile");
+const async_retry_1 = __importDefault(require("async-retry"));
+const getUserPosts = (username, proxy, postLimit) => new Promise((resolve) => {
+    try {
+        (0, getProfile_1.StalkUser)(username).then(async (res) => {
+            if (res.status === "error") {
+                return resolve({
+                    status: "error",
+                    message: res.message
+                });
+            }
+            const secUid = res.result.user.secUid;
+            const data = await parseUserPosts(secUid, postLimit, proxy);
+            if (!data.length)
+                return resolve({
+                    status: "error",
+                    message: "User not found!"
+                });
+            resolve({
+                status: "success",
+                result: data,
+                totalPosts: data.length
+            });
+        });
+    }
+    catch (err) {
+        if (err.status == 400 ||
+            (err.response.data && err.response.data.statusCode == 10201)) {
+            return resolve({
+                status: "error",
+                message: "Video not found!"
+            });
+        }
+    }
+});
+exports.getUserPosts = getUserPosts;
+const parseUserPosts = async (secUid, postLimit, proxy) => {
+    let page = 1;
+    let hasMore = true;
+    let responseCursor = 0;
+    const posts = [];
+    let counter = 0;
+    const Tiktok = new tiktokService_1.TiktokService();
+    while (hasMore) {
+        let result = null;
+        let xttparams = "";
+        let urlCursor = 0;
+        let urlCount = 0;
+        if (page === 1) {
+            urlCount = 0;
+            urlCursor = 0;
+            xttparams = Tiktok.generateXTTParams((0, params_1._xttParams)(secUid, 0, 35));
+        }
+        else if (page === 2) {
+            urlCount = 35;
+            urlCursor = 0;
+            xttparams = Tiktok.generateXTTParams((0, params_1._xttParams)(secUid, 0, 30));
+        }
+        else if (page === 3) {
+            urlCount = 30;
+            urlCursor = 0;
+            xttparams = Tiktok.generateXTTParams((0, params_1._xttParams)(secUid, responseCursor, 16));
+        }
+        else {
+            urlCount = 16;
+            urlCursor = responseCursor;
+            xttparams = Tiktok.generateXTTParams((0, params_1._xttParams)(secUid, responseCursor, 16));
+        }
+        result = await requestUserPosts(proxy, xttparams);
+        result?.itemList?.forEach((v) => {
+            const author = {
+                id: v.author.id,
+                username: v.author.uniqueId,
+                nickname: v.author.nickname,
+                avatarLarger: v.author.avatarLarger,
+                avatarThumb: v.author.avatarThumb,
+                avatarMedium: v.author.avatarMedium,
+                signature: v.author.signature,
+                verified: v.author.verified,
+                openFavorite: v.author.openFavorite,
+                privateAccount: v.author.privateAccount,
+                isADVirtual: v.author.isADVirtual,
+                isEmbedBanned: v.author.isEmbedBanned
+            };
+            if (v.imagePost) {
+                const imagePost = v.imagePost.images.map((img) => img.imageURL.urlList[0]);
+                posts.push({
+                    id: v.id,
+                    desc: v.desc,
+                    createTime: v.createTime,
+                    digged: v.digged,
+                    duetEnabled: v.duetEnabled,
+                    forFriend: v.forFriend,
+                    officalItem: v.officalItem,
+                    originalItem: v.originalItem,
+                    privateItem: v.privateItem,
+                    shareEnabled: v.shareEnabled,
+                    stitchEnabled: v.stitchEnabled,
+                    stats: v.stats,
+                    music: v.music,
+                    author,
+                    imagePost
+                });
+            }
+            else {
+                const video = {
+                    id: v.video.id,
+                    duration: v.video.duration,
+                    format: v.video.format,
+                    bitrate: v.video.bitrate,
+                    ratio: v.video.ratio,
+                    playAddr: v.video.playAddr,
+                    cover: v.video.cover,
+                    originCover: v.video.originCover,
+                    dynamicCover: v.video.dynamicCover,
+                    downloadAddr: v.video.downloadAddr
+                };
+                posts.push({
+                    id: v.id,
+                    desc: v.desc,
+                    createTime: v.createTime,
+                    digged: v.digged,
+                    duetEnabled: v.duetEnabled,
+                    forFriend: v.forFriend,
+                    officalItem: v.officalItem,
+                    originalItem: v.originalItem,
+                    privateItem: v.privateItem,
+                    shareEnabled: v.shareEnabled,
+                    stitchEnabled: v.stitchEnabled,
+                    stats: v.stats,
+                    music: v.music,
+                    author,
+                    video
+                });
+            }
+        });
+        hasMore = result.hasMore;
+        responseCursor = hasMore ? result.cursor : 0;
+        page++;
+        counter++;
+        if (postLimit && posts.length >= postLimit) {
+            hasMore = false;
+            break;
+        }
+    }
+    return postLimit ? posts.slice(0, postLimit) : posts;
+};
+const requestUserPosts = async (proxy, xttparams = "") => {
+    return (0, async_retry_1.default)(async (bail, attempt) => {
+        try {
+            let urlParams = (0, params_1._getUserPostsParams)();
+            const { data } = await axios_1.default.get(`${(0, api_1._tiktokGetPosts)(urlParams)}`, {
+                headers: {
+                    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 Edg/107.0.1418.35",
+                    "x-tt-params": xttparams
+                },
+                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 === "") {
+                throw new Error("Empty response");
+            }
+            return data;
+        }
+        catch (error) {
+            if (error.response?.status === 400 ||
+                error.response?.data?.statusCode === 10201) {
+                bail(new Error("Video not found!"));
+                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/getUserRepost.d.ts

@@ -0,0 +1,2 @@
+import { TiktokUserRepostsResponse } from "../../types/get/getUserReposts";
+export declare const getUserReposts: (username: string, proxy?: string, postLimit?: number, filterDeletedPost?: boolean) => Promise<TiktokUserRepostsResponse>;

package/lib/utils/get/getUserRepost.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserReposts = 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 getProfile_1 = require("../get/getProfile");
+const async_retry_1 = __importDefault(require("async-retry"));
+const getUserReposts = (username, proxy, postLimit, filterDeletedPost = true) => new Promise((resolve) => {
+    try {
+        (0, getProfile_1.StalkUser)(username).then(async (res) => {
+            if (res.status === "error") {
+                return resolve({
+                    status: "error",
+                    message: res.message
+                });
+            }
+            const secUid = res.result.user.secUid;
+            const data = await parseUserReposts(secUid, postLimit, proxy, filterDeletedPost);
+            if (!data.length)
+                return resolve({
+                    status: "error",
+                    message: "User not found!"
+                });
+            resolve({
+                status: "success",
+                result: data,
+                totalReposts: data.length
+            });
+        });
+    }
+    catch (err) {
+        if (err.status == 400 ||
+            (err.response.data && err.response.data.statusCode == 10201)) {
+            return resolve({
+                status: "error",
+                message: "Video not found!"
+            });
+        }
+    }
+});
+exports.getUserReposts = getUserReposts;
+const parseUserReposts = async (secUid, postLimit, proxy, filterDeletedPost) => {
+    let page = 1;
+    let hasMore = true;
+    let responseCursor = 0;
+    const posts = [];
+    let counter = 0;
+    while (hasMore) {
+        let result = null;
+        let urlCursor = 0;
+        let urlCount = 0;
+        if (page === 1) {
+            urlCount = 16;
+            urlCursor = 0;
+        }
+        else {
+            urlCount = 16;
+            urlCursor = responseCursor;
+        }
+        result = await requestUserReposts(proxy, secUid, urlCursor, urlCount);
+        if (!result || !result.itemList || result.itemList.length === 0) {
+            hasMore = false;
+            break;
+        }
+        if (filterDeletedPost) {
+            result.itemList = result.itemList.filter((item) => item.createTime !== 0);
+        }
+        result?.itemList?.forEach((v) => {
+            const author = {
+                id: v.author?.id,
+                username: v.author?.uniqueId,
+                nickname: v.author?.nickname,
+                avatarLarger: v.author?.avatarLarger,
+                avatarThumb: v.author?.avatarThumb,
+                avatarMedium: v.author?.avatarMedium,
+                signature: v.author?.signature,
+                verified: v.author?.verified,
+                openFavorite: v.author?.openFavorite,
+                privateAccount: v.author?.privateAccount,
+                isADVirtual: v.author?.isADVirtual,
+                isEmbedBanned: v.author?.isEmbedBanned
+            };
+            if (v.imagePost) {
+                const imagePost = {
+                    title: v.imagePost.title || "",
+                    images: v.imagePost.images?.map((img) => ({
+                        imageURL: {
+                            urlList: img.imageURL?.urlList || []
+                        }
+                    })) || []
+                };
+                posts.push({
+                    id: v.id,
+                    desc: v.desc,
+                    createTime: v.createTime,
+                    digged: v.digged || false,
+                    duetEnabled: v.duetEnabled,
+                    forFriend: v.forFriend || false,
+                    officalItem: v.officalItem || false,
+                    originalItem: v.originalItem || false,
+                    privateItem: v.privateItem || false,
+                    secret: v.secret || false,
+                    shareEnabled: v.shareEnabled || false,
+                    stitchEnabled: v.stitchEnabled,
+                    stats: v.stats || { shareCount: 0 },
+                    music: v.music || {},
+                    author,
+                    imagePost,
+                    AIGCDescription: v.AIGCDescription,
+                    CategoryType: v.CategoryType,
+                    collected: v.collected,
+                    contents: v.contents || [],
+                    challenges: v.challenges || [],
+                    textExtra: v.textExtra || [],
+                    textLanguage: v.textLanguage,
+                    textTranslatable: v.textTranslatable,
+                    titleLanguage: v.titleLanguage,
+                    titleTranslatable: v.titleTranslatable,
+                    isAd: v.isAd,
+                    isReviewing: v.isReviewing,
+                    itemCommentStatus: v.itemCommentStatus,
+                    item_control: v.item_control,
+                    duetDisplay: v.duetDisplay,
+                    stitchDisplay: v.stitchDisplay,
+                    diversificationId: v.diversificationId,
+                    backendSourceEventTracking: v.backendSourceEventTracking,
+                    stickersOnItem: v.stickersOnItem || [],
+                    videoSuggestWordsList: v.videoSuggestWordsList
+                });
+            }
+            else {
+                const video = {
+                    id: v.video?.id,
+                    duration: v.video?.duration,
+                    format: v.video?.format,
+                    bitrate: v.video?.bitrate,
+                    ratio: v.video?.ratio,
+                    playAddr: v.video?.playAddr,
+                    cover: v.video?.cover,
+                    originCover: v.video?.originCover,
+                    dynamicCover: v.video?.dynamicCover,
+                    downloadAddr: v.video?.downloadAddr
+                };
+                posts.push({
+                    id: v.id,
+                    desc: v.desc,
+                    createTime: v.createTime,
+                    digged: v.digged || false,
+                    duetEnabled: v.duetEnabled,
+                    forFriend: v.forFriend || false,
+                    officalItem: v.officalItem || false,
+                    originalItem: v.originalItem || false,
+                    privateItem: v.privateItem || false,
+                    secret: v.secret || false,
+                    shareEnabled: v.shareEnabled || false,
+                    stitchEnabled: v.stitchEnabled,
+                    stats: v.stats || { shareCount: 0 },
+                    music: v.music || {},
+                    author,
+                    video,
+                    AIGCDescription: v.AIGCDescription,
+                    CategoryType: v.CategoryType,
+                    collected: v.collected,
+                    contents: v.contents || [],
+                    challenges: v.challenges || [],
+                    textExtra: v.textExtra || [],
+                    textLanguage: v.textLanguage,
+                    textTranslatable: v.textTranslatable,
+                    titleLanguage: v.titleLanguage,
+                    titleTranslatable: v.titleTranslatable,
+                    isAd: v.isAd,
+                    isReviewing: v.isReviewing,
+                    itemCommentStatus: v.itemCommentStatus,
+                    item_control: v.item_control,
+                    duetDisplay: v.duetDisplay,
+                    stitchDisplay: v.stitchDisplay,
+                    diversificationId: v.diversificationId,
+                    backendSourceEventTracking: v.backendSourceEventTracking,
+                    stickersOnItem: v.stickersOnItem || [],
+                    videoSuggestWordsList: v.videoSuggestWordsList
+                });
+            }
+        });
+        hasMore = result.hasMore;
+        responseCursor = hasMore ? result.cursor : 0;
+        page++;
+        counter++;
+        if (postLimit && posts.length >= postLimit) {
+            hasMore = false;
+            break;
+        }
+    }
+    return postLimit ? posts.slice(0, postLimit) : posts;
+};
+const requestUserReposts = async (proxy, secUid = "", cursor = 0, count = 0) => {
+    return (0, async_retry_1.default)(async (bail, attempt) => {
+        try {
+            let urlParams = (0, params_1._getUserRepostsParams)(secUid, cursor, count);
+            const { data } = await axios_1.default.get(`${(0, api_1._tiktokGetReposts)(urlParams)}`, {
+                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"
+                },
+                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 === "") {
+                throw new Error("Empty response");
+            }
+            return data;
+        }
+        catch (error) {
+            if (error.response?.status === 400 ||
+                error.response?.data?.statusCode === 10201) {
+                bail(new Error("Video not found!"));
+                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/search/liveSearch.d.ts

@@ -0,0 +1,2 @@
+import { TiktokLiveSearchResponse } from "../../types/search/liveSearch";
+export declare const SearchLive: (keyword: string, cookie: string | any[], page?: number, proxy?: string) => Promise<TiktokLiveSearchResponse>;