# TikTok Scraper — Profiles & Videos (`magnova/tiktok-scraper`) Actor

Scrape TikTok profiles and videos with no login and no cookies. Give usernames or video URLs; get structured profile records (followers, likes, video count) and video records (views, likes, comments, shares, saves, music, thumbnails). $0.001 per result, no start fee.

- **URL**: https://apify.com/magnova/tiktok-scraper.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Social media, Automation, Developer tools
- **Features:** Limited permissions, Multi-tenant, Server interface
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 result records

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## TikTok Scraper — Profiles & Videos

Scrape **TikTok profiles and videos** as structured records — no login, no cookies, no account of yours involved. Give it usernames or video URLs and get back profile records (followers, following, total likes, video count, verified and TikTok Shop seller flags) and video records (views, likes, comments, shares, saves, duration, music, thumbnail and a direct download URL).

One simple price: **$0.001 per result record delivered. No start fee, no add-on fees** — filters, sorting and extras are never charged separately, because there is nothing extra to charge for. You only pay for records actually delivered; failed targets produce an ERROR record and cost nothing.

### What you give it

| Input | What it does |
|---|---|
| **Profiles** | Usernames (with or without `@`) or profile URLs. Each profile returns one PROFILE record plus its most recent videos as VIDEO records. |
| **Video URLs** | Direct `tiktok.com/@user/video/…` links. Each returns one VIDEO record with full counts. |
| **Max videos per profile** | How many of each profile's most recent videos to return (1–100, default 30). |
| **Include profile records** | Turn off to get videos only. |
| **Maximum total charge per run (USD)** | A hard budget stop you control — the run stops delivering and charging at your cap. |
| **Use residential proxy (US)** | Optional. Routes through Apify residential proxies; helps on very large runs when TikTok rate-limits datacenter IPs. Costs extra platform usage, never extra event fees. |

### What you get

#### PROFILE records

| Field | Meaning |
|---|---|
| `username` | The TikTok username (uniqueId) |
| `userId` / `secUid` | TikTok's IDs for the account |
| `nickname` | Display name |
| `signature` | Bio text — email addresses and phone numbers are removed before delivery |
| `verified` | Whether the account has the verified badge |
| `privateAccount` | Whether the account is private |
| `isSeller` | Whether the account is a TikTok Shop commerce user |
| `followerCount` | Followers (on at least 95% of records) |
| `followingCount` | Accounts followed |
| `videoCount` | Total public videos |
| `likeCount` | Total likes received across the profile |
| `friendCount` | Friend count where TikTok exposes it |
| `avatarUrl` / `profileUrl` | Picture and public profile page |
| `accountCreatedAt` | Account creation time (UTC) |

#### VIDEO records

| Field | Meaning |
|---|---|
| `videoId` | TikTok's unique video ID — the dedupe key |
| `videoUrl` | The public video page URL |
| `videoDescription` | Caption — email addresses and phone numbers are removed before delivery |
| `authorUsername` / `authorUserId` / `authorNickname` | The posting account |
| `createdAt` | When the video was posted (UTC) |
| `durationSeconds` | Video length |
| `viewCount` | Plays (on at least 90% of records) |
| `likeCount` | Likes (on at least 85% of records) |
| `commentCount` | Comments (on at least 85% of records) |
| `shareCount` | Shares / reposts |
| `saveCount` | Saves / collects |
| `musicTitle` / `musicAuthor` | The sound used in the video |
| `thumbnailUrl` | Cover image |
| `downloadUrl` | A direct media URL for videos fetched by video URL (TikTok may expire these) |
| `sourceProfile` | The profile the video was collected from, when it came from a profile input |

Every run also ends with one **SUMMARY** record (counts, elapsed time) and produces an **ERROR** record for any single target that failed — one bad username never kills a bulk run, and results always keep their input order. ERROR and SUMMARY records are never charged.

### Sample output

```json
{
  "recordType": "VIDEO",
  "videoId": "7708408003065580831",
  "videoUrl": "https://www.tiktok.com/@tiktok/video/7708408003065580831",
  "description": "You know their game 🎾 But are the @WTA singles stars ready for your TikTok comme…",
  "authorUsername": "tiktok",
  "createdAt": "2026-11-15T14:40:20Z",
  "durationSeconds": 79,
  "viewCount": 395000,
  "likeCount": 4219,
  "commentCount": 1504,
  "shareCount": 457,
  "saveCount": 555,
  "musicTitle": "original sound",
  "musicAuthor": "TikTok",
  "sourceProfile": "tiktok"
}
```

