How to Get TikTok Reposts via API

Every public TikTok profile has an upload feed, and many also have a repost tab: videos the account did not film but chose to push in front of its own followers. That second feed is a different kind of signal. Uploads tell you what a creator makes; reposts tell you what a creator endorses. This guide covers how to pull that feed with the user-repost endpoint, how to read the itemList it returns, how to reliably separate borrowed items from the account's own, and how to fill in the exact engagement numbers with post-detail.

Repost versus original post

On TikTok a repost is closer to a retweet than to a re-upload. The video file, the caption, the sound and the engagement counters all stay attached to the original creator. Nothing is duplicated; the reposting account simply attaches its name to something already published and distributes it to its own audience. That has one consequence that shapes every integration: the items you get back from the repost feed are, by definition, mostly other people's posts. Their author block belongs to whoever filmed the video, not to the account whose feed you requested.

This is exactly the opposite of what you get from an upload feed, where every item carries the same author. If you are already pulling every video from a TikTok user, you can reuse most of that code path here - the item structure is the same - but the assumption "author equals the account I asked about" no longer holds, and any code that hard-codes it will silently mislabel data.

Why the repost feed is a useful signal

Reposting costs a creator nothing to produce but spends real audience attention, so it is an unusually honest indicator of taste and affinity. A few things it is good for:

• Mapping influence between accounts. Collect the author.uniqueId of every reposted item and count the repeats. The creators that show up again and again are the ones this account actually follows closely, which is a far stronger link than a mutual follow.
• Topic and sound affinity. The challenges and music blocks on reposted items show which hashtags and sounds the account is willing to associate itself with.
• Partnership research. If a creator repeatedly reposts a brand or a peer, they are pre-warmed for an outreach message.
• Trend detection at the edges. Reposts often run ahead of a creator's own uploads, because amplifying is faster than filming.

It pairs well with the liked-videos feed, which is the other public affinity surface on a profile - see the walkthrough on reading a user's liked videos if you want both signals in one pipeline.

Step 1: get the secUid

The repost endpoint identifies accounts by secUid, not by handle and not by numeric ID. The secUid is the long opaque string beginning with MS4wLjABAAAA that TikTok uses internally; there is more on where it comes from and why it exists in the secUid explainer. You get one from a single call to userinfo-by-username, which returns user.secUid alongside user.id, user.uniqueId and the profile stats. Resolve it once, store it next to the handle in your own database, and reuse it - handles change, secUid values do not.

Step 2: call user-repost

The base URL is https://api.primeapi.co/ and authentication is the single header X-PrimeAPI-Key. The endpoint takes secUid as the only required parameter, plus optional count (page size) and cursor (start at 0). Full request and response reference lives in the PrimeApi documentation, and you can fire a test call without writing any code in the API playground.

curl

curl -s "https://api.primeapi.co/user-repost?secUid=MS4wLjABAAAA-hnFaH9aGUYLRspPmUXT3nZOha3-CEyChdtqwlyFaG1M_kAi4MD0AaZkbuIsPIzc&count=30&cursor=0" \
  -H "X-PrimeAPI-Key: YOUR_API_KEY"

Node.js (Axios)

const axios = require("axios");

const KEY = "YOUR_API_KEY";

async function getReposts(secUid, cursor = "0", count = 30) {
  const res = await axios.get("https://api.primeapi.co/user-repost", {
    params: { secUid, count, cursor },
    headers: { "X-PrimeAPI-Key": KEY }
  });
  console.log("Remaining credits:", res.headers["x-primeapi-balance"]);
  return res.data;
}

getReposts("MS4wLjABAAAA-hnFaH9aGUYLRspPmUXT3nZOha3-CEyChdtqwlyFaG1M_kAi4MD0AaZkbuIsPIzc")
  .then(d => {
    const items = d.itemList || [];
    console.log(items.length, "items, hasMore:", d.hasMore, "cursor:", d.cursor);
    items.forEach(it => console.log(it.id, "@" + it.author.uniqueId, "-", it.desc));
  })
  .catch(e => console.error(e.response ? e.response.data : e.message));

Python (Requests)

import requests

BASE = "https://api.primeapi.co"
HEADERS = {"X-PrimeAPI-Key": "YOUR_API_KEY"}

def all_reposts(sec_uid, count=30, max_pages=10):
    cursor = "0"
    for _ in range(max_pages):
        r = requests.get(f"{BASE}/user-repost",
                         params={"secUid": sec_uid, "count": count, "cursor": cursor},
                         headers=HEADERS, timeout=15)
        r.raise_for_status()
        data = r.json()
        for item in data.get("itemList", []):
            yield item
        if not data.get("hasMore"):
            break
        cursor = data.get("cursor")

