# Kwai Video Details Scraper (`automation-lab/kwai-video-details-scraper`) Actor

Enrich supplied public Kwai video URLs with exact video IDs, captions, dates, creator metadata, media links and engagement counts. No search, downloads or login.

- **URL**: https://apify.com/automation-lab/kwai-video-details-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.89 / 1,000 video details

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 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

```json
{
  "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.

```json
{
  "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

```bash
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

```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

```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:

```bash
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:

```json
{
  "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](https://apify.com/automation-lab/kwai-keyword-video-discovery) to find public video URLs by keyword, then pass selected canonical URLs here for tracked-video enrichment. The two Actors have different input contracts.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/kwai-video-details-scraper/changelog.md

# Actor input Schema

## `videoUrls` (type: `array`):

1–100 HTTPS canonical URLs in the form https://www.kwai.com/@creator/video/STRING_ID. Both kwai.com and www.kwai.com are accepted. Query strings and fragments are removed; duplicate string video IDs are fetched once, keeping the first URL. Short links and search/profile URLs are rejected. An unavailable or mismatched video fails the run; earlier saved rows remain partial output.

## `maxItems` (type: `integer`):

Global maximum matched records saved per run, after ID deduplication, in supplied order. Defaults to 10; valid range 1–100. Zero/unlimited is not supported. Stops before fetching later videos when this limit or the billing budget is reached. No discovery or pagination is performed.

## Actor input object example

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

# Actor output Schema

## `dataset` (type: `string`):

Matched video metadata; earlier rows are partial if a later input fails.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "videoUrls": [
        "https://www.kwai.com/@futebolisticos702/video/5245717778425129393"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/kwai-video-details-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "videoUrls": ["https://www.kwai.com/@futebolisticos702/video/5245717778425129393"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/kwai-video-details-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "videoUrls": [
    "https://www.kwai.com/@futebolisticos702/video/5245717778425129393"
  ],
  "maxItems": 10
}' |
apify call automation-lab/kwai-video-details-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/kwai-video-details-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/clDM9WPMKdq1dbW0B/builds/NILaX872hZclvqKsa/openapi.json