### Use it as an API (Server Actor)

This Actor also runs in server mode — no run to start, no dataset to poll. Send one HTTP request, get the records back in the response:

```bash
curl -X POST "https://magnova--tiktok-scraper.apify.actor/" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"profiles": ["natgeo"], "maxResultsPerProfile": 5}'
```

The body takes the same fields as the normal input (`profiles`, `videoUrls`, `maxResultsPerProfile`, `includeProfileRecords`, `maxTotalChargeUsd`, `useResidentialProxy`). The response is `{"records": [...], "summary": {...}}` with the same record shapes described above. Per request: up to 10 profiles and 20 video URLs. Delivered records are charged at the same $0.001 per result; ERROR rows are never charged. Works from apps, workflow tools, and AI agents that need a profile or a set of videos mid-conversation.

### Pricing

- **$0.001 per result record** (FREE and BRONZE tiers), $0.00085 on SILVER, $0.0007 on GOLD and above.
- **No start fee.** No per-filter, per-sort or per-download add-ons — the price you see is the whole price.
- Set **Maximum total charge per run** if you want a hard budget ceiling.

### FAQ

**Do I need a TikTok account or cookies?**
No. Everything is read from TikTok's public, logged-out surfaces. There is nothing to log into and no session to hand over — your account is never involved, so it can never be put at risk.

**What about private accounts?**
A private account's profile record may be limited and its videos are not public, so they cannot be returned. You get an ERROR record for what could not be fetched, and you are not charged for it.

**How fresh is the data?**
Counts are read live at run time — they are the numbers TikTok shows at that moment.

**Can I run it on a schedule?**
Yes — schedule the Actor like any other. Each run re-reads the profiles, so it works as a lightweight tracker for follower and view counts over time.

**Is contact data included?**
No. This Actor returns public profile and video facts only, and it removes email addresses and phone numbers from bios and captions before delivery.

### Limits

- Up to 100 videos per profile per run.
- Very large runs can hit TikTok rate limits from datacenter IPs; if a run under-delivers, enable the residential proxy option or split the input.
- Download URLs are issued by TikTok and may expire; fetch the media promptly if you need it.

# Actor input Schema

## `includeProfileRecords` (type: `boolean`):

Also deliver one PROFILE record per profile (followers, likes, video count). Turn off to get videos only.

## `maxResultsPerProfile` (type: `integer`):

How many of each profile's most recent videos to return (1-100).

## `maxTotalChargeUsd` (type: `number`):

A hard stop you control: the run stops delivering once its charged total would pass this amount. Leave empty for no cap.

## `profiles` (type: `array`):

TikTok usernames (with or without @) or profile URLs. For each profile you get one PROFILE record plus its most recent videos as VIDEO records.

## `useResidentialProxy` (type: `boolean`):

Route requests through Apify residential proxies in the US. Slower and costs extra platform usage, but helps when TikTok rate-limits datacenter IPs on very large runs.

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

Direct TikTok video URLs (tiktok.com/@user/video/...). Each returns one VIDEO record with full counts.

## Actor input object example

```json
{
  "includeProfileRecords": true,
  "maxResultsPerProfile": 30,
  "maxTotalChargeUsd": 1,
  "profiles": [
    "tiktok"
  ],
  "useResidentialProxy": 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 = {
    "includeProfileRecords": true,
    "maxResultsPerProfile": 30,
    "profiles": [
        "tiktok"
    ],
    "useResidentialProxy": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/tiktok-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 = {
    "includeProfileRecords": True,
    "maxResultsPerProfile": 30,
    "profiles": ["tiktok"],
    "useResidentialProxy": False,
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/tiktok-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 '{
  "includeProfileRecords": true,
  "maxResultsPerProfile": 30,
  "profiles": [
    "tiktok"
  ],
  "useResidentialProxy": false
}' |
apify call magnova/tiktok-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,magnova/tiktok-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/qRhAhV6wiO1vyVUdv/builds/VvCWkpSK0ce6ddYD9/openapi.json
