# Kwai (Kuaishou Brasil) Scraper - Videos, Views & Creators (`lanternlab318/kwai`) Actor

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

## Pricing

$1.59 / 1,000 videos

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper (Kuaishou Brasil)

A Lantern Lab Actor. Give it keywords, creator profile URLs, or both, and get Kwai's public videos back: caption, creator, publish time, views, likes, comments, shares, duration, cover image and the video's own page URL. No Kwai login, no cookies, no account of your own.

**Price: $0.00159 per video — $1.59 per 1,000 — and no run-start fee.** Empty results, status rows and the run summary are free.

```json
{
  "searchQueries": ["bolo de cenoura", "futebol"],
  "profileUrls": ["https://www.kwai.com/@Futebolmulek"],
  "maxVideos": 100
}
```

```json
{
  "recordType": "video",
  "videoId": "5224325678129130006",
  "caption": "Leozinho pede demissão do Flamengo #Futebol",
  "authorName": "Futebol mulek",
  "authorHandle": "Futebolmulek",
  "authorId": "150001736669122",
  "authorIdKind": "kwai_user_id",
  "authorUrl": "https://www.kwai.com/@Futebolmulek",
  "publishedAt": "2026-10-23T20:51:50.773Z",
  "publishedAtRaw": "2026-10-23 17:51:50",
  "views": 434,
  "likes": 17,
  "comments": 1,
  "shares": 2,
  "durationMs": 63533,
  "durationSeconds": 64,
  "url": "https://www.kwai.com/@Futebolmulek/video/5224325678129130006",
  "coverUrl": "https://aws-br-pic.kwai.net/upic/...",
  "videoUrl": "https://aws-br-cdn.kwai.net/upic/...",
  "sourceType": "profile",
  "sourceQuery": null,
  "sourceProfileUrl": "https://www.kwai.com/@Futebolmulek",
  "rank": 1,
  "partial": false,
  "partialReason": null,
  "collectedAt": "2026-10-24T00:31:08.412Z"
}
```

### Limits, before you run it

- **A creator's whole public catalogue is reachable, but Kwai sometimes stops short.** The Actor pages down a creator's videos newest first until it has `maxVideos` or Kwai runs out. Kwai does not always serve as many as the creator's own page claims: when it stops early, that creator is `partial: true` with `partialReason: "platform_profile_limit"` and the row says how many of how many arrived. It never claims to have everything, and a creator Kwai refuses is `blocked`, never reported as having no videos.
- **A keyword is matched against Kwai's topic index.** A multi-word keyword works as a phrase: spaces become hyphens, the way kwai.com does it itself, so `bolo de cenoura` and `bolo-de-cenoura` reach the same list. It is not a boolean search; there is no `OR`, no quoting and no exclusion syntax.
- **Kwai's catalogue is one catalogue, not one per country.** The topic, search and creator lists this Actor reads return the same videos through a US datacenter IP as through a Brazilian residential one, so the cheap default proxy is also the correct one. You can still set a proxy country if you want to compare Kwai's country-specific recommendation surfaces.
- **`videoUrl` expires.** It is Kwai's own signed CDN link and stops working within hours of collection. `url` is the permanent public page; `coverUrl` is a plain image URL.
- No comments, no followers, no likers, no login-only or private content, no video download or transcription, no scheduling built in (use Apify schedules).

### What it does

- Looks up each keyword separately and labels every row with the keyword that produced it, so one run can cover many keywords and many creators at once.
- Deduplicates across the whole run: a video found by several of your keywords, or by a keyword and a creator, is written once and charged once.
- Keeps the source identifiers (`videoId`, `authorId`, `authorHandle`), the platform's own publish time (`publishedAt`, plus `publishedAtRaw` exactly as Kwai sent it) and our collection time (`collectedAt`) as separate fields. A field Kwai did not send is `null`, never guessed.
- Says what happened per keyword and per creator, on its own free `source_status` row. These are different records and are never confused:
  - a keyword Kwai answered with nothing is an **empty result**, `partial: false`;
  - a creator URL that resolves to nobody is `partial: true`, `partialReason: "profile_not_found"` — not a creator with zero videos;
  - a keyword or creator cut short by a limit, a refusal or an error is `partial: true` with the reason.
