How to Find Trending TikTok Creators and Hashtags in Your Niche

May 28, 2026 · 11 min read

For brand marketers running creator partnerships, and for creators planning where to plant their own content, the most valuable signal on TikTok is who is about to break out — not who already has. By the time a creator's rate card hits four figures per video, the window is closed. The window opens earlier: when a 10k–50k follower account starts posting videos that pull views well above their follower count, the algorithm is amplifying them and follower growth is about to catch up. The same logic applies to hashtags — usage spikes precede mainstream awareness by two to six weeks, and a hashtag growing 40% week-over-week is the leading edge of a trend.

This guide walks the full pipeline for detecting those signals in any niche. Search a niche keyword or hashtag, pull the top-performing posts and the creators behind them, deep-profile each creator to get the metrics that matter, and compare against a baseline. The output is a ranked shortlist of rising creators and trending hashtags — the kind of list that drives a media-buying decision or a content calendar.

Why View-to-Follower Ratio Is the Leading Indicator

The metrics most third-party creator-discovery platforms surface — follower count, total likes, "engagement rate" calculated as (likes + comments) / followers — are lagging. They tell you who was growing six to twelve weeks ago, which is when the platforms last refreshed their indices. By the time the rate card has been quoted to ten other brands, the collab price has tripled.

View-to-follower ratio is different. If a creator with 12,000 followers posts a video that gets 400,000 views, that is a ratio of 33×. TikTok's For You Page does not amplify videos like that by accident — it is the explicit signal that the algorithm has decided to push the creator into wider distribution. The follower count will catch up over the next two to four weeks. The collab rate will catch up after that.

The practical rule of thumb for a rising-creator filter:

• Median view-to-follower ratio of the last 10 posts ≥ 5× — the median, not the maximum, so one fluke video does not pull a bad creator into the list.
• Absolute view floor of 50,000 on the median post — protects against the "1,000-follower account with a 30× ratio because they get 30,000 views on each video" case, which is real but not media-buyable.
• At least 8 posts in the last 30 days — excludes dormant or one-hit accounts.

Combine those three and you have a usable shortlist. Everything in this guide is plumbing for getting the raw numbers cheaply enough to evaluate hundreds of creators at once.

What TikTok Actually Returns Per Profile

The /api/v1/social/tiktok/deep_profile endpoint is the workhorse — one call returns the profile metadata plus the most recent posts in a single payload:

Field	Example
username	jessbakeshome
nickname	Jess Bakes
bio	sourdough + slow food in Portland
followers	47823
following	312
total_likes	1840221
verified	false
region	US
posts[].id	7384562910874523648
posts[].caption	"easiest no-knead loaf you'll ever make"
posts[].views	287400
posts[].likes	18421
posts[].comments	643
posts[].shares	2104
posts[].created_at	2026-05-19T14:22:08Z
posts[].duration_s	47
posts[].hashtags	["sourdough", "breadtok", "slowfood"]

The posts[] array gives you everything needed to compute view-to-follower ratio per post and a 30-day median in one pass. Crucially, every post carries its own hashtag list, which means deep-profiling one creator also gives you the hashtags they are riding — useful both for finding adjacent creators and for building the hashtag trend index covered later.

Step 1 — Search the Niche

Every pipeline starts with a niche keyword or hashtag. The /api/v1/social/tiktok/search endpoint takes a tagname and returns the posts TikTok currently ranks for it — which is also the implicit list of creators currently winning the topic:

curl -G "https://api.logposervices.com/api/v1/social/tiktok/search" \
  -H "X-API-Key: lp_xxxxxxx" \
  --data-urlencode "tagname=sourdough" \
  --data-urlencode "limit=50"
# → {"job_id": "tt_8a2c..."}

curl -H "X-API-Key: lp_xxxxxxx" \
  "https://api.logposervices.com/api/v1/jobs/tt_8a2c?wait=true&timeout=60"

curl -H "X-API-Key: lp_xxxxxxx" \
  https://api.logposervices.com/api/v1/jobs/tt_8a2c/result

The tagname accepts a hashtag (sourdough, breadtok) or a free-text niche term (home bakery). Hashtag results bias toward posts using that exact tag; free-text results bias toward TikTok's keyword-match against captions and creator bios. For a clean niche scan, run both and merge.

The result includes the post-level engagement plus the username of the creator who posted it. That username list — typically 20–50 unique creators per search — is the input to step two.

Step 2 — Deep-Profile Each Creator

