Så analyserar du TikTok-skapares ämnen: ett praktiskt Python-arbetsflöde

När ett team letar efter ett ämne för nästa kampanj förvandlas manuell granskning av dussintals profiler snabbt till en samling anteckningar utan en gemensam metod. En analytiker noterar visningar, en annan videobeskrivningar, och inlägg med liknande formuleringar hamnar i olika kalkylblad. En vecka senare är det svårt att avgöra vad som återkommer oftast: ämnet, sättet det presenteras på eller bara en lyckad video.

Ett praktiskt tillvägagångssätt är att hålla en liten lista med offentliga konton, regelbundet hämta information om deras videor i strukturerad form och spara varje insamling som en separat ögonblicksbild. Därefter går det att jämföra inlägg och tillgängliga mätvärden över tid och använda en språkmodell för att göra en preliminär gruppering av beskrivningarna. Nedan följer en modell för ett sådant analysflöde i Python med TikTok Scraper API från jsonscraper.

Formulera frågan innan datainsamlingen

Föreställ dig ett marknadsföringsteam hos ett mindre varumärke för sportnutrition. Teamet vill ta reda på vilka ämnen som återkommer hos utvalda offentliga TikTok-skapare och vilka videor som bör granskas manuellt. Uppgiften är att jämföra inlägg från förutbestämda konton under en observationsperiod, inte att skapa en universell popularitetsrankning för TikTok.

Detta sätter ramarna för analysen. Insamling av flöden från utvalda profiler hjälper till att undersöka innehållet och publiceringsfrekvensen för just dessa konton. Tillgängliga offentliga räknare kan registreras vid tidpunkten för förfrågan. För att utvärdera resultatet av egen annonsering behövs separata data, till exempel kostnader och konverteringar från ett annonssystem eller webbanalys.

Skriv ner ett forskningsprotokoll innan du ansluter API:t: kontolista, startdatum, insamlingsintervall, analysfält och kriterier för vilka inlägg som ska ingå. Registrera tidpunkten för varje förfrågan. Då går det att skilja en förändring i mätvärdet för en video från skillnader mellan två observationsuppsättningar.

Vad du ska samla in och mäta

Ett litet projekt behöver tre datalager. Det första innehåller kontoidentifierare och tidpunkt för insamlingen. Det andra är API:ts råsvar, sparat för senare kontroll. Det tredje består av normaliserade fält för frågor och rapporter: video-ID, beskrivning, publiceringstid och tillgängliga interaktionsräknare.

Fältnamn och svarens struktur måste fastställas utifrån ett exempel från den specifika endpointen. Utgå inte i förväg från att listan alltid heter videos eller att visningsräknaren heter views. Gör först en dokumenterad förfrågan och granska den faktiska JSON-datan. Anpassa sedan omvandlingen till ditt eget schema.

Användbara mått är antalet nya inlägg under ett intervall, inläggens ämnesfördelning och förändringen i offentliga räknare mellan ögonblicksbilder av samma video. För den sista jämförelsen matchar du poster med samma video-ID. På så sätt hålls utvecklingen för en redan publicerad video åtskild från mätvärden för nya inlägg.

Anslut till TikTok Scraper API

Beskrivningen av TikTok Scraper API anger basadressen https://tiktok.evelode.com, och endpoint-dokumentationen bekräftar GET /getUserFeed och parametrarna query, max_cursor, count, region, with_pinned_posts, sort_type och cache_timeout. För den första förfrågan räcker det att ange profilen i query och till exempel antalet objekt via count. Nyckeln license_key skickas i query string; konfigurationen beskrivs också i API-dokumentationen. I Postman-samlingen kan du kontrollera endpointen och granska svaret innan integreringen.

Förvara nyckeln i en miljövariabel. Lägg den inte i källkoden, ett kodförråd, ett kalkylblad eller en klientapplikation. Gör en förfrågan, spara ett lyckat JSON-exempel med datum och endpointens namn och använd det som grund för en normaliseringsadapter och tester.

