# TikTok Video Scraper (`fetch_cat/tiktok-video-scraper`) Actor

Extract TikTok video metadata, author details, captions, hashtags, music, covers, and engagement stats from public video URLs.

- **URL**: https://apify.com/fetch\_cat/tiktok-video-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 1,000 item extracteds

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

## TikTok Video Scraper

Extract public TikTok video metadata, engagement statistics, author details, hashtags, and music information from TikTok video URLs.

### What does TikTok Video Scraper do?

TikTok Video Scraper turns a list of public TikTok video links into structured dataset rows.

Use it to collect video IDs, captions, author names, publish times, duration, music, hashtags, cover images, and engagement counters.

The actor is designed for URL-based monitoring, competitive analysis, campaign reporting, and creator research.

### Who is it for?

- 📊 Social media analysts tracking video performance.
- 🏢 Agencies reporting TikTok campaign results.
- 🧑‍🎤 Creators benchmarking public posts.
- 🛍️ Brand teams monitoring influencer content.
- 🧪 Researchers building public social media datasets.

### Why use this actor?

- ✅ Structured output from public TikTok video URLs.
- ✅ One dataset row per submitted video.
- ✅ Engagement metrics in numeric fields.
- ✅ Hashtags and music fields ready for analysis.
- ✅ Handles unavailable videos with a clear status row.

### What data can you extract?

| Field | Description |
| --- | --- |
| `videoId` | TikTok video ID |
| `authorUsername` | Creator handle |
| `authorDisplayName` | Creator display name |
| `description` | Video caption |
| `createTime` | Publish time in ISO format |
| `durationSeconds` | Video duration |
| `musicTitle` | Music or sound title |
| `musicAuthor` | Music or sound author |
| `hashtags` | Hashtags used in the caption |
| `diggCount` | Like count |
| `commentCount` | Comment count |
| `shareCount` | Share count |
| `playCount` | View/play count |
| `collectCount` | Save/favorite count |
| `coverUrl` | Cover image URL |
| `canonicalUrl` | Normalized TikTok video URL |

### How much does it cost to scrape TikTok video metadata?

This actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-result fee for each video metadata row saved to the dataset.

For small tests, keep the prefilled single video URL and review the output before scaling to larger batches.

### How to scrape TikTok videos

1. Open the actor on Apify.
2. Paste one or more full TikTok video URLs.
3. Set `maxItems` if you want to process only part of the list.
4. Run the actor.
5. Export the dataset as JSON, CSV, Excel, or through the API.

### Input

```json
{
  "videoUrls": [
    "https://www.tiktok.com/@scout2015/video/6718335390845095173"
  ],
  "maxItems": 10
}
````

### Input fields

#### `videoUrls`

Array of full public TikTok video URLs.

Use links in the format:

```text
https://www.tiktok.com/@username/video/VIDEO_ID
```

#### `maxItems`

Maximum number of video URLs to process in the run.

#### `proxyConfiguration`

Optional Apify proxy configuration.

Most small public-video checks can start without a proxy.

### Output

```json
{
  "videoUrl": "https://www.tiktok.com/@scout2015/video/6718335390845095173",
  "videoId": "7623088450576633119",
  "authorUsername": "khaby.lame",
  "authorDisplayName": "Khabane lame",
  "description": "Not a good morning 🚑#learnfromkhaby #comedy",
  "createTime": "2026-04-30T12:37:04.000Z",
  "durationSeconds": 16,
  "musicTitle": "original sound",
  "musicAuthor": "Khabane lame",
  "hashtags": ["learnfromkhaby", "comedy"],
  "diggCount": 12345,
  "commentCount": 123,
  "shareCount": 45,
  "playCount": 67890,
  "collectCount": 100,
  "coverUrl": "https://...",
  "canonicalUrl": "https://www.tiktok.com/@scout2015/video/6718335390845095173",
  "isAvailable": true,
  "fetchedAt": "2026-06-27T00:00:00.000Z"
}
```

### Tips for reliable runs

- 🔗 Use full public TikTok video URLs.
- 🧪 Test one or two links before running a large batch.
- 📌 Remove duplicate URLs before starting a run.
- 🚫 Private, deleted, or unavailable videos may return `isAvailable: false`.
- 🌍 If TikTok blocks a region, try enabling Apify Proxy.

### Common use cases

#### Campaign reporting

Collect public engagement metrics for a list of sponsored TikTok videos.

#### Creator monitoring

Track metadata from creator posts used in influencer programs.

#### Competitor research

Compare captions, hashtags, music, and engagement across public videos.

#### Content analysis

Export captions and hashtags for downstream text analysis.

### Integrations

Use exported datasets in:

- Google Sheets
- Airtable
- BI dashboards
- Social listening workflows
- Marketing reports
- Data warehouses

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/tiktok-video-scraper').call({
  videoUrls: ['https://www.tiktok.com/@scout2015/video/6718335390845095173'],
  maxItems: 1,
});

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

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('fetch_cat/tiktok-video-scraper').call(run_input={
    'videoUrls': ['https://www.tiktok.com/@scout2015/video/6718335390845095173'],
    'maxItems': 1,
})

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

### API usage: cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~tiktok-video-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"videoUrls":["https://www.tiktok.com/@scout2015/video/6718335390845095173"],"maxItems":1}'
```