- Caps itself: `maxUpstreamRequests` is a hard ceiling on requests to Kwai for the whole run, derived from your input when you leave it empty, so a run is never unbounded.
- Writes a `RUN_SUMMARY` row last, and the same object to the run's key-value store: videos collected and charged, duplicates skipped, empty inputs, partial inputs by reason, requests sent, and why collection stopped.

### Input

| Field | Default | Meaning |
| --- | --- | --- |
| `searchQueries` | — | One keyword per line, in the language of the market you want. At least one of `searchQueries` or `profileUrls` is required. |
| `profileUrls` | — | One creator page per line: `https://www.kwai.com/@handle`. A video link, an `m.kwai.com` link or the bare `@handle` also work. |
| `maxVideos` | `100` | Upper bound on rows **per keyword and per creator**, not for the whole run. Three keywords at 100 can return 300 videos. Raise it to page deeper into a creator's back catalogue. |
| `maxUpstreamRequests` | derived | Hard ceiling on requests to Kwai for the whole run. Leave empty and the Actor works one out from your inputs and `maxVideos`. |
| `proxyConfiguration` | Apify Proxy (datacenter) | Where the requests come from. The datacenter default is what this Actor is measured on. |

### Output

Three row kinds, told apart by `recordType`:

| `recordType` | Charged | One per |
| --- | --- | --- |
| `video` | yes | collected video |
| `source_status` | no | keyword or creator |
| `RUN_SUMMARY` | no | run (always the last row) |

`partialReason` values: `platform_profile_limit`, `profile_not_found`, `upstream_request_cap`, `charge_limit_reached`, `blocked`, `upstream_error`, `not_collected`.

### What it collects

Only what Kwai shows on a public page, over public endpoints, without logging in, without cookies and without anyone's account. Creator fields are limited to the public display name, the public `@handle` and Kwai's own creator id. No email addresses, no phone numbers, no private or age-restricted content.

# Actor input Schema

## `searchQueries` (type: `array`):

One Kwai keyword per line, in the language of the market you want: "bolo de cenoura", "futebol", "maquiagem". Each keyword is looked up separately and its videos are labelled with it. Kwai matches a keyword against its topic index, so a multi-word keyword works as a phrase (spaces become hyphens, the way kwai.com itself does it) rather than as separate words. A video found by several of your keywords is returned once and charged once.

## `profileUrls` (type: `array`):

One Kwai creator page per line: "https://www.kwai.com/@handle". A link to one of the creator's videos, an m.kwai.com link or the bare @handle also work. Each creator's public videos are returned newest first, paging down their back catalogue until maxVideos is reached or Kwai runs out. When Kwai serves fewer than the creator's own page claims, that creator is marked partial and the row says how many of how many arrived, rather than being reported as complete.

## `maxVideos` (type: `integer`):

Upper bound on the rows one keyword or one creator may produce. It applies per input, not to the whole run: three keywords at 100 can return 300 videos. Raise it to page deeper into a creator's back catalogue; the run says per creator when Kwai stopped serving before that number was reached.

## `maxUpstreamRequests` (type: `integer`):

Hard ceiling on the HTTP requests this run sends to Kwai: keyword lookups, topic pages, creator headers and creator feeds together. At the ceiling collection stops - the inputs not reached are written with partialReason "upstream_request_cap" and the run then ends normally. Leave empty and the Actor works a ceiling out from your keywords, creators and maxVideos, so a run is never unbounded.

## `proxyConfiguration` (type: `object`):

Where the requests to Kwai come from. The default (Apify Proxy, datacenter) is the cheapest and is what this Actor is measured on; Kwai serves its public topic, search and creator lists over it without blocking, and returns the same catalogue it returns to a Brazilian residential IP. Set a proxy country only if you want to compare Kwai's country-specific recommendation surfaces.

## Actor input object example

```json
{
  "searchQueries": [
    "bolo de cenoura"
  ],
  "profileUrls": [],
  "maxVideos": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# 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 = {
    "searchQueries": [
        "bolo de cenoura"
    ],
    "profileUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("lanternlab318/kwai").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 = {
    "searchQueries": ["bolo de cenoura"],
    "profileUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("lanternlab318/kwai").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 '{
  "searchQueries": [
    "bolo de cenoura"
  ],
  "profileUrls": []
}' |
apify call lanternlab318/kwai --silent --output-dataset

```

## MCP server setup

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

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/ugH7XafxnTaSiHMUU/builds/SXEyQXSx1H6IkWugs/openapi.json