Jak analyzovat témata tvůrců na TikToku: praktický pracovní postup v Pythonu

Když tým hledá téma pro další kampaň, ruční procházení desítek profilů se rychle změní v hromadu poznámek bez jednotné metodiky. Jeden analytik si zapisuje zhlédnutí, jiný popisky videí a příspěvky s podobnými formulacemi končí v různých tabulkách. Po týdnu je těžké poznat, co se opakuje častěji: téma, způsob podání, nebo jen úspěšné video.

Praktický přístup spočívá v tom, že vedete krátký seznam veřejných účtů, pravidelně získáváte strukturované informace o jejich videích a každý sběr ukládáte jako samostatný snímek. Pak můžete v čase porovnávat příspěvky a dostupné metriky a jazykový model použít k předběžnému seskupení popisků. Níže najdete návrh takového výzkumného pracovního postupu v Pythonu s TikTok Scraper API od jsonscraper.

Než začnete sbírat data, stanovte si otázku

Představme si marketingový tým menší značky sportovní výživy. Potřebuje zjistit, jaká témata se pravidelně objevují u vybraných veřejných tvůrců na TikToku a která videa stojí za ruční prohlédnutí. Cílem je porovnat příspěvky předem vybraných účtů během sledovaného období, nikoli vytvořit univerzální žebříček popularity TikToku.

Tím se vymezí hranice analýzy. Sběr feedu vybraných profilů pomáhá zkoumat obsah a četnost příspěvků těchto účtů. Dostupné veřejné počty lze zaznamenat v okamžiku dotazu. K hodnocení výsledků vlastní reklamy budou potřeba samostatná data, například výdaje a konverze z reklamního systému nebo webové analytiky.

Ještě před připojením k API si zapište výzkumný protokol: seznam účtů, datum zahájení, četnost sběru, analyzovaná pole a kritéria pro zahrnutí příspěvků. Zaznamenávejte čas každého dotazu. Díky tomu rozlišíte změnu metriky u jednoho videa od rozdílu mezi dvěma soubory pozorování.

Co sbírat a co počítat

Pro menší projekt jsou potřeba tři vrstvy dat. První tvoří ID účtu a čas spuštění sběru. Druhou je původní odpověď API uložená pro pozdější ověření. Třetí představují normalizovaná pole pro dotazy a reporty: ID videa, popisek, čas zveřejnění a dostupné počty interakcí.

Názvy polí a strukturu vnoření je třeba určit podle ukázky konkrétního endpointu. Předem nepředpokládejte, že se seznam vždy jmenuje videos nebo že počet zhlédnutí má název views. Nejprve proveďte dokumentovaný dotaz a prozkoumejte skutečný JSON, teprve potom nastavte převod do vlastní struktury.

Užitečnými ukazateli jsou počet nových příspěvků za interval, rozložení příspěvků podle témat a změna veřejných počtů mezi snímky téhož videa. Při posledním ukazateli porovnávejte záznamy se shodným ID videa. Vývoj už zveřejněného videa tak zůstane oddělený od metrik nových příspěvků.

Připojení k TikTok Scraper API

V popisu TikTok Scraper API je uvedena základní adresa https://tiktok.evelode.com; dokumentace endpointů potvrzuje GET /getUserFeed a parametry query, max_cursor, count, region, with_pinned_posts, sort_type a cache_timeout. Pro první dotaz stačí zadat profil do query a například počet položek přes count. Klíč license_key se předává v query stringu; jeho nastavení popisuje také dokumentace API. V kolekci Postmanu můžete před integrací ověřit endpoint a zkontrolovat odpověď.

Klíč ukládejte do proměnné prostředí. Nevkládejte ho do zdrojového kódu, repozitáře, tabulky ani klientské aplikace. Proveďte dotaz, uložte úspěšnou ukázku JSON s datem a názvem endpointu a použijte ji jako základ pro normalizační adaptér a testy.

Základní pracovní dotaz v Pythonu

Dokumentace uvádí, že odpověď uživatelského feedu obsahuje vnější stav a objekt tiktok, v němž je seznam příspěvků uložen v aweme_list. Záznamy mohou obsahovat ID, popisek, čas zveřejnění, autora a statistiky. Konkrétní pole a hodnoty je třeba ověřit v získané odpovědi; některé údaje mohou chybět.

import json
import os
from datetime import datetime, timezone
from pathlib import Path

import requests

API_KEY = os.environ["JSONSCRAPER_TIKTOK_LICENSE_KEY"]
ENDPOINT_URL = "https://tiktok.evelode.com/getUserFeed"