if __name__ == "__main__":
    sec_uid = "MS4wLjABAAAA-hnFaH9aGUYLRspPmUXT3nZOha3-CEyChdtqwlyFaG1M_kAi4MD0AaZkbuIsPIzc"
    for item in all_reposts(sec_uid):
        print(item["id"], item["author"]["uniqueId"], item["desc"][:60])

Reading the response

The payload is a feed envelope. At the top level you get itemList, a cursor string, a boolean hasMore, an extra object (with logid and now), log_pb, and the status trio statusCode, status_code and status_msg. In a live sample of a 30-item request, itemList came back with 12 entries and cursor as the string "16" - an offset-style value rather than a timestamp. Treat the cursor as opaque: never compute it yourself, just pass the value back verbatim on the next call and stop when hasMore is false.

Each entry in itemList is a full video record. The fields worth wiring into a schema:

Detecting which items are not the user's own

This is the one piece of logic specific to repost feeds. The check is a string comparison: take author.secUid from each item and compare it to the secUid you sent in the request. Different value means the video belongs to someone else. Comparing author.id works equally well and is shorter to store; author.uniqueId also works but is a handle, so it can change under you.

def split_feed(items, sec_uid):
    own, borrowed = [], []
    for it in items:
        (own if it["author"]["secUid"] == sec_uid else borrowed).append(it)
    return own, borrowed

# who does this account amplify most?
from collections import Counter
counts = Counter(it["author"]["uniqueId"]
                 for it in all_reposts(sec_uid)
                 if it["author"]["secUid"] != sec_uid)
print(counts.most_common(10))

Two warnings. First, do not use the originalItem or officalItem booleans as a repost marker - they are TikTok's flags about the item, not a statement about the account you queried. Second, an account can repost its own video, so a small number of items may legitimately match your secUid. Keep both buckets rather than discarding the matches.

Filling in the numbers with post-detail

The captured repost item does not expose an engagement block you can count on, so when you need real numbers, take the item id and call post-detail with it. That response nests everything under itemInfo.itemStruct, where stats gives you playCount, diggCount, commentCount, shareCount and collectCount, and statsV2 mirrors those and adds repostCount - the number of times that video has been reposted across TikTok, which closes the loop nicely on this topic. The same struct carries a video block (duration, cover, playAddr, downloadAddr, width, height), the full author record, music, challenges, textExtra and a shareMeta title. The field-by-field tour is in the post on getting TikTok video data via API.

curl -s "https://api.primeapi.co/post-detail?postId=7330315169584778539" \
  -H "X-PrimeAPI-Key: YOUR_API_KEY"

Budget for this: one repost page is 1 credit, then 1 credit per video you enrich. Twelve reposts fully enriched is 13 credits. If you only need a ranking of amplified creators, skip the enrichment entirely - the author block in the feed already answers that question for a single credit.

Credits, paging and limits

Every call costs exactly 1 credit whether it returns 30 items or zero, and the remaining balance comes back in the X-PrimeAPI-Balance header, so log it and alert on it. The default rate limit is 100 requests per minute, which is plenty for a paging loop but worth respecting if you fan out across many accounts at once - stagger the jobs across minute windows. Responses are real time with no caching, and typically land in about a second. New accounts get 50 free credits on sign-up, and volume tiers start at $9.90 for 2,500 credits on the pricing page.

Be honest with yourself about the limits of this data. The feed does not tell you when the repost happened - createTime is the original upload time - so you cannot build an exact repost timeline from a single pull; you build it by polling and diffing. Reposts of deleted or private videos drop out silently. Accounts with no repost tab return an empty itemList, which is a successful response and not something to retry. And PrimeApi is an independent service that is not affiliated with or endorsed by TikTok or ByteDance, so collect only public data and keep your use within TikTok's terms of service and whatever privacy rules apply to you.

Putting it together

The complete flow is short: resolve the handle to a secUid, page user-repost until hasMore is false, split each itemList by comparing author.secUid to your input, count the borrowed authors to see who this account amplifies, and call post-detail only on the items you actually want numbers for. Store the item id values you have already seen so the next run only enriches what is new. Done that way, tracking an account's reposts costs a handful of credits per check and gives you a curation signal that upload feeds and follower lists simply do not contain.

Frequently asked questions

← Back to the PrimeApi Blog