For each creator returned by the search, pull their full profile and recent posts. The endpoint is /api/v1/social/tiktok/deep_profile, which takes a username and a limit controlling how many recent posts to fetch:

curl -G "https://api.logposervices.com/api/v1/social/tiktok/deep_profile" \
  -H "X-API-Key: lp_xxxxxxx" \
  --data-urlencode "username=jessbakeshome" \
  --data-urlencode "limit=40"

limit=40 is the sweet spot for trend detection — it covers the last one to three months of activity on most active creators, which is where the view-to-follower signal lives. Going higher pulls in older posts that dilute the recent-trend median.

For lighter scans where you only need follower count and bio (e.g. to dedupe a candidate list before deep-profiling), /api/v1/social/tiktok/profileinfo is cheaper — pass the userid and get back the profile metadata only.

The Full Python Pipeline

This is the script most teams end up running on a weekly cron. It takes one niche keyword, finds the creators currently ranking for it, deep-profiles each, computes the rising-creator metrics, and writes a ranked CSV.

import os, time, csv, statistics, requests

API_KEY = os.environ["LOGPOSE_API_KEY"]
BASE = "https://api.logposervices.com/api/v1"
HEADERS = {"X-API-Key": API_KEY}


def submit_and_wait(path: str, params: dict, timeout_s: int = 180) -> dict:
    r = requests.get(f"{BASE}/{path}", params=params, headers=HEADERS, timeout=30)
    r.raise_for_status()
    job_id = r.json()["job_id"]
    deadline = time.time() + timeout_s
    while time.time() < deadline:
        s = requests.get(f"{BASE}/jobs/{job_id}", headers=HEADERS, timeout=15).json()
        if s["status"] == "completed":
            break
        if s["status"] == "failed":
            raise RuntimeError(s.get("error", "unknown failure"))
        time.sleep(3)
    else:
        raise TimeoutError(f"job {job_id} did not finish in {timeout_s}s")
    return requests.get(f"{BASE}/jobs/{job_id}/result", headers=HEADERS, timeout=15).json()


def search_niche(tagname: str, limit: int = 50) -> list[str]:
    data = submit_and_wait(
        "social/tiktok/search",
        {"tagname": tagname, "limit": limit},
    )
    seen, usernames = set(), []
    for post in data.get("posts", []):
        u = post.get("username")
        if u and u not in seen:
            seen.add(u)
            usernames.append(u)
    return usernames


def deep_profile(username: str, limit: int = 40) -> dict:
    return submit_and_wait(
        "social/tiktok/deep_profile",
        {"username": username, "limit": limit},
    )


def score_creator(profile: dict) -> dict:
    followers = max(profile.get("followers", 0), 1)
    posts = profile.get("posts", [])[:10]
    if len(posts) < 5:
        return {"score": 0, "median_views": 0, "ratio": 0, "post_count": len(posts)}
    views = [p.get("views", 0) for p in posts]
    median_views = statistics.median(views)
    ratio = median_views / followers
    return {
        "username": profile.get("username"),
        "followers": followers,
        "median_views": int(median_views),
        "ratio": round(ratio, 2),
        "post_count": len(posts),
        "score": round(ratio * (median_views / 50_000), 2),
    }


def run_pipeline(niche: str, out_path: str) -> int:
    usernames = search_niche(niche, limit=50)
    scored = []
    for u in usernames:
        try:
            profile = deep_profile(u, limit=40)
            row = score_creator(profile)
            if row["median_views"] >= 50_000 and row["ratio"] >= 5:
                scored.append(row)
        except Exception as e:
            print(f"skip {u}: {e}")
            continue

    scored.sort(key=lambda r: r["score"], reverse=True)
    with open(out_path, "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(
            f,
            fieldnames=["username", "followers", "median_views", "ratio", "post_count", "score"],
            extrasaction="ignore",
        )
        w.writeheader()
        for r in scored:
            w.writerow(r)
    return len(scored)


if __name__ == "__main__":
    n = run_pipeline(niche="sourdough", out_path="rising_sourdough.csv")
    print(f"wrote {n} rising creators")

Run it once and the output is a ranked shortlist of creators in the niche who are currently being amplified by the algorithm beyond their follower count. Run it weekly and the rank changes are the trend.

Step 3 — Building the Hashtag Trend Index

The same deep-profile data feeds a hashtag trend index. Every post carries a hashtags[] array, so aggregating across all the deep-profiles in a niche gives you a usage frequency per hashtag. Compare this week's index to last week's snapshot and the rising tags surface themselves:

from collections import Counter
from datetime import datetime, timedelta, timezone

