# TikTok Video Stats Scraper: Views, Likes by URL (`kyungminlee/tiktok-profile-video-scraper`) Actor

View, like, comment and share counts for any public TikTok video URL, plus follower, following and likes totals for public profiles, in seconds without login. Each result includes author, description, hashtags, music, duration, cover image and post date. JSON/CSV, API or scheduled tracking.

- **URL**: https://apify.com/kyungminlee/tiktok-profile-video-scraper.md
- **Developed by:** [Kyungmin Lee](https://apify.com/kyungminlee) (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

from $0.84 / 1,000 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

### What does TikTok Video Stats Scraper do?

**TikTok Video Stats Scraper** returns the numbers behind any public TikTok video you already know the URL of — views, likes, comments, shares and saves — plus the public statistics of any profile (followers, following, total likes, video count). It reads TikTok's public pages without login, cookies or a browser, so a batch of campaign or competitor URLs is measured in seconds and nothing of yours is at risk. It does not crawl a profile's entire feed; give it video URLs.

Video records contain `videoId`, `url`, `author`, `description`, `hashtags`, `music`, `durationSeconds`, `coverUrl`, `createdAt`, `viewCount`, `likeCount`, `commentCount`, `shareCount` and `saveCount`; profile records contain `username`, `nickname`, `bio`, `verified`, `avatarUrl`, `followerCount`, `followingCount`, `heartCount` and `videoCount`. Export JSON/CSV, call the API, or schedule the same URL list daily to build engagement time series.

### Why use it?

- Monitor a creator's public audience growth and profile statistics.
- Collect engagement metrics for a known list of campaign, competitor, or brand videos.
- Build dashboards from public video URLs without managing a TikTok account.
- Enrich a spreadsheet of public video links with captions, hashtags, audio, and counts.
- Schedule repeatable checks using Apify datasets, webhooks, and integrations.

The Actor deliberately uses public pages only. It neither requests credentials nor accepts cookies, and it does not use signed private feed endpoints. This keeps the input simple and makes failed WAF/challenge responses visible instead of silently charging for them.

### How to scrape TikTok public data

1. Open the Actor and select **Try for free**.
2. Add one or more usernames, such as `tiktok` or `natgeo`.
3. Optionally add complete public video URLs such as `https://www.tiktok.com/@user/video/123456789`.
4. Choose a maximum result count.
5. Start the run and export the default dataset as JSON, CSV, Excel, or through an Apify integration.

The default input contains one public username and one stable public video URL so it can be used for a quick health check.

### Input

```json
{
  "usernames": ["tiktok"],
  "videoUrls": ["https://www.tiktok.com/@scout2015/video/6718335390845095173"],
  "maxItems": 20,
  "proxyConfiguration": {"useApifyProxy": false}
}
```

`usernames` accepts names with or without `@`. `videoUrls` accepts only full public TikTok URLs containing `/video/<numeric-id>`; short/share URLs should be opened in a browser first and replaced with their final public URL. `maxItems` counts successful profile and video records together.

TikTok currently does not expose a stable, unsigned, paginated profile-video feed in the public profile state used here. For that reason, this Actor does **not** claim to enumerate every video for a username. Supply the video URLs you want to measure. This is intentional: it avoids relying on signed feed calls, authentication, or challenge-solving that can break without warning.

### Output

A profile record looks like this:

```json
{
  "type": "profile",
  "username": "tiktok",
  "nickname": "TikTok",
  "verified": true,
  "followerCount": 0,
  "followingCount": 0,
  "heartCount": 0,
  "videoCount": 0,
  "profileUrl": "https://www.tiktok.com/@tiktok"
}
```

An individual video record contains `videoId`, `url`, `description`, `hashtags`, `authorUsername`, `createdAt`, `playCount`, `likeCount`, `commentCount`, `shareCount`, `saveCount`, `durationSeconds`, `coverUrl`, and music fields. Counts and optional metadata can be absent when TikTok does not publish them for a particular video.

### Data fields

| Field | Description |
|---|---|
| `type` | Either `profile` or `video` |
| `username`, `nickname`, `bio` | Public profile identity and biography |
| `followerCount`, `followingCount`, `heartCount`, `videoCount` | Public profile statistics |
| `videoId`, `url`, `description`, `hashtags` | Public video identity and caption data |
| `playCount`, `likeCount`, `commentCount`, `shareCount`, `saveCount` | Public video engagement counts |
| `createdAt`, `durationSeconds`, `width`, `height` | Video timing and dimensions |
| `musicTitle`, `musicAuthor`, `musicOriginal` | Public audio metadata |
| `scrapedAt` | UTC timestamp at collection time |

### Pricing

The Actor uses pay-per-event pricing of **$0.0012 per successfully collected result** ($1.20 per 1,000 profiles or videos). A profile and a video each count as one result. Invalid URLs, duplicate input errors, WAF challenges, rate limits, unavailable pages, and parsing failures are never charged as result events. Apify platform compute and optional proxy costs may apply separately according to your Apify plan.

Use Apify's maximum charge setting to enforce a spending cap. The Actor checks the remaining result-event allowance before each request and stops when the cap is reached.

### Tips

- Start with one profile or a few video URLs to confirm availability.
- Keep video URLs in an external list if you want recurring metric snapshots.
- Retry later if TikTok serves a WAF challenge; this can vary by IP and time.
- Enable an Apify proxy only when direct data-center access is challenged. The Actor uses a new proxy session for every requested public page.
- Use profile records for creator-level metrics and video records for campaign-level metrics.

### FAQ

#### Does it need a TikTok account?

No. It works only with information TikTok exposes on public web pages and does not accept usernames, passwords, cookies, or session tokens.

#### Why did a username return no video list?

Public profile pages presently expose profile data but not a dependable unsigned video-feed pagination path. Add public individual video URLs for video-level results.

#### Why can a run fail with a WAF challenge?

TikTok can vary its public-page access by IP, region, and traffic conditions. The Actor detects challenge pages, returns a clear error, and does not charge failed records. Retry later or use the optional proxy configuration.

#### Is this official?

No. This is an unofficial tool with no affiliation to TikTok or ByteDance. You are responsible for complying with applicable laws, TikTok's terms, and reasonable request volumes when using public data.

# Actor input Schema

## `usernames` (type: `array`):

Public TikTok usernames to collect, with or without the @ symbol. Each produces one profile result with public bio and statistics.

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

Optional public TikTok video URLs in the form https://www.tiktok.com/@user/video/id. Each produces one video result with public engagement statistics.

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

Maximum number of successful profile or video results to save. The Actor charge limit can lower this value.

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

Optional proxy settings. Public pages currently work from Apify data-center IPs; enable a proxy if TikTok serves a WAF challenge.

## Actor input object example

```json
{
  "usernames": [
    "tiktok"
  ],
  "videoUrls": [
    "https://www.tiktok.com/@scout2015/video/6718335390845095173"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "usernames": [
        "tiktok"
    ],
    "videoUrls": [
        "https://www.tiktok.com/@scout2015/video/6718335390845095173"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kyungminlee/tiktok-profile-video-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 = {
    "usernames": ["tiktok"],
    "videoUrls": ["https://www.tiktok.com/@scout2015/video/6718335390845095173"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kyungminlee/tiktok-profile-video-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "usernames": [
    "tiktok"
  ],
  "videoUrls": [
    "https://www.tiktok.com/@scout2015/video/6718335390845095173"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kyungminlee/tiktok-profile-video-scraper --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

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