How to Keep TikTok Search Results When Parsing JSON

When searching for TikTok videos through an API, videos may not appear in the array that a handler checks first. In a verified jsonscraper response to `\/searchVideo`, `aweme_list` was empty, while video data appeared in `search_item_list[].aweme_info`. If your code reads only `aweme_list`, it will save zero videos even though the response contains results. For developers, this is a specific reliability task: extract both data structures and normalize them into a single list before saving them to a database or sending them to a report.

You can check a live example and the endpoint description in the jsonscraper API specification and the TikTok endpoint documentation. The schema snapshot in the specification is dated October 25, 2026; it demonstrates the structure of a specific response, but does not guarantee that every field will appear in every subsequent request.

Why a parser can return an empty list

The `GET https:\/\/tiktok.evelode.com\/searchVideo` endpoint searches for videos using the required `keyword` parameter. The documentation also lists `cursor`, `count`, `cache_timeout`, `date_posted`, `sort_by`, and `region`. In the observed response schema, the top-level object contains `status` and a nested `tiktok` object; the latter contains `cursor`, `has_more`, `status_code`, `aweme_list`, and `search_item_list`.

In one observed request using a keyword and `count=3`, the `aweme_list` array was empty. At the same time, `search_item_list` contained items whose video details were in `aweme_info`. These objects could include video IDs, captions, post URLs, author details, and statistics such as views, likes, or comments. These fields describe the observed schema; your handler should still allow for missing values.

The practical takeaway is that a successful HTTP request and a nonempty array in one expected field are two different checks. First check the outer status and whether `tiktok` is present, then collect videos from every documented location. For analytics, save the IDs and the original response so you can trace how each record was extracted and normalized.

Normalize the response before storing it

A convenient boundary between the API and your own system is a function that accepts the nested `tiktok` object and returns uniform items. It should handle both arrays, skip non-dictionary or empty items, and remove duplicate videos by `aweme_id`. Leave counters empty when the provider does not return them: zero would mean a measured value, whereas `None` indicates a missing field.

Here is a minimal example for Python 3.8+. It makes one request, checks the transport and top-level status, normalizes both result variants, and prints selected fields. The key is read from an environment variable and is not printed to the log.

import os
import requests

BASE_URL = "https:\/\/tiktok.evelode.com"


def extract_videos(tiktok):
    candidates = []
    aweme_list = tiktok.get("aweme_list") or []
    if isinstance(aweme_list, list):
        candidates.extend(aweme_list)

    search_items = tiktok.get("search_item_list") or []
    if isinstance(search_items, list):
        for item in search_items:
            if isinstance(item, dict):
                candidates.append(item.get("aweme_info"))

    unique = {}
    for video in candidates:
        if not isinstance(video, dict):
            continue
        video_id = video.get("aweme_id")
        if video_id:
            unique[video_id] = video
    return list(unique.values())


license_key = os.environ["JSONSCRAPER_TIKTOK_LICENSE_KEY"]
response = requests.get(
    BASE_URL + "\/searchVideo",
    params={
        "license_key": license_key,
        "keyword": "python tutorial",
        "count": 10,
        "region": "US",
    },
    timeout=30,
)
response.raise_for_status()
payload = response.json()

if payload.get("status") != "ok":
    raise RuntimeError("TikTok API returned a non-ok status")

tiktok = payload.get("tiktok")
if not isinstance(tiktok, dict):
    raise RuntimeError("Response has no tiktok object")

for video in extract_videos(tiktok):
    stats = video.get("statistics") or {}
    author = video.get("author") or {}
    print({
        "aweme_id": video.get("aweme_id"),
        "desc": video.get("desc"),
        "share_url": video.get("share_url"),
        "author": author.get("unique_id"),
        "play_count": stats.get("play_count"),
        "digg_count": stats.get("digg_count"),
        "comment_count": stats.get("comment_count"),
    })

Install the dependency with python -m pip install requests, set `JSONSCRAPER_TIKTOK_LICENSE_KEY` in the runtime environment, and save the file, for example, as `search_videos.py`. The request parameters match the documented names: `keyword`, `count`, and `region`; `license_key` is passed as a query parameter. The code assumes the response contains `status: "ok"`, as in the recorded example. If the API returns a different status, processing stops before the questionable structure is passed on.

Turn the example into a repeatable collection process

For a one-time export, it is enough to write normalized items to JSON Lines or a table. In a persistent process, also save the original response with the retrieval time and search query. A separate table of normalized videos can use `aweme_id` as its key: repeated results update the record, while the same ID in both arrays does not create a duplicate.

To request the next page, the documentation specifies the `cursor` parameter: pass along the value received in the previous response. Treat it as an opaque token—store and return it without modification. The pagination loop should stop when `has_more` indicates there is no continuation or when the API provides no usable cursor; limit the number of pages per run so faulty logic cannot create an infinite loop. The recorded sources confirm the parameter name and the presence of `cursor` and `has_more` fields in the observed schema, but do not guarantee complete results.

When monitoring several search phrases, store the phrase alongside the video ID and collection time. You can then build query-level slices, compare results between runs, and send new IDs to a queue for further classification. Such a system describes the search results received; its dataset depends on the query, region, time, and the API items actually returned.

Check data quality, not just request success

After normalization, it is useful to track simple technical metrics for your pipeline: the number of records from each array, the number of unique IDs, the share of items without an ID, and the share of items without statistics. These are metrics for processing a specific response, not estimates of video popularity. For example, an increase in items without `play_count` means analytics should preserve the unknown value and mark the field as incomplete instead of substituting zero.

Do not tie subsequent calculations to the assumption that every video has the same set of statistics. Keep the entire JSON for raw data; in an analytics table, select only the fields you need and allow `NULL`. If the response format changes, the archived original will let you rerun the normalizer without making another request.

Pass the API key through CI secrets or orchestrator environment variables. Do not include it in URLs saved to logs, print the request parameter object, or store the key alongside raw responses. For scheduled runs, add a request timeout, HTTP error handling, and retries with a delay; store the cursor only with its specific search query so you do not mix pages from different result sets.

The result: one unified table instead of missing videos

After normalization, downstream code gets one list of videos regardless of whether an item arrived in `aweme_list` or `search_item_list[].aweme_info`. IDs allow duplicates to be removed, while optional fields remain explicitly empty. This reduces the risk of empty reports caused by reading only one array and makes the next step—exporting, filtering, or classification—more predictable.

You can start your check on the TikTok Scraper API page, which lists the base API URL and provides access to a demo. Use the official documentation for integration and first test your handling with a small number of items; increase `count` as needed and continue through the results using the documented cursor. The result is a clean data layer for your tasks, not an assumption of complete TikTok coverage.