# TikTok Scraper v2 (`cryptosignals/tiktok-scraper-v2`) Actor

Scrape TikTok profiles, hashtags, and videos.

- **URL**: https://apify.com/cryptosignals/tiktok-scraper-v2.md
- **Developed by:** [Web Data Labs](https://apify.com/cryptosignals) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$400.00 / 1,000 result scrapeds

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

## TikTok Scraper — Profiles, Hashtags & Video Data

Scrape TikTok data without the official API — **no API key needed**. Extract user profiles, video statistics, hashtag content, and individual video details. Export to **JSON, CSV, Excel**, or connect via **Zapier / Make.com** integration.

### Why Use This TikTok Scraper?

TikTok's official API has strict rate limits, requires business verification, and doesn't expose all the data available on the web. This scraper extracts data directly from TikTok's web interface, giving you access to complete profile data, video statistics, and hashtag content — all without any API key.

**No API key needed.** No TikTok developer account or business verification required. Just configure your input, run the actor, and download structured data.

### Key Features

- **Profile scraping** — extract user info, follower counts, bio, verification status, and recent videos
- **Hashtag discovery** — find trending videos for any hashtag with full engagement data
- **Video details** — get complete stats for any specific TikTok video
- **Engagement metrics** — views, likes, comments, shares, saves for every video
- **Music & hashtag data** — track name, artist, and all hashtags used in videos
- **No API key needed** — zero setup, no TikTok developer account required
- **JSON & CSV export** — download results in JSON, CSV, Excel, XML, or RSS
- **Zapier / Make.com integration** — connect to 5,000+ apps via webhooks
- **Up to 1,000 videos** per profile or hashtag scrape
- **Anti-bot handling** — built with Playwright and residential proxies for reliable access

### Use Cases

#### 1. Influencer Research & Vetting
Evaluate potential influencer partners with hard data. Analyze follower counts, engagement rates, posting frequency, and content themes before committing to partnerships. Compare multiple creators side-by-side.

#### 2. Competitor Content Analysis
Monitor what content your competitors are posting on TikTok. Track their video performance, posting cadence, hashtag strategy, and audience engagement to inform your own content strategy.

#### 3. Hashtag & Trend Discovery
Identify trending hashtags and viral content in your niche. Discover emerging trends early by monitoring hashtag video counts and engagement metrics. Time your content to ride trending waves.

#### 4. Social Media Reporting & Analytics
Build automated reporting dashboards for your TikTok presence or your clients'. Pull engagement data on a schedule and feed it into Google Sheets, Looker, or any BI tool via the API.

#### 5. Music & Audio Trend Tracking
Track which songs and audio clips are trending across TikTok. Invaluable for music labels, brand campaigns, and content creators looking to leverage popular audio in their videos.

#### 6. Market Research & Consumer Insights
Understand what resonates with specific audiences on TikTok. Analyze video content, comments, and engagement patterns to derive insights about consumer preferences and cultural trends.

#### 7. Brand Monitoring & Reputation Tracking
Monitor mentions of your brand on TikTok by searching hashtags and keywords. Track sentiment, engagement, and reach of user-generated content featuring your products or services.

#### 8. Academic & Journalism Research
Collect TikTok data for research on social media behavior, content virality, platform dynamics, or cultural trends. Export clean, structured datasets for statistical analysis.

#### 9. Content Performance Benchmarking
Analyze top-performing videos in your niche to understand what works. Study video lengths, posting times, hashtag counts, and engagement ratios to optimize your own content strategy.

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `action` | `string` | Yes | `"profile"` | What to scrape: `profile`, `hashtag`, or `video`. |
| `username` | `string` | For `profile` | — | TikTok username (without `@`). Required when action is `profile`. |
| `hashtag` | `string` | For `hashtag` | — | Hashtag to scrape (without `#`). Required when action is `hashtag`. |
| `url` | `string` | For `video` | — | Full TikTok video URL. Required when action is `video`. |
| `maxItems` | `integer` | No | `5` | Maximum number of videos to scrape per run. Range: 1–1,000. |
| `proxyConfiguration` | `object` | No | Apify Residential | Proxy settings. Residential proxies are strongly recommended — TikTok blocks datacenter IPs aggressively. |

#### Action Types

| Action | Description | Required Input |
|--------|-------------|---------------|
| `profile` | Scrape a user's profile info and recent videos | `username` |
| `hashtag` | Discover trending videos for a hashtag | `hashtag` |
| `video` | Get detailed stats for a specific video | `url` |

#### Input Examples

**Scrape a user profile:**
```json
{
    "action": "profile",
    "username": "tiktok",
    "maxItems": 50
}
````

**Discover hashtag content:**

```json
{
    "action": "hashtag",
    "hashtag": "coding",
    "maxItems": 100
}
```

**Get specific video details:**

```json
{
    "action": "video",
    "url": "https://www.tiktok.com/@username/video/1234567890"
}
```

### Output Format

#### Profile Scrape Output

Each profile scrape returns the user's profile data plus their recent videos.

**Profile fields:**

| Field | Type | Description |
|-------|------|-------------|
| `type` | `string` | Always `"profile"` |
| `id` | `string` | TikTok user ID |
| `username` | `string` | Username (handle) |
| `nickname` | `string` | Display name |
| `bio` | `string` | Profile biography text |
| `verified` | `boolean` | Whether the account is verified |
| `privateAccount` | `boolean` | Whether the account is private |
| `followers` | `integer` | Total follower count |
| `following` | `integer` | Number of accounts followed |
| `totalLikes` | `integer` | Total likes received across all videos |
| `totalVideos` | `integer` | Total number of videos posted |
| `avatarLarger` | `string` | URL of the profile avatar (large) |
| `profileUrl` | `string` | Full URL to the TikTok profile |

**Video fields (within profile or hashtag results):**

| Field | Type | Description |
|-------|------|-------------|
| `videoId` | `string` | Unique video identifier |
| `description` | `string` | Video caption / description |
| `views` | `integer` | Total view count |
| `likes` | `integer` | Total like count |
| `comments` | `integer` | Total comment count |
| `shares` | `integer` | Total share count |
| `saves` | `integer` | Total bookmark/save count |
| `duration` | `integer` | Video length in seconds |
| `videoUrl` | `string` | Direct URL to the TikTok video |
| `coverUrl` | `string` | Video thumbnail image URL |
| `musicName` | `string` | Name of the audio track used |
| `musicAuthor` | `string` | Artist/creator of the audio track |
| `hashtags` | `array` | List of hashtags used in the video |
| `createTime` | `string` | Video creation timestamp |

#### Sample Output — Profile

```json
{
    "type": "profile",
    "id": "107955",
    "username": "tiktok",
    "nickname": "TikTok",
    "bio": "Every second counts",
    "verified": true,
    "privateAccount": false,
    "followers": 85200000,
    "following": 1032,
    "totalLikes": 2900000000,
    "totalVideos": 542,
    "avatarLarger": "https://p16-sign-va.tiktokcdn.com/...",
    "profileUrl": "https://www.tiktok.com/@tiktok",
    "videos": [
        {
            "videoId": "7350000000000000000",
            "description": "The feels when your FYP just gets you 🥹",
            "views": 4500000,
            "likes": 320000,
            "comments": 8500,
            "shares": 12000,
            "saves": 45000,
            "duration": 15,
            "videoUrl": "https://www.tiktok.com/@tiktok/video/7350000000000000000",
            "coverUrl": "https://p16-sign-va.tiktokcdn.com/...",
            "musicName": "original sound",
            "musicAuthor": "TikTok",
            "hashtags": ["fyp", "tiktok", "viral"],
            "createTime": "2026-03-15T14:30:00.000Z"
        }
    ],
    "scrapedAt": "2026-04-09T10:30:00.000Z"
}
```

#### Sample Output — Hashtag

```json
{
    "type": "hashtag",
    "hashtag": "coding",
    "videoCount": 15000000,
    "videos": [
        {
            "videoId": "7340000000000000000",
            "description": "Day 30 of learning Python 🐍 #coding #learnpython",
            "views": 890000,
            "likes": 95000,
            "comments": 2300,
            "shares": 5600,
            "saves": 28000,
            "duration": 45,
            "videoUrl": "https://www.tiktok.com/@coder123/video/7340000000000000000",
            "author": "coder123",
            "musicName": "Aesthetic",
            "musicAuthor": "Tollan Kim",
            "hashtags": ["coding", "learnpython", "tech", "developer"]
        }
    ],
    "scrapedAt": "2026-04-09T10:30:00.000Z"
}
```

### Code Examples

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

## Scrape a TikTok profile
run = client.actor("cryptosignals/tiktok-scraper").call(run_input={
    "action": "profile",
    "username": "charlidamelio",
    "maxItems": 20,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("type") == "profile":
        print(f"@{item['username']} | {item['followers']:,} followers | {item['totalLikes']:,} likes")
    for video in item.get("videos", []):
        print(f"  📹 {video['views']:,} views | {video['likes']:,} likes | {video['description'][:60]}...")
```

**Compare engagement across hashtags:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

hashtags = ["fitness", "cooking", "coding", "fashion"]

for tag in hashtags:
    run = client.actor("cryptosignals/tiktok-scraper").call(run_input={
        "action": "hashtag",
        "hashtag": tag,
        "maxItems": 10,
    })
    items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
    for item in items:
        videos = item.get("videos", [])
        if videos:
            avg_views = sum(v.get("views", 0) for v in videos) / len(videos)
            avg_likes = sum(v.get("likes", 0) for v in videos) / len(videos)
            print(f"#{tag}: {len(videos)} videos | avg {avg_views:,.0f} views | avg {avg_likes:,.0f} likes")
```

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

// Scrape hashtag content
const run = await client.actor('cryptosignals/tiktok-scraper').call({
    action: 'hashtag',
    hashtag: 'smallbusiness',
    maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const item of items) {
    for (const video of item.videos || []) {
        console.log(`${video.views?.toLocaleString()} views | ${video.description?.slice(0, 60)}...`);
    }
}
```

#### cURL (Apify API)

**Start a profile scrape:**

```bash
curl -X POST "https://api.apify.com/v2/acts/cryptosignals~tiktok-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "action": "profile",
    "username": "nasa",
    "maxItems": 30
  }'
```

**Start a hashtag scrape:**

```bash
curl -X POST "https://api.apify.com/v2/acts/cryptosignals~tiktok-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "action": "hashtag",
    "hashtag": "techreview",
    "maxItems": 50
  }'
```

**Fetch results:**

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"
```

### Integrations

Connect this scraper to 5,000+ apps via Apify's built-in integrations:

- **Google Sheets** — export TikTok data to spreadsheets for reporting and analysis
- **Zapier** — trigger workflows when new viral content is detected
- **Make (Integromat)** — build automated influencer monitoring pipelines
- **Slack / Email** — get alerts on trending hashtags or competitor activity
- **Webhooks** — send results to any HTTP endpoint in real-time
- **Google BigQuery / Snowflake** — load TikTok data into your data warehouse

### Pricing

This actor uses **pay-per-result** pricing. You only pay for data successfully extracted — no charge for failed runs.

| Usage | Estimated Cost |
|-------|---------------|
| 1 profile + 10 videos | ~$0.25–$0.75 |
| 50 hashtag videos | ~$1.00–$3.00 |
| 100 videos | ~$2.00–$5.00 |
| 1,000 videos (max per run) | ~$8.00–$15.00 |

Costs include Apify platform compute time and residential proxy usage (required for TikTok). Check the [Apify pricing calculator](https://apify.com/pricing) for exact estimates.

**Free tier available:** Apify's free plan includes $5/month in platform credits — enough to scrape dozens of profiles and hundreds of videos.

### Tips for Best Results

- **Use residential proxies** — TikTok aggressively blocks datacenter IPs. The default configuration uses Apify's residential proxy group, which is recommended.
- **Start with smaller batches** — test with 10–20 videos first, then scale up. This saves credits while you validate your workflow.
- **Schedule recurring runs** — set up daily or weekly runs via Apify Schedules to build a historical engagement database.
- **Combine actions** — use `profile` to identify creators, then `hashtag` to discover related content and trends.
- **Monitor engagement rates** — likes/views ratio is more meaningful than raw view counts for influencer evaluation.

### Frequently Asked Questions

#### Do I need a TikTok account or API key?

No. This scraper works without any TikTok credentials. No developer account, API key, or business verification required.

#### How many videos can I scrape per run?

Up to 1,000 videos per profile or hashtag scrape. For larger datasets, run multiple scrapes with different inputs.

#### Can I scrape private accounts?

No. Only publicly available profiles and content can be scraped. Private accounts return only basic profile metadata.

#### What's the difference between profile and hashtag scraping?

**Profile** scraping extracts a specific user's profile data and their recent videos. **Hashtag** scraping discovers trending videos for a given hashtag across all creators.

#### How fresh is the engagement data?

Data is scraped in real-time from TikTok's web interface. View counts, likes, and comments reflect the current state at the time of the scrape.

#### Can I export results to CSV or Excel?

Yes. Apify datasets support export to JSON, CSV, Excel (XLSX), XML, and RSS. Use the export buttons in the Apify console or append `?format=csv` to the API endpoint.

#### Why do some videos show zero views?

TikTok occasionally delays public view count updates for recent videos. Videos posted in the last few hours may show 0 views temporarily.

#### Can I track a hashtag over time?

Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run the hashtag scrape daily or weekly. Compare results across runs to track trending content and engagement changes.

#### Is this compliant with TikTok's terms?

This scraper accesses only publicly available content displayed on TikTok's website. Users are responsible for ensuring their use case complies with applicable laws and platform policies.

#### Why are residential proxies required?

TikTok employs aggressive anti-bot measures that block most datacenter IP addresses. Residential proxies simulate real user connections and are essential for reliable data extraction.

### Limitations

- Maximum 1,000 videos per run
- Only public profiles and content can be scraped
- TikTok's anti-bot measures may occasionally cause partial results — retry with a fresh run
- Video download URLs are not provided (only metadata and statistics)
- Comment text extraction is not included in the current version (engagement counts only)
- TikTok's page structure changes frequently — actor updates are released promptly

### Support

Found a bug or have a feature request? Reach out through Apify's messaging system on the actor page, or leave a review with your feedback.

***

### ⭐ Found this useful?

If this actor saved you time, please **[leave a review on the Apify Store](https://apify.com/cryptosignals/tiktok-scraper#reviews)** — it takes 30 seconds and helps other developers find it.

Questions or issues? Drop a comment below and I'll respond within 24 hours.

# Actor input Schema

## `action` (type: `string`):

What to scrape: 'profile' for user profiles, 'hashtag' for hashtag videos, 'video' for single video details.

## `username` (type: `string`):

TikTok username to scrape (without @). Used when action is 'profile'.

## `hashtag` (type: `string`):

Hashtag to scrape (without #). Used when action is 'hashtag'.

## `url` (type: `string`):

Full TikTok video URL. Used when action is 'video'.

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

Maximum number of videos to scrape.

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

Proxy configuration for bypassing TikTok's anti-bot measures. Residential proxies are recommended for profile video scraping.

## Actor input object example

```json
{
  "action": "profile",
  "username": "tiktok",
  "hashtag": "coding",
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "action": "profile",
    "username": "tiktok",
    "hashtag": "coding",
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cryptosignals/tiktok-scraper-v2").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 = {
    "action": "profile",
    "username": "tiktok",
    "hashtag": "coding",
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("cryptosignals/tiktok-scraper-v2").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 '{
  "action": "profile",
  "username": "tiktok",
  "hashtag": "coding",
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call cryptosignals/tiktok-scraper-v2 --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Scraper v2",
        "description": "Scrape TikTok profiles, hashtags, and videos.",
        "version": "0.1",
        "x-build-id": "QQDIc04zxKgUbX5ix"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cryptosignals~tiktok-scraper-v2/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cryptosignals-tiktok-scraper-v2",
                "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/cryptosignals~tiktok-scraper-v2/runs": {
            "post": {
                "operationId": "runs-sync-cryptosignals-tiktok-scraper-v2",
                "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/cryptosignals~tiktok-scraper-v2/run-sync": {
            "post": {
                "operationId": "run-sync-cryptosignals-tiktok-scraper-v2",
                "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": [
                    "action"
                ],
                "properties": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "profile",
                            "hashtag",
                            "video"
                        ],
                        "type": "string",
                        "description": "What to scrape: 'profile' for user profiles, 'hashtag' for hashtag videos, 'video' for single video details.",
                        "default": "profile"
                    },
                    "username": {
                        "title": "Username",
                        "type": "string",
                        "description": "TikTok username to scrape (without @). Used when action is 'profile'.",
                        "default": "nasa"
                    },
                    "hashtag": {
                        "title": "Hashtag",
                        "type": "string",
                        "description": "Hashtag to scrape (without #). Used when action is 'hashtag'."
                    },
                    "url": {
                        "title": "Video URL",
                        "type": "string",
                        "description": "Full TikTok video URL. Used when action is 'video'."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of videos to scrape.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy configuration for bypassing TikTok's anti-bot measures. Residential proxies are recommended for profile video scraping.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