En minimal arbetsförfrågan i Python

Dokumentationen anger att svaret från användarflödet innehåller en yttre status och objektet tiktok, där listan med inlägg finns i aweme_list. Poster kan innehålla ID, beskrivning, publiceringstid, skapare och statistik. Kontrollera de faktiska fälten och värdena i svaret du får, eftersom enskilda uppgifter kan saknas.

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("Ett JSON-objekt förväntades")
    if payload.get("status") != "ok":
        raise RuntimeError(f"API:t returnerade status: {payload.get('status')!r}")
    tiktok = payload.get("tiktok")
    if not isinstance(tiktok, dict):
        raise ValueError("Objektet tiktok saknas i svaret")
    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("Fältet tiktok.aweme_list är inte en lista")

    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"Sparat: {raw_path}; poster: {len(observations)}")

Innan du kör skriptet anger du JSONSCRAPER_TIKTOK_LICENSE_KEY i miljön och installerar biblioteket requests. Koden kontrollerar HTTP-svaret, den yttre statusen och att objektet tiktok finns, och läser därefter aweme_list. Den sparar rå JSON och hämtar fälten som bekräftas i dokumentationen, medan saknade värden lämnas tomma. Flödet som hämtas är den uppsättning resultat som API:t returnerar; rapporten bör därför kopplas till tidpunkten för förfrågan och den valda profilen.

Spara ögonblicksbilder och jämför inlägg

SQLite eller PostgreSQL passar bra för ett litet projekt. Förvara råsvaret separat från de normaliserade posterna. Du kan använda följande schema för en tabell med observationer:

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)
);

Varje körning lägger till en ny ögonblicksbild i stället för att skriva över den gamla. När du jämför räknare beräknar du skillnaden endast när det finns värden från båda observationerna för samma video. Ta med intervallet mellan förfrågningarna och observationstidpunkterna i rapporten: de förklarar hur lång tid förändringen ackumulerades under.

Börja med en liten ordlista med kategorier för ämnesgrupperingen och lägg vid behov till en klassificerare eller språkmodell. Skicka rensade beskrivningar, inläggs-ID:n och fördefinierade kategorier till modellen. Strukturerade resultat med en kategori och en kort motivering är enklare att jämföra mellan körningar än fria sammanfattningar.

Lägg till en språkmodell med kontrollerbar märkning

Modellen kan göra en preliminär fördelning av beskrivningar i ämnen som ”recept”, ”träning”, ”produktrecensioner” och ”personliga berättelser”. Börja med att märka upp några dussin inlägg manuellt. Jämför modellens automatiska etiketter med dessa exempel, förtydliga kategoriernas definitioner och gör en ny utvärdering när du ändrat prompten eller modellen.

Beräkna antalet nya inlägg, medianen för räknarna och skillnaden mellan ögonblicksbilder med vanlig kod; det är tillförlitligare. Använd modellen för textklassificering och korta förklaringar. Låt de ursprungliga beskrivningarna och de numeriska observationerna vara tillgängliga för kontroll.

Spara inläggs-ID, promptversion, bearbetningsdatum och den använda modellen tillsammans med etiketten. Om klassificeringen blir fel kan en analytiker hitta beskrivningen och justera regeln. Det är användbart att lagra den ursprungliga etiketten separat från den manuella korrigeringen.

Automatisera körningen

När du har kontrollerat en manuell körning kan du flytta skriptet till cron, GitHub Actions, n8n eller Make. Schemaläggaren kör insamlingen enligt plan, skickar med kontolistan, loggar resultatet och skickar rapporten till valt lagringsställe. Förvara nyckeln bland körmiljöns hemligheter. Testa först processen med ett konto och utöka sedan listan.

