Kwai Video Details Scraper

Enrich tracked Kwai videos from supplied public video URLs. Get the exact string video ID, caption, creation time, creator details, thumbnail, media link and visible engagement in structured records for recurring content inventory.

This Actor is for analysts, social-media teams and content researchers who already have a list of public videos. It does not search keywords, enumerate creator feeds, download videos or access private content.

Who is it for?

Content analysts maintain tracked-video inventories, agencies revisit campaign links, and researchers compare public engagement snapshots. Supply the known URLs rather than searching for new content.

Why use this Actor?

• Match the exact supplied video ID, rather than accepting unrelated recommendations.
• Preserve long video identifiers as strings so spreadsheet and database joins remain accurate.
• Fetch only public page metadata, without downloading media assets.
• Revisit an existing list to compare engagement snapshots in your own pipeline.
• Receive predictable typed fields, with unavailable optional values represented as null.

Getting started

1. Copy a canonical public Kwai video URL from the website.
2. Add it to Public Kwai video URLs.
3. Choose a maximum number of records, from 1 to 100.
4. Start the Actor and inspect the default dataset.
5. Export the dataset or pass it to your downstream workflow.

The canonical format is https://www.kwai.com/@creator/video/STRING_ID. App share links and shortened URLs are not supported.

Input example

{
  "videoUrls": [
    "https://www.kwai.com/@futebolisticos702/video/5245717778425129393"
  ],
  "maxItems": 10
}

Public videos may later be removed or become unavailable. Replace a stale example with a currently accessible canonical URL.

Input parameters

Field	Meaning
videoUrls	Required array of 1–100 canonical HTTPS Kwai video URL strings.
maxItems	Global maximum matched records saved, 1–100, default 10. Zero/unlimited is unsupported.

Both kwai.com and www.kwai.com are accepted. Query strings and fragments are removed. Duplicate video IDs are fetched once, keeping the first supplied URL. All URLs are validated before work begins, even if the record limit is lower than the list length.

The Actor processes URLs sequentially in supplied order. It stops before fetching later URLs when the record limit or available billing budget is reached. There is no pagination, discovery mode or user-configurable proxy fallback.

Extracted data

Field	Description
inputUrl	Normalized supplied canonical video URL.
videoId	Exact source string ID, matched to the URL.
caption	Public caption, or null.
publishedAt	Source creation timestamp converted to ISO UTC.
creatorId	Public creator string ID.
creatorName, creatorHandle	Public display name and handle, or null.
creatorUrl	Public creator page link.
thumbnailUrl	Source thumbnail link.
mediaUrl	Source video link; may expire.
viewCount, likeCount	Visible public engagement counts, or null.
commentCount, shareCount	Visible comment and share counts, or null.
durationSeconds	Source duration in seconds, or null.
music	Optional {id, name, artist} object; values can be null. Entire object is null when absent.
scrapedAt	ISO time when the record was collected.

Counts reflect what the public source provides, not private analytics. A missing count is not reported as zero. Music was absent from the initial live samples and is not guaranteed on every video.

Output example

The following anonymized record preserves the shape and sample measurements of an actual response; creator identity, caption and media paths are illustrative.

{
  "inputUrl": "https://www.kwai.com/@exampleuser/video/5000000000000000001",
  "videoId": "5000000000000000001",
  "caption": "Example football video",
  "publishedAt": "2026-06-14T20:58:28.821Z",
  "creatorId": "3xexamplecreator",
  "creatorName": "Example Creator",
  "creatorHandle": "exampleuser",
  "creatorUrl": "https://www.kwai.com/@exampleuser",
  "thumbnailUrl": "https://aws-br-pic.kwai.net/example.webp",
  "mediaUrl": "https://aws-br-cdn.kwai.net/example.mp4",
  "viewCount": 772,
  "likeCount": 25,
  "commentCount": 2,
  "shareCount": 9,
  "durationSeconds": 14.978,
  "music": null,
  "scrapedAt": "2026-10-27T21:04:57.702Z"
}

How much does it cost to enrich Kwai videos?

Pay-per-event pricing includes one start event per run plus one item event per matched video record delivered. Duplicate inputs do not create additional item events. Failed or unmatched videos do not create item events; the start fee still applies after valid input begins processing.

At the BRONZE tier, the start fee is $0.001 per run and each delivered video costs $0.0014816. Estimated event charges are $0.0024816 for one video, $0.015816 for ten videos, and $0.14916 for 100 videos. Other subscription tiers have different per-video prices; check the pricing tab for your tier.

There are no separate creator, music, thumbnail or download events. A media URL is included metadata, not a downloaded file. Set your maximum total charge in Apify to control spending. A budget stop can produce a successful partial dataset.

Coverage and limitations

• Public canonical international Kwai video pages only.
• No keyword search, creator-feed enumeration, comment bodies or historical backfill.
• No private content, login, short-link expansion or media downloads.
• Media links can expire and may be region-dependent; their playback is not tested or guaranteed.
• Creator and engagement metadata are limited to the public source response.
• Scheduling runs does not create built-in alerts, change detection or cross-run deduplication.
• Source changes and availability restrictions can cause failures.

