Best Douyin Data APIs in 2026: A Comparison Guide

Key takeaway (TL;DR) — Douyin has an official developer platform, but it serves authorized, account-linked workflows; there is no general, unauthenticated public-data API for arbitrary Douyin data. Third-party providers fill that gap and differ widely in coverage, pricing model, reliability and architecture. This guide covers the criteria that matter when choosing one, not a ranking of who is “best.”

Douyin is one of China’s largest short-video platforms. For AI agents, market researchers and data-driven applications, reading public Douyin data programmatically is often a requirement, and the official Douyin Open Platform is built around authorization and account-linked use cases rather than open data consumption.

That leaves a market of Douyin data API providers, each with different trade-offs. Choosing between them means understanding what your agent architecture actually needs, not just comparing feature lists.

Why Douyin data access is hard

Before evaluating services, understand the landscape:

The official APIs are scoped to authorized workflows. The Douyin Open Platform documents OpenAPI/SDK capabilities for authorization, publishing, account management and account-linked data, and Ocean Engine serves advertisers. Neither is a general API for reading arbitrary public data.
Anti-bot measures. Douyin uses device fingerprinting, rate limiting and behavioral checks, which makes self-built scrapers fragile.
Multiple data surfaces. Web, mobile app, creator platform, advertising tools and Xingtu (the influencer marketplace) each expose different data.
Frequent frontend changes. Client and web changes regularly break scrapers and unofficial integrations.
Legal obligations. China’s Personal Information Protection Law (PIPL) applies to processing personal information. Whether and how it applies depends on your use case; assess your own obligations and each provider’s terms rather than assuming an API makes a workload compliant.

The result: maintaining your own Douyin pipeline is expensive. Third-party APIs exist because the problem is hard enough to justify specialized services.

Evaluation criteria

Here’s what actually differentiates Douyin data API services:

1. Operation coverage

The most visible differentiator. “Operations” means distinct API endpoints with specific data retrieval capabilities. The tiers below are illustrative buckets for thinking about fit, not market data:

Coverage tier	Operations	Typical data surfaces	Use case fit
Basic	20–50	User profiles, basic video info	Simple monitoring
Mid-range	50–150	+ Comments, search, trending	Market research
Comprehensive	150–250	+ Creator platform, ads, marketplace	Competitive intelligence
Full-spectrum	250+	+ Xingtu, DOU+, most channels	Full agent integration

What to look for: Not just total count, but coverage across specific channels. Douyin’s public data is segmented across surfaces:

Index/Feed — Trending content, recommendations, hashtag pages
Web — Public profiles, video pages, search results
App (v3) — Mobile-app views of public profiles, videos and engagement counts
Billboard — Official rankings, hot topics
Xingtu — Public influencer-marketplace listings and creator signals
Creator — Creator-platform billboards (hot topics, music, props) and courses
DOU+ — DOU+ talent categories and video rankings
Search — Keyword-based content and user discovery

A service with 100 operations all focused on the web surface may be less useful than one with 80 operations spanning web, app, Xingtu and creator channels.

2. Pricing model

Three common models exist. The dollar figures below are hypothetical, chosen to show how the models compare; they are not quotes from any provider.

Per-call pricing:

Example: $0.001–0.005 per API call
Pros: Pay only for what you use, predictable unit economics
Cons: High-volume gets expensive
Best for: Agents with variable/unpredictable usage patterns

Subscription tiers:

Example: $99–499/month for X calls included
Pros: Predictable monthly cost, often cheaper at volume
Cons: Waste if usage is variable, cliff pricing at tier boundaries
Best for: Steady-state applications with predictable volume

Credit-based:

Buy credits, spend per operation (different ops cost differently)
Pros: Flexible allocation across expensive/cheap operations
Cons: Complex cost prediction, credits may expire
Best for: Teams using many different operation types

Hypothetical cost comparison at scale:

