Blog/Developer Tools/

Kuaishou Creator Research API Tutorial | SandBase

Build a Kuaishou creator-research workflow: search users, resolve a creator, and read their profile — one SandBase key, no Kuaishou login, no SDK.

By Sophie Lin
Dark cinematic render of a Kuaishou user search resolving into a creator profile card, feeding an agent core

If you research creators on Kuaishou (快手) — China’s second-largest short-video platform — you want a repeatable loop: search users for a niche, resolve the creators behind the strong results, and read each profile to rank them. This Kuaishou Creator Research API tutorial wires that loop with two SandBase endpoints so an agent can run it end to end. It builds on the Kuaishou public data API hub; read that first for the big picture.

Everything here is public, read-only data. There is no Kuaishou login and no SDK — a SandBase API key is still required to authenticate. The endpoint API reference is the source of truth for parameters and the response envelope. The reference guarantees only that envelope; the payload field names below come from calls I ran (tested on 2026-09-28, UTC) and are illustrative, observed-only — not documented guarantees — so confirm them against a live response.

Key takeaway

  • Two endpoints form the loop: search-user-v2 (find creators) → one-user-v2 (creator profile).
  • Each call is POST /v1/api/kuaishou/app/<path>, one SANDBASE_API_KEY.
  • Chain by natural inputs: a keyword drives search; a result’s user.user_id becomes the input for the profile call.
  • Page the search with the returned pcursor. Public, read-only data only.

SandBase vs. Kuaishou’s official channels

Your needUse
Public, read-only search and profilesSandBase Kuaishou public-data API
Post, act as an account, or use partner APIsKuaishou’s official channels
Private or account-only dataNeither public workflow

The workflow at a glance

  1. Search users with kuaishou/app/search-user-v2 using a keyword.
  2. Read the creator with kuaishou/app/one-user-v2 using a result’s user_id.

Each endpoint returns the shared envelope — an id, a status, the model, and the payload on a completed run.

SandBase Kuaishou API page with the endpoints used in this workflow The Kuaishou endpoints on SandBase — search-user-v2 and one-user-v2 drive this loop.

Step 0: one helper for every call

import os
import requests

API = "https://api.sandbase.ai/v1/api"
HEADERS = {
    "Authorization": f"Bearer {os.environ['SANDBASE_API_KEY']}",
    "Content-Type": "application/json",
}

def call(path: str, payload: dict) -> dict:
    resp = requests.post(f"{API}/{path}", headers=HEADERS, json=payload, timeout=70)
    resp.raise_for_status()
    body = resp.json()
    if body.get("status") != "completed":
        raise RuntimeError(body.get("error", {}).get("message", f"{path} did not complete"))
    # Envelope can vary: prefer a top-level `output`, else `outputs[0].data`.
    output = body.get("output")
    if output is None and body.get("outputs"):
        output = body["outputs"][0].get("data", {})
    return output or {}

Step 1: search users

data = call("kuaishou/app/search-user-v2", {"keyword": "美食"})
feeds = data.get("mixFeeds", [])
pcursor = data.get("pcursor")
for f in feeds[:5]:
    user = f.get("user", {}) if isinstance(f, dict) else {}
    print(user.get("kwaiId"), "-", user.get("fansCount"), "fans")

In the response I captured (search run id 760a7ea6-b480-40c2-8a91-fb551a2df9c1, tested on 2026-09-28, UTC), the payload carried a mixFeeds list and a pcursor. Each feed’s user object carried user_id, kwaiId, fansCount, and following — illustrative, observed-only fields. Read each with .get().

To page, resend search-user-v2 with the returned pcursor — confirm the exact parameter name against the reference.

SandBase API reference for the Kuaishou search-user-v2 endpoint The search-user-v2 reference — the source of truth for the keyword parameter and paging.

Step 2: read the creator

user_ids = {
    f.get("user", {}).get("user_id")
    for f in feeds if isinstance(f, dict) and f.get("user", {}).get("user_id")
}

for uid in list(user_ids)[:5]:
    profile = call("kuaishou/app/one-user-v2", {"user_id": str(uid)})
    author = profile.get("authorInfo", {}) or profile.get("userProfile", {})
    print(uid, "-", profile.get("totalPhotoLike"))

The one-user-v2 endpoint takes a user_id — a search result’s user.user_id works directly. In my run (profile run id 142efb32-7caf-47e1-a45e-37cf01c721e2), the payload carried authorInfo, userProfile, and totalPhotoLike — illustrative, observed-only fields the reference does not guarantee. Read the nested objects defensively.

SandBase API reference for the Kuaishou one-user-v2 endpoint The one-user-v2 reference — pass a user_id; a search result’s user.user_id works as that identifier.

Putting it together

def research(keyword: str, max_creators: int = 5):
    data = call("kuaishou/app/search-user-v2", {"keyword": keyword})
    feeds = data.get("mixFeeds", [])
    seen, creators = set(), []
    for f in feeds:
        if not isinstance(f, dict):
            continue
        uid = f.get("user", {}).get("user_id")
        if uid and uid not in seen:
            seen.add(uid)
            creators.append(call("kuaishou/app/one-user-v2", {"user_id": str(uid)}))
        if len(creators) >= max_creators:
            break
    return creators

Because both endpoints share the same envelope, the loop stays flat: one status check in call(...) and the user_id flowing from a search result into the profile lookup.

Common use cases

Creator shortlisting

Search a niche keyword, collect the user_ids from strong results, and rank creators by fansCount to build a shortlist. Input: a keyword. Output: ranked creator profiles. Endpoints: search-user-v2, one-user-v2.

Competitor and KOL research

Read a set of creators’ profile signals with one-user-v2 to compare reach and engagement (totalPhotoLike) across a niche. Input: user ids. Output: comparable creator profiles. Endpoint: one-user-v2.

Niche mapping

Search a topic and inspect the mixFeeds payload — creators and their fan counts — to map who leads a niche on Kuaishou. Input: a keyword. Output: a creator sample. Endpoint: search-user-v2.

Trend sampling

Poll a keyword’s search on a schedule to sample which creators surface for a topic over time. Because each result carries fan and engagement signals, you can feed the sample to a model for ranking. Input: a keyword. Output: a creator sample over time. Endpoint: search-user-v2.

Practical notes

  • Envelope can vary. The reference documents outputs[0].data; read either shape (prefer output, fall back to outputs[0].data).
  • Page with pcursor. Resend search-user-v2 with the returned value while more results exist.
  • Business fields are observed-only. Treat mixFeeds, user_id, fansCount, totalPhotoLike, and the like as observed and confirm live.
  • Public, read-only data only. No posting, no private/account-only data. Authenticate with a SandBase API key.
  • Be a good client. Retry with backoff on transient errors such as HTTP 429; page rather than hammering.

FAQ

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

How do I get from a search result to a creator profile? Each feed’s user object carries a user_id; pass it to one-user-v2.

How do I page through more results? The search payload carries a pcursor; resend search-user-v2 with it. Confirm the exact parameter against the reference.

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

Wrap up

Two endpoints, one envelope, a user_id flowing between steps — that is the whole creator-research loop. For the full endpoint catalog, see the Kuaishou public data API hub. When you are ready: