Blog/Developer Tools/

Kuaishou Public Data API | SandBase

Read public Kuaishou hot list, search, shopping rankings, and videos with one REST API. No Kuaishou login, no SDK — one SandBase key, built for agents.

By Sophie Lin
Dark cinematic render of Kuaishou hot-list, search, and video data flowing through one API conduit into an agent core

Kuaishou is one of China’s biggest short-video platforms, strong in lower-tier cities and live commerce — a hot list, comprehensive search, shopping rankings, and video streams that map directly onto trend research, e-commerce monitoring, and content analytics. Getting at it programmatically usually means reverse-engineering the app, rotating tokens, and rebuilding a scraper every time the app changes.

The SandBase Kuaishou public data API removes that setup tax. It reads the public Kuaishou hot list, search results, shopping rankings, and videos through plain REST endpoints — one SandBase API key, no Kuaishou login and no SDK. The endpoint API reference is the source of truth for each parameter and for the response envelope (id/status/model/outputs[0].data); the business-payload field names shown below are an illustrative shape, not a guaranteed schema, so confirm them against a live response.

This is not Kuaishou’s official open platform. Use Kuaishou’s official channels when you need authenticated member actions or a licensed data agreement. Use SandBase when your workflow needs public, read-only data for research and monitoring. Ready to try it? Get a SandBase API key and browse the Kuaishou endpoints.

Key takeaway

  • One API reads the public Kuaishou hot list, search results, shopping rankings, videos, and comments.
  • The Model API endpoints in this guide are called with POST /v1/api/kuaishou/<path> — pass only that endpoint’s params, no SDK, one SANDBASE_API_KEY.
  • Endpoints key off natural identifiers: a keyword for search, a photo_id for a video, or a user_id for a creator.
  • It returns public, read-only data only. There is no posting, no platform login or OAuth on your side, and no private data; authenticate with a SandBase API key.

Which Kuaishou API do you need?

Your needChooseWhy
Post, act as a member, or use account-authorized dataKuaishou’s official channelsMember and account operations run through Kuaishou directly.
Read the public hot list, search, shopping rankings, or videosSandBase Kuaishou public-data APIPlain REST, one SandBase key, structured JSON for read-only workflows.
Private or account-only dataNeither public workflowThat data is out of scope for this public-data guide.

What you can get from the Kuaishou API

The catalog spans an app surface and a web surface. Grouped by job:

  • Hot list & rankings — the trending hot list and shopping top list.
  • Search — comprehensive, live, and tag search by keyword.
  • Videos — a single video and its comments by photo_id.
  • Creators — public creator reads by user_id.

Check each endpoint’s live API reference for the exact surface and parameters before you build; availability differs by endpoint.

SandBase Kuaishou API page: description, capability tags, and the endpoint list The Kuaishou API page on SandBase — a tagged overview and the endpoint list, each with its path.

What Kuaishou provides vs. what SandBase adds

Public data comes from Kuaishou. SandBase does not own or operate Kuaishou; it provides a uniform API layer for eligible public-data workflows. Each capability becomes one stable endpoint, auth collapses to a single key, and responses come back as predictable JSON — so an agent can chain “read the hot list → search a keyword → read a video’s comments” along one convention instead of maintaining a scraper.

Quick start: your first call

SandBase exposes more than one API surface. The catalog may show GET paths under /apis/v1/...; this guide uses the vendor-qualified Model API path on each endpoint’s API reference. Do not swap the HTTP method or URL — follow the reference for the endpoint you choose.

Read the hot list:

import os
import requests