Monthly volume	Per-call ($0.001)	Per-call ($0.003)	Subscription ($299/100K)
10,000 calls	$10	$30	$299 (overpay)
50,000 calls	$50	$150	$299 (fair)
100,000 calls	$100	$300	$299 (break-even)
500,000 calls	$500	$1,500	Higher tier needed

For AI agents, per-call pricing usually fits better because agent workloads are bursty. You don’t want to commit to a tier when your agent might need 5,000 calls one week and 50,000 the next.

3. Sync vs async design

This matters for agent architectures.

Synchronous APIs:

Request → wait → response
Fits directly into agent tool-call patterns
No webhook infrastructure needed
Simpler error handling (HTTP status codes)
Constraint: operations must complete within a request timeout

Asynchronous APIs:

Request → task ID → poll/webhook → result
Supports long-running operations (bulk exports, deep crawls)
Requires callback infrastructure
More complex agent integration (state machines, polling loops)
Better for batch workloads

What agents need: Sync for real-time decision loops. If your agent is reasoning about a competitor’s latest video performance, it needs data in the same tool-call round, not in a callback that arrives later.

Single-object lookups (a profile, a video’s stats, one page of comments or search results) are natural sync calls. Measure latency yourself on the endpoints you’ll use (see the test checklist below). Async only pays off for bulk jobs like “export all videos from this account” or “crawl every comment on a post with tens of thousands of replies.”

4. Authentication and access model

How you authenticate shapes your integration architecture:

API key (simple):

Header: Authorization: Bearer sk-xxxxx

Easiest to integrate
Single credential per team
Rate limits tied to key

OAuth/Token refresh:

Get token → use until expiry → refresh

More secure for long-running agents
Adds complexity (token lifecycle management)
Some providers require this for premium operations

SDK-based:

client = DouyinDataClient(api_key="...", region="cn")
response = client.user.get_profile(user_id="...")

Convenience wrapper
May abstract away important details
Lock-in concern if SDK is proprietary

For agent integration, simple API key + REST endpoints is the easiest fit. Your agent’s tool-calling mechanism already handles HTTP requests. Adding OAuth token management or SDK dependencies adds complexity.

5. Reliability and SLA

Questions to ask any provider:

Is there a written uptime SLA? Look for a documented commitment with credits for downtime.
How do they handle Douyin-side changes? Platform updates can break data access. Recovery time matters.
What’s their per-operation error rate? High overall uptime can hide individual operations that fail more often.
Do they have status pages? Transparency about issues indicates maturity.
What’s the latency distribution? P50 and P99 matter more than averages.

Red flags:

No uptime commitment
“Best effort” language
No status page or incident history
Claims of “unlimited” rate limits (nothing is unlimited on Douyin)

6. Data freshness and caching

Not all “real-time” claims are equal:

Freshness level	Meaning	Typical use
Real-time	Fresh fetch on each request	Trending detection, live monitoring
Near-real-time	Cached for minutes	Most agent workflows
Cached	Cached for an hour or so	Batch analytics, reporting
Snapshot	Daily/weekly refresh	Historical analysis

For most agent use cases, near-real-time is enough. Only pay for true real-time when your agent genuinely needs to detect changes within seconds.

The market landscape in 2026

Without naming specific providers (the landscape shifts quickly), here’s how the market segments:

Segment 1: Full-spectrum platforms

Hundreds of operations
Multi-platform (Douyin + Weibo + Xiaohongshu + TikTok)
Unified authentication and billing
Per-call pricing
Sync-first design
Target audience: Agent developers, enterprise data teams

SandBase falls in this segment. As of 2026-10-01 the SandBase Douyin catalog shows 262 Douyin endpoints across the index, web, app-v3, billboard, xingtu-v2, xingtu, creator, DOU+ (douplus) and search channels; the creator-v2 channel has no callable endpoints right now. The catalog lists these data APIs as Free as of 2026-10-01; prices can change, so check the live model card before you budget. Scope: public, read-only data with one SandBase API key. SandBase is not an official Douyin partner, and the main catalog does not cover private accounts, DMs, owner-only analytics, publishing or account actions. More in the Douyin public data API overview.

The catalog page itself is the source for that count and the Free label:

SandBase Douyin API catalog page showing Douyin Endpoints with the 262 SHOWN counter and an endpoint marked Available and Free

Caption: The SandBase Douyin catalog shows “262 SHOWN” endpoints, and the selected endpoint is marked Available · Free (captured 2026-10-02).

Authentication-dependent capabilities. A few catalog entries are session-based rather than public lookups, for example douyin/web/query-user (takes a user ttwid cookie) and douyin/index/get-user-sub-word (described as the current logged-in user’s subscribed keywords). They are outside the public-data workflow in this guide.

Segment 2: Specialized providers

Fewer operations, often focused on one surface
Douyin-only or limited platform coverage
Often subscription-based pricing
Mix of sync and async
Target audience: Marketing teams, research firms

Segment 3: Scraping-as-a-service

Variable coverage (depends on what they can scrape)
Often async (headless browser behind the API)
Usually slower and less predictable than structured endpoints, because each request drives a browser
Can be cheaper at extreme volume
Target audience: One-off research, price-sensitive users

Segment 4: Official platforms

Douyin Open Platform: authorization, publishing, account management and account-linked data
Ocean Engine: advertising workflows
Requires developer/business onboarding and user authorization
The right choice when you act on behalf of your own or your users’ accounts

Need	Official Douyin Open Platform	Public-data API (e.g. SandBase)
Data scope	Data of accounts that authorized your app	Public, read-only data
Account authorization	Required (user OAuth)	Not used; one SandBase API key
Publishing / account actions	Supported for authorized accounts	Not supported
Onboarding	Developer and app review	Sign up and create an API key
Fits	Apps acting for their own users	Research, monitoring, agent tools on public data

Choosing by use case

For AI agent development

Priority order: Sync design → Coverage → Per-call pricing → Reliability

Agents need sync responses that fit tool-call patterns. Breadth of operations determines what decisions your agent can make. Per-call pricing matches bursty agent workloads. Reliability must be high enough that your agent can trust the data.

For competitive intelligence

Priority order: Coverage (public creator + Xingtu marketplace data) → Data freshness → Historical data → Pricing

You need public creator, content and marketplace data across channels. Freshness determines how quickly you spot trends. Historical snapshots you store yourself enable trajectory analysis.

For influencer marketing

Priority order: Xingtu coverage → Public creator metrics → Pricing → Bulk capability

The Xingtu marketplace is where public influencer listings live. You’ll make many calls evaluating candidates.

For trend detection

Priority order: Billboard + Search coverage → Latency → Real-time freshness → Cost

Speed matters more than breadth. You need trending data fast, and you need search to validate signals.

Integration patterns

Basic: Direct REST calls

The example calls one endpoint, douyin/app-v3/user-profile (endpoint reference). You need a SandBase API key; the rest of the Douyin catalog uses the same pattern.

import os
import httpx

SANDBASE_API_KEY = os.environ["SANDBASE_API_KEY"]
ENDPOINT = "https://api.sandbase.ai/v1/api/douyin/app-v3/user-profile"


async def get_douyin_user(sec_user_id: str) -> dict:
    async with httpx.AsyncClient(timeout=30) as client:
        response = await client.post(
            ENDPOINT,
            json={"sec_user_id": sec_user_id},
            headers={"Authorization": f"Bearer {SANDBASE_API_KEY}"},
        )
        response.raise_for_status()
        body = response.json()
    outputs = body.get("outputs") or []
    if body.get("status") != "completed" or not outputs:
        raise RuntimeError(
            f"SandBase call did not complete: {body.get('status')} {body.get('error')}"
        )
    data = outputs[0].get("data") or {}
    return data.get("user") or {}

This uses SandBase’s Model API route (POST /v1/api/douyin/app-v3/user-profile, Bearer auth, JSON body with only sec_user_id), not the catalog’s GET view. The endpoint reference below shows that route and the single required body field:

Caption: The user-profile reference documents POST /v1/api/douyin/app-v3/user-profile with sec_user_id as the only request field, matching the code above (captured 2026-10-02).

