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

Scrape TikTok videos in bulk from profile handles or direct video URLs. Returns video ID, author, caption, hashtags, music, full metrics (plays, likes, comments, shares, saves), no-watermark video URL, cover image, duration, and post date.

- **URL**: https://apify.com/goat255/tiktok-video-scraper.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** Social media, Videos, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 Goat - Export TikTok Videos, Metrics, Music & No-Watermark URLs

Scrape TikTok videos in bulk from any public profile or from direct video links. Pull captions, hashtags, music, full engagement metrics (plays, likes, comments, shares, saves), no-watermark video URLs, cover images, duration, and post dates. No TikTok login, no cookies, no API key.

### What this TikTok scraper does

Pass a mix of profile handles and video URLs in one run. The actor detects each input automatically:

- **Profile handles or profile URLs** - fetches that user's recent videos, paginating automatically until it reaches your `maxVideosPerUser` cap or the profile runs out.
- **Direct video URLs** - fetches one detailed row for each link.

Every video comes back as a clean, ordered JSON row with **no-watermark video URLs**, cover images, music, hashtags, and the complete metric set.

Perfect for **content research, trend tracking, creator vetting, and competitor analysis** on TikTok.

### Why use this TikTok Video Scraper

- **No login, no cookies, no API key** - works on every public TikTok profile and video.
- **Two input modes in one run** - mix profile handles and direct video links freely.
- **Automatic pagination** - request 60, 200, or thousands of videos per profile and the cursor loop fetches them all.
- **No-watermark media URLs** - clean video links plus the original cover image.
- **Full metric set** - plays, likes, comments, shares, and saves on every row.
- **Hashtags and music** - parsed hashtags, plus music title and author per video.
- **Per-video billing** - you pay only for videos actually returned, never for an empty profile.

### What data you get per video