resp = requests.post(
    "https://api.sandbase.ai/v1/api/kuaishou/web/hot-list-v1",
    headers={
        "Authorization": f"Bearer {os.environ['SANDBASE_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={},
)
resp.raise_for_status()
body = resp.json()
if body.get("status") != "completed":
    error = body.get("error", {})
    raise RuntimeError(error.get("message", "Kuaishou request did not complete"))

# The reference only guarantees the envelope; business fields vary by endpoint — confirm against a live response.
for item in body["outputs"][0]["data"][:5]:
    print(item.get("rank"), item.get("name"), item.get("tagType"))
curl -X POST https://api.sandbase.ai/v1/api/kuaishou/web/hot-list-v1 \
  -H "Authorization: Bearer $SANDBASE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

Every response uses the same envelope: an id, a status, the model name, and an outputs array whose single item carries the payload under data. Branch on status before reading outputs[0].data, and check each endpoint’s reference for its run mode. The hot list returns its items as a list directly under data. The block below is an illustrative response shape — the field names are not a guaranteed schema, so confirm them against a live response, since payloads vary and change over time:

{
  "id": "0e6f9926-eb40-4d04-94bf-35b070748803",
  "status": "completed",
  "model": "kuaishou/web/hot-list-v1",
  "outputs": [
    {
      "data": [
        { "rank": 0, "name": "…", "tagType": "…", "viewCount": null }
      ]
    }
  ]
}

A failed or timeout run carries error and never outputs. Response shapes differ by endpoint — inspect one real response and map the exact path per endpoint.

SandBase API reference for a Kuaishou endpoint, showing the vendor-qualified URL and the response schema The endpoint API reference is the source of truth for each parameter name and response path.

Capability map

Capability clusterRepresentative endpointTypical use
Hot listkuaishou/web/hot-list-v1Trending-topic monitoring
Shopping rankingkuaishou/app/shopping-top-listLive-commerce and product tracking
Searchkuaishou/app/search-comprehensiveKeyword content discovery
Videokuaishou/web/one-video-v2Read a video by photo_id
Video commentskuaishou/app/video-commentEngagement and sentiment inputs

Paging differs by endpoint — several endpoints return or accept a cursor value such as pcursor. Read each endpoint’s schema.

SandBase Kuaishou endpoint list showing hot-list, search, shopping, and video endpoints with their paths A slice of the Kuaishou endpoint list across the app and web surfaces.

Chaining calls in an agent workflow

Because every endpoint shares the same auth and the same response envelope, an agent can walk from the hot list to a video’s comments without special-casing each surface. A common content-research pattern looks like this:

  1. Read the hot list. Call kuaishou/web/hot-list-v1 to get trending topics, then pick the ones you care about.
  2. Search the keyword. Call kuaishou/app/search-comprehensive with a keyword to pull matching videos, paging with the returned pcursor.
  3. Read a video. Call kuaishou/web/one-video-v2 with a photo_id, then kuaishou/app/video-comment for engagement inputs.

Each step returns the same { id, status, model, outputs } shape, so your agent branches on status once and reuses the same JSON-reading code across every step.

Common use cases

Kuaishou hot-list API for trend monitoring

Poll kuaishou/web/hot-list-v1 on a schedule to track trending topics — each item carries a name and a rank. Input: none. Output: a ranked list of trending topics. Endpoint: hot-list-v1.

Kuaishou shopping API for live-commerce research

Read kuaishou/app/shopping-top-list for the shopping top list. Input: none. Output: a ranked shopping list. Endpoint: shopping-top-list.

Kuaishou search API for content discovery

Run kuaishou/app/search-comprehensive with a keyword to survey content around a topic, then page with pcursor. Input: a keyword. Output: matching feeds. Endpoint: search-comprehensive.

Why run this at the API layer

You could point a headless browser at Kuaishou and parse the app’s payloads, but that path is fragile: the app changes, tokens rotate, and you maintain a scraper instead of shipping features. Reading through one uniform API means your code depends on named JSON fields and a single response envelope rather than an app internal. Auth is one key, and because every endpoint returns the same { id, status, model, outputs } shape, retries, logging, and error handling live in one helper you write once and reuse everywhere.

That uniformity is what makes the workflow composable for an agent. Swap the hot-list topic for any keyword, swap one photo_id for another, and the code path is identical. Add a fourth read — a creator’s videos, say — and it slots in behind the same status-checking helper. The practical payoff is that your time goes to what the data means for your research, not to keeping a scraper alive against a moving target. When you need more than single reads, check the live listing for the endpoint that fits and confirm its parameters before wiring it in.

Limitations and boundaries

  • Public, read-only data only. No posting, following, or private/account-only data.
  • Rate and volume. Treat responses as best-effort reads; as a client-side resilience measure, retry with backoff on transient errors such as HTTP 429.
  • Parameters and shapes follow the upstream surface. Identifiers vary (keyword, photo_id, user_id); paging is a per-endpoint cursor such as pcursor. Inspect a real response and read the schema first.
  • Verify endpoints against the live reference. Availability and fields can change; confirm before building on a specific endpoint.
  • This is not an official Kuaishou partnership. SandBase provides uniform access to public data; respect Kuaishou’s terms and applicable rules for your use case.

FAQ

Do I need a Kuaishou developer app or login? No. You authenticate to SandBase with your SANDBASE_API_KEY. These read endpoints do not require a Kuaishou account or OAuth on your side.

What identifies a video or creator? A photo_id for a video and a user_id for a creator. Search takes a keyword.

How does pagination work? Search and feed endpoints return or accept a cursor value such as pcursor — pass it back to fetch the next page. Read each endpoint’s schema.

Can I read private or account-only data? No. The API returns public data only. Private and account-authorized content are out of scope.

Start with the hot list

Create a SandBase API key, call hot-list-v1, and inspect the returned schema before you expand to search, shopping, or videos. When you are ready: