Slik analyserer du TikTok-skaperes temaer: en praktisk Python-pipeline

Når et team leter etter et tema til neste kampanje, blir manuell gjennomgang av dusinvis av profiler raskt til en samling notater uten en felles metode. Én analytiker noterer visninger, en annen videotekster, og innlegg med lignende formuleringer havner i forskjellige regneark. Etter en uke er det vanskelig å vite hva som går igjen oftest: et tema, en presentasjonsform eller bare en video som traff godt.

En praktisk tilnærming er å føre en kort liste over offentlige kontoer, jevnlig hente informasjon om videoene deres i et strukturert format og lagre hver innsamling som et eget øyeblikksbilde. Deretter kan du sammenligne innlegg og tilgjengelige måltall over tid og bruke en språkmodell til å gruppere videotekster foreløpig. Nedenfor finner du en skisse til en slik analysepipeline i Python med TikTok Scraper API fra jsonscraper.

Formuler spørsmålet før datainnsamlingen

Se for deg et markedsføringsteam hos et lite merke for sportsnæring. Teamet vil finne ut hvilke temaer som jevnlig dukker opp hos utvalgte offentlige TikTok-skapere, og hvilke videoer som bør gjennomgås manuelt. Målet er å sammenligne innlegg fra forhåndsvalgte kontoer i en observasjonsperiode, ikke å lage en universell popularitetsrangering for TikTok.

Dette setter rammene for analysen. Innsamling av feeden fra utvalgte profiler gjør det mulig å studere innholdet og publiseringsfrekvensen til disse kontoene. Tilgjengelige offentlige tellere kan registreres på tidspunktet for forespørselen. For å vurdere resultatene av egen annonsering trengs separate data, for eksempel kostnader og konverteringer fra annonsesystemet eller nettanalysen.

Før du kobler til API-et, bør du skrive ned forskningsprotokollen: kontoliste, startdato, innsamlingsfrekvens, analysefelt og kriterier for hvilke innlegg som inkluderes. Registrer tidspunktet for hver forespørsel. Da kan du skille en endring i måltallet for én video fra forskjeller mellom to observasjonsutvalg.

Hva du bør samle inn og måle

Et lite prosjekt trenger tre datalag. Det første er konto-ID og tidspunktet for innsamlingskjøringen. Det andre er den opprinnelige API-responsen, lagret slik at den kan kontrolleres senere. Det tredje er normaliserte felt for søk og rapporter: video-ID, videotekst, publiseringstidspunkt og tilgjengelige engasjementstall.

Feltnavn og hvordan dataene er nøstet, må fastslås ut fra et eksempel fra det aktuelle endepunktet. Ikke anta på forhånd at listen alltid heter videos, eller at visningstelleren heter views. Kjør først en forespørsel som dokumentasjonen beskriver, og undersøk den faktiske JSON-en. Tilpass deretter transformasjonen til ditt eget skjema.

Nyttige måltall er antall nye innlegg per intervall, fordelingen av innlegg etter tema og endringen i offentlige tellere mellom øyeblikksbilder av samme video. Når du beregner sistnevnte, sammenligner du oppføringer med samme video-ID. Slik holdes utviklingen for en allerede publisert video atskilt fra måltallene for nye innlegg.

Koble til TikTok Scraper API

Beskrivelsen av TikTok Scraper API oppgir basisadressen https://tiktok.evelode.com, og endepunktoversikten bekrefter GET /getUserFeed og parameterne query, max_cursor, count, region, with_pinned_posts, sort_type og cache_timeout. For den første forespørselen holder det å angi en profil i query og for eksempel antall elementer med count. Nøkkelen license_key sendes i query string; oppsettet er også beskrevet i API-oversikten. I Postman-samlingen kan du kontrollere endepunktet og prøve responsen før integreringen.

Oppbevar nøkkelen i en miljøvariabel. Ikke legg den i kildekoden, et repositorium, et regneark eller en klientapplikasjon. Kjør forespørselen, lagre et vellykket JSON-eksempel med dato og navn på endepunktet, og bruk det som grunnlag for normaliseringsadapteren og testene.