def fetch_user_feed(handle: str, count: int = 20) -> dict:
    response = requests.get(
        ENDPOINT_URL,
        params={
            "license_key": API_KEY,
            "query": handle,
            "count": count,
            "region": "US",
        },
        timeout=45,
    )
    response.raise_for_status()
    payload = response.json()
    if not isinstance(payload, dict):
        raise ValueError("Očekával se objekt JSON")
    if payload.get("status") != "ok":
        raise RuntimeError(f"API vrátilo stav: {payload.get('status')!r}")
    tiktok = payload.get("tiktok")
    if not isinstance(tiktok, dict):
        raise ValueError("V odpovědi chybí objekt tiktok")
    return payload


def save_raw(payload: dict, account: str, output_dir: str = "data/raw") -> Path:
    collected_at = datetime.now(timezone.utc).isoformat()
    safe_account = "".join(c for c in account if c.isalnum() or c in "-_@")
    path = Path(output_dir) / f"{safe_account}_{collected_at.replace(':', '-')}.json"
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(
        json.dumps(
            {"collected_at": collected_at, "account": account, "payload": payload},
            ensure_ascii=False,
            indent=2,
        ),
        encoding="utf-8",
    )
    return path


def normalize_items(payload: dict, account: str, collected_at: str) -> list:
    items = payload["tiktok"].get("aweme_list", [])
    if not isinstance(items, list):
        raise ValueError("Pole tiktok.aweme_list není seznam")

    observations = []
    for item in items:
        if not isinstance(item, dict):
            continue
        stats = item.get("statistics")
        stats = stats if isinstance(stats, dict) else {}
        author = item.get("author")
        author = author if isinstance(author, dict) else {}
        observations.append({
            "account_handle": account,
            "collected_at": collected_at,
            "video_id": item.get("aweme_id"),
            "caption": item.get("desc"),
            "published_at_epoch": item.get("create_time"),
            "author_handle": author.get("unique_id"),
            "views": stats.get("play_count"),
            "likes": stats.get("digg_count"),
            "comments": stats.get("comment_count"),
            "shares": stats.get("share_count"),
        })
    return observations


if __name__ == "__main__":
    account = "creator_handle"
    payload = fetch_user_feed(account, count=20)
    collected_at = datetime.now(timezone.utc).isoformat()
    raw_path = save_raw(payload, account)
    observations = normalize_items(payload, account, collected_at)
    print(f"Uloženo: {raw_path}; záznamů: {len(observations)}")

Před spuštěním nastavte v prostředí JSONSCRAPER_TIKTOK_LICENSE_KEY a nainstalujte knihovnu requests. Kód ověřuje HTTP odpověď, vnější stav i přítomnost objektu tiktok a potom načte aweme_list. Uloží nezpracovaný JSON a vytáhne pole potvrzená dokumentací; chybějící hodnoty ponechá prázdné. Získaný feed je sada výsledků vrácených API, proto by report měl uvádět čas dotazu a vybraný profil.

Ukládejte snímky a porovnávejte příspěvky

Pro menší projekt postačí SQLite nebo PostgreSQL. Původní odpověď ukládejte odděleně od normalizovaných záznamů. Pro tabulku pozorování lze použít následující strukturu:

CREATE TABLE IF NOT EXISTS video_observations (
    account_handle TEXT NOT NULL,
    video_id TEXT NOT NULL,
    collected_at TEXT NOT NULL,
    published_at_epoch INTEGER,
    caption TEXT,
    views INTEGER,
    likes INTEGER,
    comments INTEGER,
    shares INTEGER,
    raw_file TEXT,
    PRIMARY KEY (account_handle, video_id, collected_at)
);

Každé spuštění přidá nový snímek, místo aby přepsalo předchozí. Při porovnávání počtů vypočítejte rozdíl pouze tam, kde jsou k dispozici obě hodnoty pro stejné video. Interval mezi dotazy a čas pozorování uveďte v reportu; vysvětlí, za jak dlouhé období se změna nahromadila.

Pro seskupování podle témat začněte s malým slovníkem kategorií a podle potřeby přidejte klasifikátor nebo jazykový model. Modelu předávejte očištěné popisky, ID příspěvků a předem stanovené kategorie. Strukturovaný výstup s kategorií a krátkým zdůvodněním se porovnává snáz než volný přehled.

Přidejte jazykový model s ověřitelným označováním

Model může předběžně zařazovat popisky do témat, jako jsou „recepty“, „tréninky“, „recenze produktů“ nebo „osobní příběhy“. Nejprve ručně označte několik desítek příspěvků. Porovnejte automatické štítky s těmito příklady, upřesněte definice kategorií a po změně promptu nebo modelu hodnocení zopakujte.

Počet nových příspěvků, medián počtů a rozdíl mezi snímky je spolehlivější počítat běžným kódem. Model použijte ke klasifikaci textu a přípravě stručných vysvětlení. Původní popisky a číselná pozorování ponechte dostupná k ověření.

