I Reviewed TikTok Video API Fields. Here’s What to Save for Repeat Checks.

For a known TikTok video, keep the returned video ID, observation time, caption, creation date, author and any numeric counts your decision uses. Treat missing fields as unknown and media links as temporary. This is a repeat check of a known item, not search or a promise that a downloadable copy exists.

I founded Serpent API, so this field review is affiliated. On October 5, 2026, I checked its published video contract and TikTok’s Display API information. The example has no authenticated parsed production result. Verify access and a returned video ID before scheduling checks.

Start from a known video ID

Begin with a video ID or a canonical TikTok URL supplied by your own inventory. Decide which metadata actually drives the audit: publication date, author identity, text, engagement counts or media properties. Avoid requesting comments, related videos or a hosted copy if the basic fields answer the question.

The Serpent video contract says video_id or url is required. The response has video_id, video_url, description, created_at, author, media, stats and other structured fields. Validate the returned video_id before merging it with your existing record. Keep created_region distinct from creator region, and keep missing stats null rather than zero.

Keep stable IDs and nullable fields

TikTok’s official Display API focuses on videos for an authorized user. Serpent’s known-video route reads public metadata for an ID or URL, with optional enriched groups. This article has no authenticated parsed production result for its example request. Confirm availability and returned fields in your account before scheduling a job.

Save a video snapshot in Python

Set SERPENT_API_KEY and install requests. The example below includes request authentication, a bounded timeout, a parsed success check and explicit missing-data handling. Its syntax was checked; production values and access remain to be validated with an authorized account. Replace the illustrative handle, ID or tag with one you are permitted to review.

import os
from datetime import datetime, timezone
import requests

BASE = "https://apiserpent.com"
KEY = os.environ["SERPENT_API_KEY"]

def fetch(path, params):
    response = requests.get(BASE + path, params=params,
                            headers={"X-API-Key": KEY}, timeout=60)
    if response.status_code == 404:
        # HTTP status alone cannot separate route access from resource absence.
        return {"lookup": "unverified_404", "observed_at":
                datetime.now(timezone.utc).isoformat()}
    response.raise_for_status()
    data = response.json()
    if data.get("success") is not True:
        raise ValueError("No usable response")
    data["observed_at"] = datetime.now(timezone.utc).isoformat()
    return data

requested_id = "1234567890123456789"
data = fetch("/api/tiktok/video", {"video_id": requested_id})
if data.get("lookup") == "unverified_404":
    print({"video_id": requested_id, "status": "unverified API 404; check route access and request"})
else:
    if str(data.get("video_id")) != requested_id:
        raise ValueError("Video identity did not match")
    author = data.get("author") or {}
    stats = data.get("stats") or {}
    media = data.get("media") or {}
    if not all(isinstance(x, dict) for x in (author, stats, media)):
        raise ValueError("Unexpected metadata shape")
    print({"video_id": requested_id, "observed_at": data["observed_at"],
           "description": data.get("description"),
           "created_at": data.get("created_at"),
           "author_username": author.get("username"),
           "play_count": stats.get("play_count"),
           "comment_count": stats.get("comment_count"),
           "duration": media.get("duration"),
           "temporary_link_expires": media.get("link_expires_at")})

Interpret the printed record carefully. The code records individual nullable counts, not a made-up engagement score. If a link expiry is present, treat the link as a temporary display or download location; the video ID remains the durable key. The example does not request include_media, so it does not promise a hosted copy or incur that optional media surcharge.

Budget basic and enriched reads

At the documented Default rate, a basic TikTok video lookup without include_* groups is $0.10 per 1,000 calls. Checking 100 known IDs once is $0.01 in metered usage. Any enriched group moves to the enriched rate, and include_media adds a separate surcharge; a basic call with include_media plans at $10.10 per 1,000 at Default. Request that copy only when its short-lived output is actually needed.

These are dated contract calculations, not a live invoice or a guarantee of result quality. See Serpent pricing for current tier terms, and inspect your account ledger after a small verified run. Do not divide a bill by returned items when the published unit is a request or requested depth.

When authorized TikTok access fits

Why a video lookup may be incomplete

An unavailable video may be removed, restricted, temporarily inaccessible or entered with the wrong ID; a 404 alone cannot identify the cause. Counts and links can change between runs. Direct media links and their associated headers, when provided, are temporary and should be refreshed rather than stored as permanent records. This guide does not test download success or production delivery.

Choose an alert rule that the fields can support

Keep a baseline per returned video_id, not per media URL. A two-run comparison can flag a changed description or a higher numeric play count, but cannot reconstruct the full edit history or prove why a count changed. Compare only two numeric values observed for the same field; if either is null, the change is unknown. Store the observation time separately from created_at, which describes the video rather than your audit.

Request media only when a reviewer truly needs a temporary copy and is authorized to use it; otherwise retain the canonical video URL and stable ID. If an expiry is returned, schedule any authorized use before that time and never treat the link as an archive. Test a known permitted ID and compare the parsed fields and account charge before adding optional groups to a recurring job.

Check two observations before alerting

1. Start with a known video ID you are allowed to review, and confirm the endpoint is available before interpreting a 404.
2. Match the parsed video_id to the request and save caption, creation date, author and nullable counts with the observation time.
3. Open the current video page for a small spot check; treat expiring media links as temporary rather than permanent assets.
4. Repeat only the IDs whose fields affect your decision, and compare the actual charge with the documented lookup unit.

FAQ

Can this endpoint search TikTok for videos?

No. This workflow starts from a known video ID or URL. Search is a separate product and decision.

Does null play_count mean zero plays?

No. Keep null as unknown; only a measured numeric zero means zero in that field.

Is include_media required for video metadata?

No. The basic video metadata call does not need it. include_media requests a separate temporary hosted copy and adds a surcharge.

Can a 404 prove a video was deleted?

No. It can mean an incorrect ID, restricted access or unavailable content. Check the source and context.