### MCP integration

Use this actor from MCP-compatible tools through Apify MCP Server when you want Claude, Cursor, or another MCP client to run TikTok video metadata extraction without writing custom API code.

MCP server URL:

```text
https://mcp.apify.com/?tools=fetch_cat/tiktok-video-scraper
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=fetch_cat/tiktok-video-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/tiktok-video-scraper"
    }
  }
}
```

MCP example prompts you can ask:

- "Use Apify MCP to run fetch\_cat/tiktok-video-scraper for these TikTok URLs and rank them by play count."
- "Use the TikTok Video Scraper MCP tool to extract captions, hashtags, and music for this campaign URL list."

### Claude Desktop prompt example

"Run fetch\_cat/tiktok-video-scraper for these TikTok video URLs and summarize which videos have the most plays."

### Claude Code prompt example

"Use Apify MCP to scrape metadata for this TikTok campaign URL list, export the dataset, and calculate average engagement."

### More MCP prompts

- "Extract TikTok video stats for these five URLs and return a table sorted by play count."
- "Compare likes, comments, shares, and saves for this creator's public campaign videos."
- "Save TikTok video metadata to an Apify dataset and tell me which captions contain product hashtags."

### Troubleshooting

#### The actor returned `isAvailable: false`

The video may be deleted, private, region-restricted, or temporarily unavailable.

Check the URL in a browser and confirm it is a public video page.

#### A metric looks different from the TikTok app

TikTok engagement counts can change quickly.

Run the actor again when you need a fresh snapshot.

#### Short links are not working

Use the full video URL format whenever possible.

### Limits

This actor is for public video metadata only.

It does not scrape comments, replies, direct messages, private accounts, or TikTok Shop records.

### Legality and responsible use

Only scrape public TikTok pages you are allowed to access.

Respect TikTok terms, privacy rights, copyright, and applicable laws.

Do not use the actor to collect private or sensitive personal data.

### Related scrapers

- https://apify.com/fetch\_cat/tiktok-comments-scraper
- https://apify.com/fetch\_cat/tiktok-ads-library-scraper
- https://apify.com/fetch\_cat/tiktok-transcript-scraper
- https://apify.com/fetch\_cat/instagram-stories-highlights-scraper
- https://apify.com/fetch\_cat/x-profile-tweets-scraper

### FAQ

#### Can I scrape multiple TikTok videos at once?

Yes. Add multiple full video URLs to `videoUrls`.

#### Does this actor download video files?

No. It extracts public metadata and engagement counters.

#### Does this actor scrape comments?

No. Use the related TikTok Comments Scraper for comments.

#### Can I schedule it?

Yes. Use Apify schedules to run the same input daily, weekly, or monthly.

#### Can I export to CSV?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and HTML exports.

#### Does it require login?

No login is required for public video metadata.

#### What happens with duplicate URLs?

The actor de-duplicates URLs during input normalization.

#### What is the best first test?

Run the prefilled sample input with one video and inspect the dataset row.

### Changelog

- Initial version: public TikTok video metadata by URL.

# Actor input Schema

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

Full public TikTok video URLs to scrape, for example https://www.tiktok.com/@khaby.lame/video/7623088450576633119.

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

Maximum number of video URLs to process in this run.

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

Optional proxy settings. Leave disabled unless TikTok blocks requests from your region.

## Actor input object example

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

# Actor output Schema

## `overview` (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 = {
    "videoUrls": [
        "https://www.tiktok.com/@scout2015/video/6718335390845095173"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/tiktok-video-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 '{
  "videoUrls": [
    "https://www.tiktok.com/@scout2015/video/6718335390845095173"
  ]
}' |
apify call fetch_cat/tiktok-video-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Video Scraper",
        "description": "Extract TikTok video metadata, author details, captions, hashtags, music, covers, and engagement stats from public video URLs.",
        "version": "0.1",
        "x-build-id": "ZlyusnZCqUfieyDfl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~tiktok-video-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-tiktok-video-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/fetch_cat~tiktok-video-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-tiktok-video-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/fetch_cat~tiktok-video-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-tiktok-video-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": [
                    "videoUrls"
                ],
                "properties": {
                    "videoUrls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "Full public TikTok video URLs to scrape, for example https://www.tiktok.com/@khaby.lame/video/7623088450576633119.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum videos",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of video URLs to process in this run.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Leave disabled unless TikTok blocks requests from your region.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```