Spolu se štítkem ukládejte ID příspěvku, verzi promptu, datum zpracování a použitý model. Pokud se klasifikace nepovede, analytik najde popisek a může pravidlo upravit. Původní štítek a ruční opravu je vhodné uchovávat odděleně.

Automatizujte spuštění

Po ověření ručního spuštění přesuňte skript do cronu, GitHub Actions, n8n nebo Make. Plánovač spouští sběr podle rozvrhu, předává seznam účtů, zaznamenává výsledek a odesílá report do zvoleného úložiště. Klíč uchovávejte mezi tajnými údaji prostředí, v němž proces běží. Nejprve ověřte postup na jednom účtu a pak seznam rozšiřujte.

Automatizaci rozdělte do kroků: fronta účtů, volání API, uložení původní odpovědi, normalizace, zápis snímku a příprava reportu. Chyba u jednoho účtu by neměla smazat výsledky ostatních. Opakované spuštění lze nastavit jako idempotentní pomocí ID běhu a omezení jedinečnosti v databázi.

Zaznamenávejte čas, účet, endpoint, HTTP stav, dobu trvání, počet zpracovaných položek a popis chyby. API klíč do logu nezapisujte. Parametr cache_timeout je uveden pro /getUserFeed; lze ho přidat do dotazu, pokud potřebujete nastavit dobu kešování. Dokumentace API uvádí výchozí hodnotu 3600 sekund.

Před zveřejněním reportu ověřte kvalitu

Porovnejte několik normalizovaných záznamů s původním JSON. Zkontrolujte, že opakovaný sběr rozpozná stejné video podle ID, data se interpretují očekávaným způsobem, číselná pole mají vhodný typ a podíl chybějících údajů je známý. Poté sběr zopakujte a ověřte, že databáze zachovala stará pozorování a přidala nová.

Nemíchejte účty ani období sběru. Při porovnávání témat používejte stejně dlouhá období, případně jejich délku v reportu výslovně uveďte. U vývoje počtů zaznamenejte interval mezi snímky, aby čtenář rozuměl délce porovnávaných období.

Uchovávejte původní text popisku a zvlášť vytvářejte jeho očištěnou verzi. Emoji, hashtagy, odkazy a jazykové zvláštnosti mohou ovlivnit klasifikaci; samostatná pole pomohou ověřit dopad čištění a přepočítat kategorie bez nového dotazu na API.

Jaký výsledek pracovní postup přinese

Po několika cyklech bude mít tým tabulku příspěvků a snímků, předběžné seskupení popisků podle témat a report nových videí za vybrané období. To pomůže vybrat videa k odbornému posouzení, rozpoznat opakující se témata u vybraných účtů a ověřit změnu veřejných počtů mezi daty pozorování.

Na základě těchto dat lze formulovat hypotézy pro redakční kalendář: porovnat různé způsoby zpracování stejné otázky nebo vybrat témata k otestování ve vlastním obsahu. Pro posouzení komerčního dopadu porovnejte pozorování s interními údaji o kampaních.

Začněte výběrem krátkého seznamu veřejných účtů a ověřte GET /getUserFeed v kolekci požadavků v Postmanu. Do kódu přenášejte jen parametry a cesty k polím potvrzené dokumentací endpointu a jeho skutečnou odpovědí.

Odpovědný sběr veřejných dat

Seznam účtů omezte na účel výzkumu, sbírejte jen potřebná pole a stanovte dobu uchovávání původní odpovědi. Před komerčním využitím dat ověřte příslušné podmínky platformy a požadavky na osobní údaje ve své jurisdikci. Řízení přístupu a mazání zastaralých snímků pomáhají udržet proces v mezích stanoveného úkolu.

Před odesláním dat do služby AI odstraňte pole, která model nepotřebuje. V reportu uvádějte ID příspěvku a datum pozorování, aby zaměstnanec mohl přejít k záznamu a ověřit, o co se závěr opírá.

Stručný kontrolní seznam spuštění

1. Určete oblast, seznam účtů, období a otázky analýzy.
2. Ověřte parametry GET /getUserFeed v dokumentaci a skutečnou odpověď v Postmanu.
3. Uložte ukázku JSON a nastavte normalizaci pro potvrzená pole.
4. Ukládejte původní odpověď a samostatné snímky s časem sběru.
5. Číselné ukazatele počítejte kódem; AI použijte k předběžnému seskupení textu.
6. Přidejte plánování, logování, zpracování opakovaných pokusů a dobu uchovávání.

Díky tomu se sledování změní na reprodukovatelný výzkum: každý závěr bude propojený s příspěvkem a časem pozorování a kód bude vycházet ze skutečné struktury zvoleného endpointu.