Dela upp automatiseringen i steg: kontokö, API-anrop, lagring av råsvar, normalisering, sparande av ögonblicksbild och rapportframställning. Ett fel för ett konto ska inte radera resultaten för de andra. Du kan göra omkörningar idempotenta med ett körnings-ID och unika begränsningar i databasen.

Logga tid, konto, endpoint, HTTP-status, varaktighet, antal bearbetade objekt och felbeskrivning. Skriv inte API-nyckeln i loggen. Parametern cache_timeout anges för /getUserFeed; den kan läggas till i förfrågan om du behöver en bestämd cachelagringstid. API-dokumentationen anger att standardvärdet är 3600 sekunder.

Kontrollera kvaliteten innan rapporten publiceras

Jämför några normaliserade poster med den ursprungliga JSON-datan. Kontrollera att en upprepad insamling känner igen samma video via ID, att datum tolkas som förväntat, att numeriska fält har rätt typ och att andelen saknade värden är känd. Kör sedan processen igen och kontrollera att databasen behållit gamla observationer och lagt till nya.

Blanda inte konton eller insamlingsperioder. När du jämför ämnen använder du perioder av samma längd eller visar tydligt hur långa de är i rapporten. När räknarnas utveckling jämförs anger du tiden mellan ögonblicksbilderna, så att läsaren förstår längden på intervallen.

Spara den ursprungliga beskrivningstexten och skapa en separat rensad version. Emojier, hashtaggar, länkar och språkliga särdrag kan påverka klassificeringen. Separata fält gör det enklare att kontrollera hur rensningen påverkar resultatet och klassificera om utan att göra ett nytt API-anrop.

Vilket resultat ger arbetsflödet?

Efter flera insamlingscykler får teamet en tabell med inlägg och ögonblicksbilder, en preliminär ämnesgruppering av beskrivningarna och en rapport över nya videor under den valda perioden. Det hjälper teamet att välja videor för expertgranskning, upptäcka återkommande ämnen hos de utvalda kontona och kontrollera hur offentliga räknare förändras mellan observationstillfällen.

Utifrån dessa data kan teamet formulera hypoteser för en redaktionell kalender: jämföra olika sätt att presentera samma fråga eller identifiera ämnen att testa i eget innehåll. Om den kommersiella effekten ska utvärderas behöver observationerna jämföras med interna kampanjdata.

Kom igång genom att välja en liten lista med offentliga konton och testa GET /getUserFeed i Postman-samlingen med förfrågningar. För över endast de parametrar och sökvägar till fält som bekräftas av endpointens dokumentation och dess faktiska svar.

Ansvarsfull insamling av offentliga data

Begränsa kontolistan till undersökningens syfte, samla in de fält som behövs och bestäm hur länge råsvaret ska sparas. Kontrollera vilka plattformsvillkor och krav på personuppgifter som gäller i din jurisdiktion innan data används kommersiellt. Åtkomstkontroll och borttagning av gamla ögonblicksbilder hjälper till att hålla processen inom uppdragets ramar.

Ta bort fält som modellen inte behöver innan du skickar data till en AI-tjänst. Ange inläggs-ID och observationsdatum i rapporten så att medarbetaren kan hitta posten och kontrollera slutsatsens underlag.

Kort checklista för att komma igång

1. Bestäm nisch, kontolista, period och analysfrågor.
2. Kontrollera parametrarna för GET /getUserFeed i dokumentationen och det faktiska svaret i Postman.
3. Spara ett JSON-exempel och konfigurera normaliseraren för bekräftade fält.
4. Spara råsvaret och separata ögonblicksbilder med insamlingstid.
5. Beräkna numeriska mått med kod och använd AI för preliminär gruppering av text.
6. Lägg till schemaläggning, loggning, hantering av omkörningar och en lagringstid.

På så sätt blir övervakningen en reproducerbar undersökning: varje slutsats kopplas till ett inlägg och en observationstidpunkt, och koden utgår från det faktiska schemat för den valda endpointen.