# WeChat Channels Scraper — 视频号 Video Search (`sian.agency/wechat-channels-scraper`) Actor

Search WeChat Channels (视频号) short-form videos by keyword and export clean datasets — video titles, direct video URLs, cover images, creators, publish dates, and engagement signals. No account or API key needed.

- **URL**: https://apify.com/sian.agency/wechat-channels-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Social media, Videos, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $48.00 / 1,000 account video results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## WeChat Channels Scraper — 视频号 Video Search & Export 🚀

[![Store - SIÁN Agency](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Store - WeChat Official Accounts](https://img.shields.io/badge/Store-WeChat%20Official%20Accounts-07C160)](https://apify.com/sian.agency/wechat-official-accounts-scraper?fpr=sian) [![Store - Kwai Kuaishou](https://img.shields.io/badge/Store-Kwai%20Kuaishou-FF4906)](https://apify.com/sian.agency/kwai-kuaishou-scraper?fpr=sian) [![Store - Douyin Shop](https://img.shields.io/badge/Store-Douyin%20Shop-161823)](https://apify.com/sian.agency/douyin-shop-scraper?fpr=sian)

#### 🎉 Search WeChat Channels (视频号) videos, find creators, and pull their full video catalogs — with direct video URLs and no WeChat account
##### Built for China-market researchers, brand monitors, and content teams who need 视频号 data without a phone, login, or API key

---

### 📋 Overview

**Looking inside WeChat Channels shouldn't require a phone in hand.** This actor covers **WeChat Channels (视频号)** — Tencent's fast-growing in-app short-video feed — across **four operations**: search videos by keyword, find creator accounts by name, pull a creator's full video catalog, and resolve a video to its creator. Clean, structured JSON out — no WeChat account, login, or API key.

**Why teams choose this WeChat Channels scraper:**
- 🎬 **Direct video URLs you can't get in the app**: WeChat Channels has **no built-in download** — these direct CDN video links are the only way to grab the actual video file, on every search result.
- 🧩 **Four operations in one actor**: Keyword video search, creator account lookup, a creator's full video list, and export-ID → creator resolution — chain them into a full 视频号 workflow.
- ⚡ **Smart de-duplication**: WeChat Channels recycles results across deep pages. We dedupe automatically and never charge you twice for the same row.
- 💰 **Pay-per-unique-result**: You're billed only for unique rows saved, plus a tiny run-start fee. No account, no API key, no monthly subscription.
- 💎 **Chinese + English keywords**: Search 人工智能, 美食, 旅游 or brand and product names in any language.
- ✨ **Clean camelCase output**: Curated fields (videoTitle, videoUrl, v2Name, nickname…) plus the full raw payload for power users.

---

### ✨ Features

**Four operations:**
- 🔍 **Video Search** (`searchVideo`): Find WeChat Channels videos for any keyword, fresh on every run.
- 👤 **Account Search** (`searchAccount`): Look up creator accounts by display name — verified profession, signature, avatar, and the creator's `v2Name`.
- 🎬 **Account Videos** (`accountVideos`): Pull a creator's full video list by `v2Name` — object IDs, media type, and engagement.
- 🔗 **Resolve Export ID** (`convertExportId`): Turn a video's `exportId` into its canonical object ID + creator.

**Plus:**
- 🎬 **Direct Video & Cover URLs**: Playable CDN video links + cover images for every search result.
- 👤 **Creator Capture**: Account name and avatar for each video.
- 📅 **Publish Metadata**: Epoch + ISO publish dates, duration, and "X minutes ago" relative time.
- 🔥 **Engagement Signals**: Hot-content flag and like counts where the source exposes them.
- ♻️ **Automatic De-duplication**: Cross-page duplicates removed before they reach your dataset.
- 📊 **Two Dataset Views**: A full Overview of every field plus a curated Key-fields view.
- 🧾 **HTML Run Report**: Unique-video count, duplicate-skip count, pages fetched, and duration — saved every run.

---

### 🎬 Quick Start

Pick the **Video Search** operation, type a keyword, set how many unique videos you want, and run. Results land in the dataset within seconds.

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~wechat-channels-scraper/runs?token=YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"operation": "searchVideo", "keyword": "人工智能", "maxResults": 50}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Enter a keyword

Type any search term — Chinese gives the richest results (try 人工智能, 美食, 健身), but English and brand names work too.

#### Step 2: Set your target

Choose how many **unique** videos you want (default 50). The actor paginates and de-duplicates until it hits the target or the feed runs dry.

#### Step 3: Run and export

Download your dataset as JSON, CSV, or Excel — one clean row per unique video.

**That's it! In under a minute, you'll have:**

- A de-duplicated list of WeChat Channels videos for your keyword
- Direct video URLs + cover images, ready to use
- Creator names, publish dates, and engagement signals

***

### ℹ️ Scope

This actor covers **WeChat Channels (视频号)** across four operations: **video search**, **account search** (creators by name), **account videos** (a creator's full video list), and **export-ID resolution** (video → object ID + creator). Per-video comments, full metrics, and downloads are **not currently reliable from the data source** and are intentionally excluded — we ship only the endpoints that consistently return clean data, and will add more as they stabilize. Video search already includes direct video URLs, covers, creators, publish dates, and engagement signals for every match.

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| operation | string | Yes | One of: `searchVideo`, `searchAccount`, `accountVideos`, `convertExportId`. |
| keyword | string | For search ops | **Video Search**: the term to search videos for. **Account Search**: the creator's exact display name (e.g. 央视新闻). Chinese, English, or brand names. |
| v2Name | string | For `accountVideos` | The creator's `v2Name` (`v2_...@finder`) — from an Account Search result or a Resolve Export ID result. |
| exportId | string | For `convertExportId` | A video's `exportId` from a Video Search result — resolves it to object ID + creator. |
| maxResults | integer | No | Target unique rows for the paginated ops (Video Search, Account Videos). Default 50, range 1–1000. Billed per unique row. |

**Video Search** — find videos by keyword:

```json
{ "operation": "searchVideo", "keyword": "人工智能", "maxResults": 50 }
```

**Account Search** — find a creator by display name:

```json
{ "operation": "searchAccount", "keyword": "央视新闻" }
```

**Account Videos** — pull a creator's catalog (use a `v2Name` from Account Search):

```json
{ "operation": "accountVideos", "v2Name": "v2_060000231003b20faec8c5...@finder", "maxResults": 50 }
```

**Resolve Export ID** — turn a video's `exportId` into its object ID + creator:

```json
{ "operation": "convertExportId", "exportId": "export/UzFfBgAAxN6gICpvEmDJ..." }
```

***

### 📤 Output

Results are saved to the Apify dataset — one flat row per **unique** result, with curated camelCase aliases plus the raw upstream fields spread alongside. Every row carries `_operation` and `status` so you can tell rows apart and filter errors.

**Video Search (`searchVideo`)** — one row per unique video:

| Field | Type | Description |
|-------|------|-------------|
| videoTitle | string | Video caption (search-highlight markup stripped) |
| videoUrl | string | Direct CDN video URL |
| coverImage | string | Cover / thumbnail image URL |
| duration | string | Video length (mm:ss) |
| pubTime | number | Publish time (epoch seconds) |
| pubDate | string | Publish time (ISO 8601) |
| relativeTime | string | Human-readable "X ago" |
| accountName | string | Creator / account name |
| accountAvatar | string | Creator avatar URL |
| isHot | boolean | Whether the source flags the video as trending |
| likeNum | number | Like count (when exposed by the source) |
| docID | string | Stable video identifier (used for de-duplication) |
| width / height | number | Video pixel dimensions |

**Example:**

```json
{
  "videoTitle": "15亿部iPhone一夜升级AI！Siri接入谷歌万亿大模型",
  "videoUrl": "https://findermp.video.qq.com/251/20302/stodownload?...",
  "coverImage": "https://findermp.video.qq.com/251/20304/stodownload?...",
  "duration": "02:51",
  "pubTime": 1780973060,
  "pubDate": "2026-06-09T04:04:20.000Z",
  "relativeTime": "4分钟前",
  "accountName": "AI壹号",
  "accountAvatar": "https://wx.qlogo.cn/finderhead/ver_1/...",
  "isHot": false,
  "likeNum": 1,
  "docID": "finderobjv0XJY/B7T1oJa5RWDlp86dMw0H...",
  "width": 1080,
  "height": 1920,
  "status": "success"
}
```

**Account Search (`searchAccount`)** — one row per creator: `v2Name` (use it for Account Videos), `nickname`, `avatar`, `signature`, `authProfession` (verified org/profession), `boundOfficialAccount`, `liveStatus`, plus the raw account payload.

**Account Videos (`accountVideos`)** — one row per video in the creator's catalog: `objectId`, `objectNonceId`, `mediaType`, `favCount`, `_sourceV2Name`, plus raw fields.

**Resolve Export ID (`convertExportId`)** — a single row: `objectId`, `nickname`, `v2Name`, `exportId`.

***

### 💼 Use Cases & Examples

#### 1. WeChat Channels Content Discovery

**Content and social teams tracking what's being published on a topic.**

**Input:** A topic or hashtag keyword
**Output:** A de-duplicated feed of matching videos with creators and publish dates
**Use:** Schedule daily runs to monitor a niche and surface fresh 视频号 content.

#### 2. Brand & Competitor Monitoring

**Brand managers watching how a brand or campaign shows up on WeChat Channels.**

**Input:** A brand, product, or campaign keyword
**Output:** Matching videos, who posted them, and when
**Use:** Spot organic mentions, knockoffs, and competitor activity over time.

#### 3. Trend & Hashtag Research

**Strategists mapping rising topics on China's biggest in-app video feed.**

**Input:** A seed keyword or hashtag
**Output:** Video titles + creator names for the term
**Use:** Identify emerging narratives, formats, and creators in a space.

#### 4. Video Asset Collection

**Researchers and media teams building corpora for a keyword.**

**Input:** A keyword + a high maxResults target
**Output:** Direct video URLs and cover images for every unique match
**Use:** Feed downstream media pipelines, mood boards, or analysis tools.

#### 5. Market & Audience Intelligence

**Analysts measuring how active a niche is and who produces for it.**

**Input:** A category keyword
**Output:** Creator names and publish dates across results
**Use:** Quantify content velocity and map the creator landscape in a vertical.

#### 6. Creator Tracking & Catalog Pulls

**Agencies and analysts monitoring specific 视频号 creators.**

**Input:** A creator's display name → **Account Search** → their `v2Name` → **Account Videos**
**Output:** The creator's full video catalog with object IDs, media type, and engagement
**Use:** Track an influencer's output over time, benchmark competitors, or build a per-creator content archive.

***

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/wechat-channels-scraper').call({
  operation: 'searchVideo',
  keyword: '人工智能',
  maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/wechat-channels-scraper').call(
    run_input={'operation': 'searchVideo', 'keyword': '人工智能', 'maxResults': 50}
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~wechat-channels-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"operation": "searchVideo", "keyword": "人工智能", "maxResults": 50}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule or webhook
2. **HTTP Request**: Call the actor API
3. **Process**: Handle the JSON results
4. **Action**: Save, notify, or transform

***

### 📈 Performance & Pricing

#### FREE Tier (Try It Now)

- Search WeChat Channels and collect unique videos — full feature access, same quality
- No credit card required
- Perfect for testing and small projects

#### PAID Tier (Production Ready)

- Collect up to 1,000 unique videos per run
- Pay-per-result: charged only for **unique** videos saved (duplicates are free)
- No account, no API key, no monthly subscription

💰 **You never pay twice for the same video** — built-in de-duplication keeps your bill tied to real, unique results.

🔗 [View current pricing](https://apify.com/sian.agency/wechat-channels-scraper?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: How many videos can I collect per run?**
A: Set any target from 1 to 1,000 unique videos. The actor stops when it hits your target or the search is exhausted.

**Q: Why did I get fewer videos than I asked for?**
A: WeChat Channels search recycles the same videos across deeper pages. We de-duplicate and stop once the feed stops returning new results — so you only get (and pay for) genuinely unique videos.

**Q: Can I get a specific creator's full video list?**
A: Yes — use **Account Search** to find the creator (you'll get their `v2Name`), then **Account Videos** with that `v2Name` to pull their full video catalog. Per-video comments and detailed metrics aren't reliable from the data source yet, so they're intentionally excluded.

**Q: Can I download WeChat Channels videos?**
A: WeChat Channels has no built-in download. Every **Video Search** result includes the direct CDN `videoUrl` — that's the actual video file, which you can fetch and save yourself.

**Q: Do I need a WeChat account or API key?**
A: No. Just enter a keyword and run.

**Q: What output formats are available?**
A: JSON, CSV, and Excel — export directly from the Apify dataset.

**Q: Do Chinese keywords work better than English?**
A: Chinese keywords usually return the richest results, but English and brand names work too.

**Q: Is this legal?**
A: Yes — we only extract publicly available data. See the legal section below.

***

### 🐛 Troubleshooting

**Search returns 0 results**

- Try a broader or more common keyword.
- Chinese keywords typically return more results than English ones.

**Fewer unique videos than expected**

- This is normal — WeChat Channels recycles results across pages. The actor de-duplicates and stops when no new videos appear. Try a more popular keyword for higher volume.

**"This operation is not currently available"**

- The data source is temporarily unavailable. Wait a few minutes and re-run; the actor retries transient errors automatically.

***

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### ⚠️ Trademark Disclaimer

WeChat, WeChat Channels, 视频号, and Weixin are trademarks of Tencent Holdings Limited. This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Tencent**. It accesses only publicly available data. All product names, logos, and brands are property of their respective owners and are used for identification purposes only.

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's Issues tab
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `operation` (type: `string`):

What to scrape.

## `keyword` (type: `string`):

For **Video Search**: the term to search videos for (Chinese gives the richest results — try 人工智能, 美食, 旅游). For **Account Search**: the creator's exact display name (e.g. 央视新闻, 人民日报). Not used by the other operations.

## `v2Name` (type: `string`):

For **Account Videos** only. The creator's `v2Name` (a `v2_...@finder` identifier) — get it from an **Account Search** result's `v2Name` field, or from a **Resolve Export ID** result.

## `exportId` (type: `string`):

For **Resolve Export ID** only. The `exportId` from a **Video Search** result — resolves it to the canonical object ID, creator nickname, and creator `v2Name`.

## `maxResults` (type: `integer`):

Target number of unique rows for the paginated operations (Video Search, Account Videos). The actor paginates and de-duplicates until it hits this target or results are exhausted. You are billed only per unique row saved. Default 50. Range 1–1000.

## Actor input object example

```json
{
  "operation": "searchVideo",
  "keyword": "人工智能",
  "v2Name": "v2_060000231003b20faec8c5...@finder",
  "exportId": "export/UzFfBgAAxN6gICpvEmDJ...",
  "maxResults": 50
}
```

# Actor output Schema

## `output` (type: `string`):

WeChat Channels video search results — one flat row per unique video with videoTitle, videoUrl, coverImage, duration, pubDate, accountName, engagement signals, and the raw upstream fields.

## `report` (type: `string`):

HTML report with run status, unique-video count, duplicate-skip count, pages fetched, duration, and the inputs used — written even on fatal crash.

# 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 = {
    "keyword": "人工智能",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/wechat-channels-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 = {
    "keyword": "人工智能",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/wechat-channels-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keyword": "人工智能",
  "maxResults": 50
}' |
apify call sian.agency/wechat-channels-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sian.agency/wechat-channels-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WeChat Channels Scraper — 视频号 Video Search",
        "description": "Search WeChat Channels (视频号) short-form videos by keyword and export clean datasets — video titles, direct video URLs, cover images, creators, publish dates, and engagement signals. No account or API key needed.",
        "version": "1.0",
        "x-build-id": "Opk9zNKFXrpvEKhrZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~wechat-channels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-wechat-channels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sian.agency~wechat-channels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-wechat-channels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sian.agency~wechat-channels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-wechat-channels-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "searchVideo",
                            "searchAccount",
                            "accountVideos",
                            "convertExportId"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "searchVideo"
                    },
                    "keyword": {
                        "title": "Keyword / Account name",
                        "type": "string",
                        "description": "For **Video Search**: the term to search videos for (Chinese gives the richest results — try 人工智能, 美食, 旅游). For **Account Search**: the creator's exact display name (e.g. 央视新闻, 人民日报). Not used by the other operations."
                    },
                    "v2Name": {
                        "title": "Account ID (v2Name)",
                        "type": "string",
                        "description": "For **Account Videos** only. The creator's `v2Name` (a `v2_...@finder` identifier) — get it from an **Account Search** result's `v2Name` field, or from a **Resolve Export ID** result."
                    },
                    "exportId": {
                        "title": "Video Export ID",
                        "type": "string",
                        "description": "For **Resolve Export ID** only. The `exportId` from a **Video Search** result — resolves it to the canonical object ID, creator nickname, and creator `v2Name`."
                    },
                    "maxResults": {
                        "title": "Max unique rows",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Target number of unique rows for the paginated operations (Video Search, Account Videos). The actor paginates and de-duplicates until it hits this target or results are exhausted. You are billed only per unique row saved. Default 50. Range 1–1000.",
                        "default": 50
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