Failure behavior and troubleshooting

An unavailable, blocked, malformed or mismatched video fails the run clearly. The Actor never substitutes recommendations for the requested video and does not emit error rows as billable results. Earlier matched rows remain available as partial output if a later URL fails.

Transient network, rate-limit and temporary server failures have at most two retries per URL. Redirects are not followed. Invalid URL shapes are rejected before work; permanent access failures are not retried blindly.

Why does a video link fail? Check that the canonical website URL opens publicly. Private, removed, geo-restricted or app-only content may not expose the required data.

Why are there fewer rows than inputs? Check duplicate IDs, maxItems, billing limits and the terminal run status. Do not treat partial rows from a failed run as a complete inventory.

Integrations

• Export JSON or CSV to a data warehouse and join by string videoId.
• Schedule repeated runs over your tracked URL list; compare counts using scrapedAt in your own database.
• Connect Apify webhooks to Make or n8n after successful completion.
• Send selected metadata to a spreadsheet while retaining full rows in dataset storage.

Keep video IDs as text in spreadsheets to avoid rounding. Store each snapshot separately when building a time series.

API usage

Start the Actor using your own Apify token, then retain the returned run ID and storage IDs. Never put tokens in public files.

cURL

curl -X POST 'https://api.apify.com/v2/acts/automation-lab~kwai-video-details-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"videoUrls":["https://www.kwai.com/@futebolisticos702/video/5245717778425129393"],"maxItems":1}'

JavaScript

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/kwai-video-details-scraper').call({
  videoUrls: ['https://www.kwai.com/@futebolisticos702/video/5245717778425129393'],
  maxItems: 1,
});
if (run.status !== 'SUCCEEDED') throw new Error(`Run ${run.id}: ${run.status}`);
const page = await client.dataset(run.defaultDatasetId).listItems({ limit: 20, offset: 0 });
console.log(page.items);

Python

import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/kwai-video-details-scraper').call(run_input={
    'videoUrls': ['https://www.kwai.com/@futebolisticos702/video/5245717778425129393'],
    'maxItems': 1,
})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError(f"Run {run['id']}: {run['status']}")
page = client.dataset(run['defaultDatasetId']).list_items(limit=20, offset=0)
print(page.items)

Use with MCP

Scope the hosted Apify MCP server to this Actor:

claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/kwai-video-details-scraper'

For Claude Desktop, Cursor and VS Code, use the equivalent desktop/editor configuration below where HTTP MCP configuration is supported:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/kwai-video-details-scraper"
    }
  }
}

Authenticate using your client's supported Apify authorization mechanism. Discover actual names and argument schemas using scoped tools/list. Actor selection also adds run/data helpers; it does not expose exactly one tool.

Example prompt: “Enrich this public Kwai video URL and show its exact ID, creator, caption and engagement. Use maxItems 1.”

For an authorized invocation, start once and retain the run ID. A start response is metadata, not dataset rows. call-actor waits at most 45 seconds (default 30); use a client timeout longer than the selected wait plus transport margin. If still running, check that same run using bounded backoff of 2, 4, 8 seconds, capped at 10, with a 120-second total deadline. On timeout recover the known run, never restart just to poll. If its ID is unknown, report uncertainty. At deadline report pending and stop polling. Report terminal failures honestly and label any rows partial.

After success, use get-dataset-items with explicit dataset ID, offset, limit and needed fields from the discovered schema. An example consumer context budget is pages of 20 untransformed source rows, at most 100 rows and 64 KiB of serialized UTF-8 content across pages, whichever comes first. Enforce bytes host-side before model injection; disclose omitted or summarized oversized rows. If your client cannot intercept oversized responses, do not promise a hard byte bound. Track source offsets, stop at budget/exhaustion and state continuation offset plus truncated status. Keep full exports in storage outside model context. This is a consumer context limit, not a reduced Actor collection default. No universal token-savings claim is made.

Legality and responsible use

Privacy and data handling

Use only public content you are authorized to process. Respect applicable law, platform terms and intellectual-property rights. Public accessibility does not grant redistribution rights. This Actor is not affiliated with Kwai and does not bypass login or private-content restrictions.

Runtime extraction is deterministic and uses no AI model or paid external data API. Apify supplies compute, logs and result storage; Kwai receives the requested public page URLs. Storage follows your Apify account retention settings and can be deleted through Apify. There is no persistent cross-run cache. For help, open an issue on this Actor's Apify page with the run ID and a public example URL, never credentials.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed; reports are retained for 30 days. Do not submit secrets or private information as video inputs.

FAQ

Does it download video files? No. It returns source media URLs only.

Can I search keywords? No. Supply canonical video URLs; use a discovery Actor separately to obtain candidates.

Does it monitor automatically? You can schedule runs through Apify, but comparisons, alerts and cross-run state belong to your integration.

Is music always available? No. Music is optional and often absent from the public page state.

Related Actors

Use Kwai Keyword Video Discovery Scraper to find public video URLs by keyword, then pass selected canonical URLs here for tracked-video enrichment. The two Actors have different input contracts.