En enkel fungerende forespørsel i Python

Oversikten oppgir at responsen fra brukerfeeden inneholder en ytre status og et tiktok-objekt, der listen over innlegg ligger i aweme_list. Oppføringene kan inneholde ID, videotekst, publiseringstidspunkt, forfatter og statistikk. Kontroller konkrete felt og verdier mot responsen du mottar: enkelte data kan mangle.

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("Forventet et JSON-objekt")
    if payload.get("status") != "ok":
        raise RuntimeError(f"API-et returnerte status: {payload.get('status')!r}")
    tiktok = payload.get("tiktok")
    if not isinstance(tiktok, dict):
        raise ValueError("Responsen mangler tiktok-objektet")
    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("Feltet tiktok.aweme_list er ikke en liste")

    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"Lagret: {raw_path}; oppføringer: {len(observations)}")

Før du kjører skriptet, setter du JSONSCRAPER_TIKTOK_LICENSE_KEY i miljøet og installerer biblioteket requests. Koden kontrollerer HTTP-responsen, den ytre statusen og at tiktok-objektet finnes, og leser deretter aweme_list. Den lagrer rå JSON og henter ut feltene som er bekreftet i oversikten, mens manglende verdier forblir tomme. Feeden du får, er datasettet API-et returnerte, så rapporten bør knyttes til tidspunktet for forespørselen og den valgte profilen.

Lagre øyeblikksbilder og sammenlign innlegg

SQLite eller PostgreSQL passer godt til små prosjekter. Lagre råresponsen separat fra de normaliserte oppføringene. Du kan bruke følgende skjema for observasjonstabellen:

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

Hver kjøring legger til et nytt øyeblikksbilde i stedet for å overskrive det forrige. Når du sammenligner tellere, beregner du bare differansen der du har begge verdiene for samme video. Ta med intervallet mellom forespørslene og tidspunktet for observasjonen i rapporten: De forklarer hvor lang tid endringen har akkumulert over.

For temagruppering kan du begynne med en liten kategoriliste og senere legge til en klassifikator eller språkmodell ved behov. Gi modellen rensede videotekster, publiserings-ID-er og forhåndsdefinerte kategorier. Et strukturert resultat med kategori og en kort begrunnelse er enklere å sammenligne mellom kjøringer enn en fri oppsummering.

Legg til en språkmodell med etterprøvbar merking

En modell kan foreløpig sortere videotekster i temaer som «oppskrifter», «trening», «produktomtaler» og «personlige historier». Begynn med å merke noen titalls innlegg manuelt. Sammenlign modellens etiketter med disse eksemplene, presiser kategoridefinisjonene og gjenta vurderingen etter at du har endret instruksjonen eller modellen.

Antall nye innlegg, medianen for tellerne og differansen mellom øyeblikksbilder beregnes mer pålitelig med vanlig kode. Bruk modellen til tekstklassifisering og korte forklaringer. Sørg for at originaltekstene og tallobservasjonene fortsatt er tilgjengelige for kontroll.

Lagre publiserings-ID, instruksjonsversjon, behandlingstidspunkt og modellen som ble brukt, sammen med etiketten. Hvis klassifiseringen er feil, kan analytikeren finne videoteksten og korrigere regelen. Det er nyttig å lagre den opprinnelige etiketten og en manuell korrigering hver for seg.

Automatiser kjøringen

Når den manuelle kjøringen er kontrollert, kan du flytte skriptet til cron, GitHub Actions, n8n eller Make. Planleggeren kjører innsamlingen etter en tidsplan, sender inn en liste med kontoer, logger resultatet og videresender rapporten til valgt lagring. Oppbevar nøkkelen som en hemmelighet i kjøremiljøet. Test først prosessen på én konto, og utvid deretter listen.

Del automatiseringen inn i trinn: kontokø, API-kall, lagring av rårespons, normalisering, lagring av øyeblikksbilde og rapportutarbeidelse. En feil for én konto skal ikke slette resultatene for de andre. Du kan gjøre gjentatte kjøringer idempotente ved å bruke en kjørings-ID og unike begrensninger i databasen.