The reference documents the completed payload at outputs[0].data; the code raises an error when a call doesn’t complete. Swap in your provider’s URL and parameters if you use another service.

Tested on 2026-10-01 (UTC) against the public official account of People’s Daily:

curl -X POST https://api.sandbase.ai/v1/api/douyin/app-v3/user-profile \
  -H "Authorization: Bearer $SANDBASE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sec_user_id": "MS4wLjABAAAA8U_l6rBzmy7bcy6xOJel4v0RzoR_wfAubGPeJimN__4"}'

Trimmed response (most fields removed):

{
  "id": "54cc210f-6dff-487b-ad3e-21a3ccce34cb",
  "status": "completed",
  "model": "douyin/app-v3/user-profile",
  "outputs": [{
    "data": {
      "status_code": 0,
      "user": {
        "nickname": "人民日报",
        "unique_id": "rmrbxmt",
        "enterprise_verify_reason": "人民日报官方账号",
        "follower_count": 203209774,
        "aweme_count": 12276
      }
    }
  }]
}

The user fields above (nickname, unique_id, follower_count, aweme_count) come from that call. They are observed-only, not a documented guarantee, so read them with .get().

The endpoint’s model page is where to confirm the price before you budget:

Caption: The douyin/app-v3/user-profile model page lists Base price Free, sync execution and 1 input field, which supports the sync-call and pricing points above (captured 2026-10-02).

Agent tool pattern

Expose the same function as a tool so the model can call it inside its reasoning loop:

tools = [{
    "type": "function",
    "function": {
        "name": "get_douyin_user",
        "description": "Get the public profile of a Douyin account by sec_user_id",
        "parameters": {
            "type": "object",
            "properties": {
                "sec_user_id": {"type": "string", "description": "Douyin sec_user_id"}
            },
            "required": ["sec_user_id"]
        }
    }
}]

# When the model returns a get_douyin_user tool call, run
# get_douyin_user(args["sec_user_id"]) and send the result back as the tool message.

Batch pattern

import asyncio


async def batch_get_profiles(sec_user_ids: list[str]) -> list[dict]:
    tasks = [get_douyin_user(s) for s in sec_user_ids]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return [r for r in results if not isinstance(r, Exception)]

What to test before committing

Latency test. Make 100 calls to the most common operation you’ll use. Check P50 and P99.
Error rate test. Run 1,000 requests. What percentage fail? Are failures retryable?
Schema stability. Call the same endpoint daily for a week. Does the response structure change?
Rate limit behavior. What happens when you exceed limits? Graceful 429 or silent drops?
Edge cases. Try deleted accounts, accounts with no public videos, videos with no comments. How does the API handle them?
Cost projection. Estimate your monthly volume, multiply by unit price, add 20% buffer for retries.

The ecosystem view

Douyin data APIs don’t exist in isolation. For AI agents working across Chinese social platforms, you likely also need Weibo, Xiaohongshu and possibly TikTok data. Choosing a provider that covers multiple platforms with consistent interfaces reduces your integration burden and simplifies your agent’s tool definitions.

A unified platform approach means:

One authentication mechanism for all platforms
Consistent error handling patterns
Single billing relationship
Cross-platform correlation with less schema mapping

This is the advantage of ecosystem platforms over single-platform providers: not that any individual endpoint is better, but that the integration overhead is amortized across your entire data surface.

Ready to try it: create a SandBase API key, browse the Douyin catalog, or open the user-profile endpoint reference.

Conclusion

The “best” Douyin data API depends on what you’re building. For agent developers: prioritize sync design, per-call pricing and operation breadth across channels. For researchers: prioritize data freshness and historical depth. For marketers: prioritize Xingtu coverage and public creator metrics.

The hard part is no longer “can I get public Douyin data programmatically?” It’s “which service matches my architecture and use case?” Ask for documented SLAs and prices, then verify latency and error rates with your own calls.

Evaluate against the six criteria above, run the tests described, and choose the provider whose strengths align with your highest-priority needs.