```json
{
  "videoId": "0000000000000000000",
  "authorHandle": "example_user",
  "authorNickname": "Example User",
  "authorId": "000000",
  "description": "having fun in the studio today #music #behindthescenes",
  "hashtags": ["music", "behindthescenes"],
  "region": "US",
  "isAd": false,
  "musicTitle": "original sound - example_user",
  "musicAuthor": "Example User",
  "musicIsOriginal": true,
  "playCount": 1532000,
  "likeCount": 210400,
  "commentCount": 3120,
  "shareCount": 8800,
  "saveCount": 14200,
  "downloadCount": 410,
  "videoUrl": "https://...",
  "coverUrl": "https://...",
  "musicUrl": "https://...",
  "duration": 33,
  "createTime": "2024-04-25T08:15:18+00:00",
  "createTimestamp": 1714032918,
  "webUrl": "https://www.tiktok.com/@example_user/video/0000000000000000000"
}
````

### How to use the TikTok Video Scraper

1. Click **Try for free** on the actor page.
2. Add profile handles and/or video URLs to the `inputs` field (handles, @handles, profile URLs, or full video URLs - all accepted, auto-deduped).
3. Set `maxVideosPerUser` to control how many videos to pull per profile (direct video URLs ignore this and return one row each).
4. Tune `concurrency` (default 4) and `delayBetweenRequests` (default 1s).
5. Click **Save & start**. Download JSON / CSV / Excel / XML / HTML.

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `inputs` | string\[] | - | Profile handles, profile URLs, or direct video URLs (mix freely, auto-deduped) |
| `maxVideosPerUser` | integer | `30` | Max videos to fetch per profile handle (ignored for direct video URLs) |
| `concurrency` | integer | `4` | Inputs processed in parallel |
| `delayBetweenRequests` | number | `1.0` | Seconds between paginated requests inside one profile pipeline |
| `proxyConfiguration` | object | direct | Optional Apify proxy settings |

### Top use cases

- **Content research** - pull a creator's recent videos with full metrics to study what performs.
- **Trend tracking** - monitor hashtags and play counts across many profiles over time.
- **Creator vetting** - check posting cadence and engagement before a partnership.
- **Competitor analysis** - snapshot rival brand accounts and benchmark their video metrics.
- **Media archiving** - capture no-watermark video URLs and cover images for your library.

### Integrations

#### Apify API

```bash
curl "https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=json"
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("goat255/tiktok-video-scraper").call(run_input={
    "inputs": ["example_user", "https://www.tiktok.com/@example_user/video/0000000000000000000"],
    "maxVideosPerUser": 60,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"@{item['authorHandle']}: {item['playCount']} plays, {item['likeCount']} likes")
```

#### No-code integrations

Send results directly to Google Sheets, Slack, Zapier, Make, Amazon S3, or your own webhook via [Apify Integrations](https://docs.apify.com/platform/integrations).

### Pricing

Pay-per-event. One charge per video returned. You are never billed for an empty profile or a failed lookup.

| Event | Price (tiered by Apify plan) |
|---|---|
| Video scraped (primary) | per video returned |

Apify's platform free credit applies on first use.

### FAQ

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

No. The scraper works on every public TikTok profile and video without auth.

#### Can I scrape a whole profile?

Yes. Pass a handle and set `maxVideosPerUser`. The actor paginates automatically until it hits your cap or the profile runs out of videos.

#### Can I scrape a single video?

Yes. Pass the direct video URL and you get one detailed row for it.

#### Can it scrape private accounts?

No. Only public profiles and videos are accessible.

#### What metrics are included?

Plays, likes, comments, shares, saves, and downloads, plus duration and post date on every row.

#### How do I download the media files?

The actor returns `videoUrl` and `coverUrl` for every video. Pipe those URLs to your own downloader, S3, or webhook.

### Support

Open an issue on the actor page if something breaks or a field is missing. Reviews are read and replied to.

### Related actors

Part of the scraper suite by goat255:

- [TikTok Profile Scraper](https://apify.com/goat255/tiktok-profile-scraper) - public profiles in bulk.
- [TikTok Comments Scraper](https://apify.com/goat255/tiktok-comments-scraper) - comments from any TikTok video.

# Actor input Schema

## `inputs` (type: `array`):

Mix freely. Pass TikTok profile handles or profile URLs to fetch a user's recent videos (e.g. tiktok, @tiktok, https://www.tiktok.com/@tiktok), or pass direct video URLs to fetch each video's detail (e.g. https://www.tiktok.com/@example\_user/video/0000000000000000000).

## `maxVideosPerUser` (type: `integer`):

Maximum number of videos to fetch per profile handle. Pagination runs automatically until this many videos are collected or the profile runs out. Ignored for direct video URLs (one row each).

## `concurrency` (type: `integer`):

Maximum number of inputs processed in parallel.

## `delayBetweenRequests` (type: `number`):

Seconds to wait between paginated requests inside a single profile pipeline. Helps avoid rate limits on large profiles.

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

Optional proxy. Direct connection works for most runs. Enable a proxy if you scrape at high volume.

## Actor input object example

```json
{
  "inputs": [
    "tiktok",
    "nba"
  ],
  "maxVideosPerUser": 30,
  "concurrency": 4,
  "delayBetweenRequests": 1,
  "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 = {
    "inputs": [
        "tiktok",
        "nba"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/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 = { "inputs": [
        "tiktok",
        "nba",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("goat255/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 '{
  "inputs": [
    "tiktok",
    "nba"
  ]
}' |
apify call goat255/tiktok-video-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Video Scraper Goat",
        "description": "Scrape TikTok videos in bulk from profile handles or direct video URLs. Returns video ID, author, caption, hashtags, music, full metrics (plays, likes, comments, shares, saves), no-watermark video URL, cover image, duration, and post date.",
        "version": "0.0",
        "x-build-id": "fpA6oAF7P17soS9rM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~tiktok-video-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-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/goat255~tiktok-video-scraper/runs": {
            "post": {
                "operationId": "runs-sync-goat255-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/goat255~tiktok-video-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-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": [
                    "inputs"
                ],
                "properties": {
                    "inputs": {
                        "title": "Profile Handles or Video URLs",
                        "type": "array",
                        "description": "Mix freely. Pass TikTok profile handles or profile URLs to fetch a user's recent videos (e.g. tiktok, @tiktok, https://www.tiktok.com/@tiktok), or pass direct video URLs to fetch each video's detail (e.g. https://www.tiktok.com/@example_user/video/0000000000000000000).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideosPerUser": {
                        "title": "Max videos per user",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of videos to fetch per profile handle. Pagination runs automatically until this many videos are collected or the profile runs out. Ignored for direct video URLs (one row each).",
                        "default": 30
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of inputs processed in parallel.",
                        "default": 4
                    },
                    "delayBetweenRequests": {
                        "title": "Delay Between Requests (seconds)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Seconds to wait between paginated requests inside a single profile pipeline. Helps avoid rate limits on large profiles.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy. Direct connection works for most runs. Enable a proxy if you scrape at high volume.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```