def hashtag_index(usernames: list[str], days: int = 7) -> Counter:
    cutoff = datetime.now(timezone.utc) - timedelta(days=days)
    counter = Counter()
    for u in usernames:
        try:
            profile = deep_profile(u, limit=40)
        except Exception:
            continue
        for post in profile.get("posts", []):
            try:
                ts = datetime.fromisoformat(post["created_at"].replace("Z", "+00:00"))
            except (KeyError, ValueError):
                continue
            if ts < cutoff:
                continue
            for tag in post.get("hashtags", []) or []:
                counter[tag.lower()] += 1
    return counter

# Compare week-over-week
this_week = hashtag_index(usernames, days=7)
last_week = hashtag_index(usernames, days=14)  # then subtract this_week
# rising = tags where this_week / max(last_week - this_week, 1) >= 1.4

The hashtags growing 40% week-over-week are typically two to six weeks ahead of when they show up in TikTok's official "Trending" tab — which is the window where they are still useful for organic content placement.

Two refinements make the hashtag index more reliable. First, exclude evergreen tags from the comparison — fyp, foryou, viral, tiktok, and the niche's own anchor tag (sourdough if the niche is sourdough) will dominate every snapshot and add no signal. Maintain a blocklist of those generic tags and skip them at aggregation time. Second, weight each hashtag occurrence by the post's view count, not just count of posts. A tag appearing on three posts that each pulled 500k views is more meaningful than a tag appearing on twelve posts that each pulled 8k views. The view-weighted index surfaces the tags actually being amplified, not just the tags being typed into captions.

For creators planning their own content calendar rather than running brand-marketing audits, the hashtag index is the half of the pipeline that matters most. Identify the three to five rising tags in the niche each week, work them into the next round of content, and the algorithmic amplification effect compounds — TikTok's For You ranking treats hashtag usage as a topic signal, and posting against a tag while it is rising puts the content in front of an audience that is being actively grown.

Step 4 — Single-Post Spot Checks

When a specific video looks interesting — a competitor's launch post, a viral clip in the niche — pull metrics on it directly with /api/v1/social/tiktok/postinfo, which takes the post's mediaid:

curl -G "https://api.logposervices.com/api/v1/social/tiktok/postinfo" \
  -H "X-API-Key: lp_xxxxxxx" \
  --data-urlencode "mediaid=7384562910874523648"

For deeper qualitative analysis — what audiences are actually saying about a video — /api/v1/social/tiktok/comments pulls the comment thread keyed on the same mediaid:

curl -G "https://api.logposervices.com/api/v1/social/tiktok/comments" \
  -H "X-API-Key: lp_xxxxxxx" \
  --data-urlencode "mediaid=7384562910874523648" \
  --data-urlencode "limit=100"

Comments are the field where brand sentiment actually shows up. A creator whose comments are heavily questions about "where did you get that?" is one who converts on product mentions; a creator whose comments are heavily commentary about the creator themselves converts less well. The signal is qualitative but consistent across categories — pull 100 comments on five of a creator's recent posts, scan for "link?", "where from?", "what brand?", and the comment-to-product-query ratio is a usable predictor of how a paid collab will perform before any contract is signed.

Cleaning the Output for Brand Use

A 50-creator deep-profile run typically produces 8–15 creators passing the rising filter. Three quality steps make the shortlist actually usable:

import pandas as pd

df = pd.read_csv("rising_sourdough.csv")

# 1. Cap the upper follower band — collab rates above 200k followers
#    are usually outside indie-brand budgets
df = df[df["followers"] <= 200_000]

# 2. Floor the lower band — too small to move product
df = df[df["followers"] >= 5_000]

# 3. Sort by score (ratio weighted by absolute reach) descending
df = df.sort_values("score", ascending=False)

df.to_csv("rising_sourdough_clean.csv", index=False)

The 5k–200k follower band is where most brand-creator collab programs operate. Below 5k the absolute reach is too low to justify the operational overhead per collab; above 200k the rate card crosses the threshold where most performance-marketing teams move budget to paid ads instead.

One nuance worth knowing: the ratio threshold should shift with the niche. Fashion and beauty creators typically run lower median view-to-follower ratios (2–4×) because the audience density on those topics is enormous and TikTok distributes views thinly across many creators. Niche verticals — sourdough, woodworking, indie tabletop games, vintage cars — run higher ratios (8–20×) because the algorithm has fewer creators competing for the same audience pool, so when it picks a winner the amplification is sharper. Calibrate the ratio >= 5 threshold against the niche's own baseline: pull the median ratio for the top 30 creators in the niche, set the rising-creator floor at 1.5× that baseline, and the filter adapts to the category dynamics automatically.