Loggfør tidspunkt, konto, endepunkt, HTTP-status, varighet, antall behandlede elementer og feilbeskrivelse. Ikke skriv API-nøkkelen til loggen. Parameteren cache_timeout er oppført for /getUserFeed; du kan legge den til i forespørselen hvis du trenger en bestemt hurtigbufferperiode. API-oversikten oppgir 3600 sekunder som standardverdi.

Kontroller kvaliteten før du publiserer rapporten

Sammenlign noen normaliserte oppføringer med den opprinnelige JSON-en. Kontroller at gjentatte innsamlinger identifiserer samme video med samme ID, at datoer tolkes som forventet, at numeriske felt har riktig type, og at andelen manglende verdier er kjent. Kjør deretter prosessen på nytt, og bekreft at databasen har beholdt de gamle observasjonene og lagt til nye.

Ikke bland kontoer og innsamlingsperioder. Bruk samme periodelengde når du sammenligner temaer, eller vis den tydelig i rapporten. For utviklingen i tellere bør du registrere tiden mellom øyeblikksbildene, slik at leseren forstår hvor lange intervallene som sammenlignes, er.

Behold den opprinnelige teksten, og lag en separat renset versjon. Emoji, emneknagger, lenker og språkspesifikke trekk kan påvirke klassifiseringen. Separate felt gjør det lettere å undersøke effekten av rensingen og beregne kategoriene på nytt uten å sende en ny forespørsel til API-et.

Hvilke resultater gir pipelinen?

Etter flere innsamlingsrunder får teamet en tabell over innlegg og øyeblikksbilder, en foreløpig gruppering av videotekstene etter tema og en rapport over nye videoer i den valgte perioden. Det hjelper teamet med å velge videoer for ekspertgjennomgang, oppdage tilbakevendende temaer hos de utvalgte kontoene og undersøke endringer i offentlige tellere mellom observasjonsdatoene.

Med utgangspunkt i disse dataene kan dere formulere hypoteser for en redaksjonell kalender: sammenligne ulike måter å presentere samme spørsmål på eller finne temaer som kan testes i eget innhold. For å vurdere den kommersielle effekten kan dere sammenholde observasjonene med interne kampanjedata.

For å komme i gang velger du en kort liste over offentlige kontoer og tester GET /getUserFeed i Postman-samlingen med forespørsler. Bruk bare parametere og feltnøkler i koden som er bekreftet av dokumentasjonen for endepunktet og den faktiske responsen.

Ansvarlig innsamling av offentlige data

Begrens kontolisten til det forskningsformålet krever, samle inn nødvendige felt og fastsett hvor lenge råresponsene skal lagres. Før du bruker dataene kommersielt, bør du kontrollere plattformens gjeldende vilkår og kravene til personopplysninger i din jurisdiksjon. Tilgangskontroll og sletting av foreldede øyeblikksbilder bidrar til å holde prosessen innenfor rammene av oppgaven.

Fjern felter som modellen ikke trenger, før du sender data til en AI-tjeneste. Oppgi publiserings-ID og observasjonsdato i rapporten, slik at en medarbeider kan finne posten og kontrollere grunnlaget for konklusjonen.

Kort sjekkliste for oppstart

1. Definer nisje, kontoliste, periode og analysespørsmål.
2. Kontroller parameterne for GET /getUserFeed i oversikten og den faktiske responsen i Postman.
3. Lagre et JSON-eksempel og konfigurer normaliseringen for bekreftede felt.
4. Lagre råresponsen og separate øyeblikksbilder med innsamlingstidspunkt.
5. Beregn tallverdier med kode; bruk AI til foreløpig gruppering av tekst.
6. Legg til tidsplan, logging, håndtering av gjentatte kjøringer og oppbevaringstid.

Slik blir overvåkingen en etterprøvbar undersøkelse: Hver konklusjon er knyttet til et innlegg og et observasjonstidspunkt, og koden bygger på det faktiske skjemaet til det valgte endepunktet.