Scaling Beyond a Single Niche

One niche keyword scan gives you a category snapshot. To run a multi-niche program — say a beverage brand tracking "smoothies", "matcha", "mocktails", and "kombucha" in parallel — submit the searches as a bulk job and let the platform schedule across the proxy pool:

requests.post(
    "https://api.logposervices.com/api/v1/social/tiktok/search/bulk",
    headers={"X-API-Key": os.environ["LOGPOSE_API_KEY"]},
    json={
        "targets": [
            {"tagname": "smoothies", "limit": 50},
            {"tagname": "matcha", "limit": 50},
            {"tagname": "mocktails", "limit": 50},
            {"tagname": "kombucha", "limit": 50},
        ],
    },
).raise_for_status()

The deep-profile step is also bulk-capable on /api/v1/social/tiktok/deep_profile/bulk — feed in the deduped username list from all four searches in one call, and the parallel execution cuts what would be a 30-minute sequential sweep down to two or three minutes wall-clock.

For a recurring weekly index — re-running the same niche pipeline and surfacing only the deltas — store the previous run's CSV and diff on username plus score. A rising creator with a 40% week-over-week jump in their score is the alert that goes to the brand-partnerships team. Full walkthrough of the diff-loop pattern in the web scraping API guide, which covers the same logic generalized across platforms. For the equivalent workflow on Instagram (rising creators by reels view-to-follower), see the Instagram scraping guide — the metrics and thresholds are slightly different but the pipeline shape is identical.

Legality and Ethics

TikTok profile and post metrics are public and unauthenticated. Scraping them for internal market research, creator discovery, and trend analysis is on the same legal footing as scraping any other public web data. The risk surface for a brand-marketing program is downstream of the scrape — running paid ads featuring a creator's likeness without a license, screenshotting a creator's video in a marketing deck without permission, or storing personal data of users who left comments on a post in a way that triggers GDPR. The aggregate metrics in this guide (follower counts, view counts, hashtag frequencies) are not personal data and do not trigger those regimes. The cold-DM outreach to creators that often follows is the part that needs the actual compliance review.

Common Mistakes

• Using the wrong identifier parameter. TikTok endpoints use username (profile and posts), tagname (search), mediaid (single post and comments), and userid (lightweight profile lookup). Confusing mediaid with a post URL is the most common 400-error cause — extract the numeric ID from the URL (/video/7384562910874523648 → 7384562910874523648).
• Filtering on follower count alone. This is the lagging-indicator trap discussed at the top — every creator-discovery platform makes this mistake, which is exactly why a custom pipeline outperforms them.
• Comparing absolute view counts across creators. A 100k-view video on a 5k-follower account is a different signal from a 100k-view video on a 5M-follower account. Always normalize on view-to-follower ratio, not raw views.
• Treating one post as a signal. Algorithm amplification is real, but so are flukes. Use the median of the last 10 posts as the floor, not the maximum.
• Ignoring the Cloudflare 100-second edge timeout. api.logposervices.com sits behind Cloudflare, so a job that takes 100+ seconds returns a 524 to your client even though the job continues server-side. Always poll for status; never expect a synchronous response on a deep-profile sweep across 50 creators.
• Sampling a niche only once before drawing conclusions. One snapshot of the top creators in a niche is a noisy signal — TikTok's For You ranking shuffles which posts surface for any given search at different times of day and across geographies. Run the niche scan three times across a week and merge the candidate username lists; the creators who appear in all three are the ones reliably ranking, not the ones who happened to be amplified during a single five-minute scrape.
• Scraping too aggressively from a single IP. Even with the managed API's residential rotation handling the public-endpoint pacing, the upstream creator audit pattern is to space deep-profile calls across the bulk endpoint rather than firing them back-to-back from a tight Python loop. The bulk submission also returns a single parent job_id you can poll once, instead of tracking 50 individual jobs by hand — operationally cleaner and the same wall-clock time.

Get Started

1. Sign up at logposervices.com and generate an API key under Tool → API Keys.
2. export LOGPOSE_API_KEY=lp_xxxxxxx
3. Pick a niche keyword and run the Python pipeline above against it.

Related reading: the Instagram scraping guide for the equivalent creator-discovery workflow on Instagram, and the web scraping API guide for the broader DIY-vs-managed comparison and the recurring-refresh diff pattern that turns this one-shot script into a weekly trend index.

External: TikTok, hiQ Labs v. LinkedIn.