# TikTok Profile Videos Scraper – No Login (`datascraperes/tiktok-profile-videos-scraper`) Actor

Scrape public videos from one or more TikTok profiles. Export video URLs, captions, dates, authors, music and engagement stats to one Dataset row per video. No TikTok account, login or API key is required.

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

## Pricing

$1.00 / 1,000 saved videos

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

## TikTok Profile Videos Scraper – No Login

Extract public videos from one or more TikTok profiles and receive clean, structured results in an Apify Dataset. This Actor is suitable for collecting a few videos from one profile, building a content inventory, or processing large lists of public creators.

Enter one or more TikTok usernames, with or without the `@` prefix, or paste a public TikTok profile URL. Each video is saved as a separate Dataset item with its URL, caption, author, publication date, engagement metrics, music information and available video metadata.

No TikTok account, password, official TikTok API key, browser session or cookies are required. The Actor works with publicly available profile content only. Private, deleted, unavailable or access-restricted videos cannot be returned.

> **Important:** This is an independent, unofficial third-party Actor. It is not affiliated with, sponsored by, endorsed by or approved by TikTok. You are responsible for using the results lawfully and respecting the terms and privacy rights that apply to the source data.

### At a glance

- Scrape one or many public TikTok profiles.
- Accepts usernames, `@handles` and public TikTok profile URLs.
- Save one Dataset row per video.
- Request a fixed number of videos or all public items available during the run.
- Process profiles in batches and resume from the next profile when needed.
- Export results from Apify as JSON, CSV, Excel or other Dataset formats.
- Use the Actor without configuring a TikTok login or an external scraping service.
- Pay per saved video, with no video charge for diagnostic/error rows.

### What data is extracted?

Each successful Dataset item represents one public TikTok video and can contain:

| Field | Description |
| --- | --- |
| `videoId` | TikTok's public identifier for the video. |
| `videoUrl` | Canonical URL of the TikTok video. |
| `description` | Caption or description published with the video. |
| `createdAt` | Publication date in ISO date-time format, when available. |
| `createTime` | Original Unix timestamp, when available. |
| `profileInput` | The profile value used in the input. |
| `profileUrl` | Normalized public profile URL. |
| `username` | Normalized TikTok username. |
| `author` | Author ID, username and display name when available. |
| `stats` | Public play, like, comment, share and collect counts when available. |
| `video` | Duration and available cover-image URLs. |
| `music` | Music ID, title and author name when available. |
| `retrievedAt` | Time at which the item was collected. |

Public counters and metadata are snapshots. They can change after the run, and some fields may be empty when TikTok does not expose them for a particular video.

The Actor returns metadata and public URLs. It does not download MP4 video files, private media, comments, followers, following lists or account credentials.

### Quick start

1. In **Input**, add one or more values to `profiles`.
2. For a test, set `maxVideosPerProfile` to a small number such as `5`.
3. Click **Start**.
4. Open the **Dataset** tab to review the video rows.
5. Export the Dataset in the format you need, or connect it to another Apify workflow.

#### Quick test input

```json
{
  "profiles": ["@corgibobaa"],
  "maxVideosPerProfile": 5,
  "maxTotalVideos": 5
}
```

### Input reference

#### `profiles` — required

List of public TikTok profiles to process. Use a username, an `@username`, or a direct public profile URL:

```json
[
  "@creatorname",
  "creatorname",
  "https://www.tiktok.com/@anothercreator"
]
```

Profile URLs must point directly to a TikTok user profile. Video, hashtag, sound, shortened and other TikTok URLs are rejected. Repeated profiles are deduplicated before processing. The input accepts up to 1,000 profile values.

#### `startIndex`

Zero-based position from which to start in the deduplicated profile list. Leave it at `0` for a new run.

For a large batch, use the `nextStartIndex` value from the previous run's `SUMMARY` record. This lets you continue with the next group of profiles without repeating profiles already processed.

#### `maxProfilesPerRun`

Maximum number of profiles processed in one run.

- Default: `100`
- Maximum: `1,000`
- Use a lower value for small, predictable runs.
- Increase it for batch collection when the input list contains more profiles.

This limit controls profiles, not videos. The video limits below control how many results are collected from those profiles.

#### `maxVideosPerProfile`

Maximum number of unique videos saved for each profile.

- Default: `5`
- `0`: continue until the public items available for that profile are exhausted or another safety limit is reached.
- A positive value such as `10`, `100` or `1,000`: stop after that many unique videos for each profile.

For a quick test, use `5` or `10`. For a complete profile inventory, use `0` and keep `maxPagesPerProfile` at its default unless the `SUMMARY` record reports that the page limit was reached.

#### `maxTotalVideos`

Maximum number of videos saved across the entire run.

- Default: `5`
- `0`: no explicit run-wide video limit.
- A positive value: stop once that many videos have been saved across all selected profiles.

This is useful when you want to control the maximum size and cost of a multi-profile run. For example, `maxVideosPerProfile: 100` and `maxTotalVideos: 1,000` limits each profile to 100 videos while also limiting the whole run to 1,000 videos.

#### `maxPagesPerProfile`

Safety limit for the amount of profile history requested in one run.

- Default: `1,000`
- Minimum: `1`
- Maximum: `5,000`

The default is suitable for normal use. If a very large profile stops with `MAX_PAGES`, increase this value and run again, provided the run duration and budget are acceptable.

#### `includeCoverUrls`

Whether to include the public cover-image URL fields in each video item.

- Default: `true`
- Set to `false` for a smaller Dataset when cover images are not needed.

Cover URLs are supplied by TikTok and may expire or change. They are links, not permanent media storage.

### Examples for common goals

#### Collect a small sample from one profile

Use this to verify that the profile is correct and inspect the output before a larger run:

```json
{
  "profiles": ["https://www.tiktok.com/@examplecreator"],
  "maxVideosPerProfile": 10,
  "maxTotalVideos": 10
}
```

#### Collect all public videos available for one profile

```json
{
  "profiles": ["@examplecreator"],
  "maxVideosPerProfile": 0,
  "maxTotalVideos": 0
}
```

“All” means all public items available to the Actor during that run. It does not include private, deleted, unavailable or access-restricted videos, and TikTok may return fewer items than the count displayed in the app or on the profile.

#### Collect a controlled batch from many profiles

```json
{
  "profiles": ["@creator1", "@creator2", "@creator3"],
  "maxProfilesPerRun": 3,
  "maxVideosPerProfile": 100,
  "maxTotalVideos": 250,
  "includeCoverUrls": true
}
```

The run stops at the first applicable limit. In this example, no profile can contribute more than 100 videos and the complete run cannot save more than 250 videos.

#### Resume a large profile list

1. Run the first batch with `maxProfilesPerRun` set to the desired batch size.
2. Open the `SUMMARY` record in the run's Key-value store.
3. Copy `nextStartIndex` into `startIndex` for the next run.
4. Use the same profile list and ordering.

If `nextStartIndex` is `null`, all supplied profiles were processed. If you change the order or remove profiles between runs, the resume position will no longer refer to the same profile.

### Understanding the results

#### Dataset items

Successful video items have `success: true` and normally `status: "ok"`.

Example:

```json
{
  "success": true,
  "status": "ok",
  "profileInput": "@examplecreator",
  "profileUrl": "https://www.tiktok.com/@examplecreator",
  "username": "examplecreator",
  "videoId": "1234567890",
  "videoUrl": "https://www.tiktok.com/@examplecreator/video/1234567890",
  "createdAt": "2026-08-18T10:20:30Z",
  "description": "Public video caption",
  "author": {
    "id": "author-id",
    "uniqueId": "examplecreator",
    "nickname": "Example Creator"
  },
  "stats": {
    "playCount": 1200,
    "diggCount": 80,
    "commentCount": 4,
    "shareCount": 6,
    "collectCount": 2
  },
  "video": {
    "duration": 18,
    "coverUrl": "https://example.com/cover.jpg"
  },
  "music": {
    "id": "music-id",
    "title": "Sound title",
    "authorName": "Sound creator"
  }
}
```

#### Diagnostic items

When a profile cannot be completed, the Actor records a diagnostic item with fields such as `success: false`, `errorCode`, `errorMessage`, `pages`, `itemsReceived` and `uniqueVideos`. These rows help identify which profile needs attention and are not charged as successful video results.

#### `SUMMARY` record

Every run creates a `SUMMARY` record in the Key-value store. It contains:

- Number of profiles requested, selected and processed.
- Number of videos saved.
- The starting position and `nextStartIndex` for batch resumption.
- A result summary for each profile.
- The profile status, pages processed, items received, unique videos and duplicates skipped.
- A stop reason when a configured limit or availability issue ends a profile early.

Useful stop reasons include:

| Stop reason | Meaning |
| --- | --- |
| `COMPLETE` | No more public items were available for that profile during the run. |
| `MAX_VIDEOS` | `maxVideosPerProfile` was reached. |
| `MAX_TOTAL_VIDEOS` | `maxTotalVideos` was reached for the complete run. |
| `MAX_PAGES` | `maxPagesPerProfile` was reached. |
| An error code | The profile or run could not be completed; inspect the diagnostic item. |

### Pricing

The customer is charged only for successful video results:

- **$0.001 per saved video** — $1 per 1,000 video results.
- There is no separate customer charge for starting a run.
- Execution, proxy and infrastructure costs are covered by the Actor owner.
- Diagnostic/error rows are not charged as successful video results.
- A video is saved only when the platform confirms that one video charge was applied.
- If the run's spending limit is reached, the Actor stops before saving another billable video.

For example, a run that saves 100 videos costs the customer **$0.10**. The number of billable video results is controlled by `maxVideosPerProfile` and `maxTotalVideos`.

### Limitations and important expectations

- Only publicly available profile content can be collected.
- Private, deleted, region-restricted, age-restricted or temporarily unavailable videos may be missing.
- TikTok can change public fields, ordering, pagination or availability at any time.
- A profile's displayed video count is informational and is not a guarantee of how many items will be returned.
- Cover URLs may expire; export or store the images separately if permanent access is required.
- This Actor returns metadata and public URLs, not downloaded video files.
- Large profiles can take longer and produce more Dataset items and charges.
- The Actor does not collect passwords, cookies or private account information.

### Troubleshooting

#### The run returns no videos

Check that:

1. The input is a TikTok username, `@username`, or direct public profile URL. Do not enter a video, hashtag, sound or shortened URL.
2. The username is spelled correctly.
3. The profile is public and currently has publicly available videos.
4. `maxVideosPerProfile` and `maxTotalVideos` are not set to `0` in a context where you expected a small sample, or to an unexpectedly low value.
5. The `SUMMARY` record does not report an error or an early stop reason.

#### The run returns fewer videos than expected

Review `SUMMARY` and check `stopReason`, `uniqueVideos`, `duplicatesSkipped` and `profileVideoCount` when present. The result may be limited by `maxVideosPerProfile`, `maxTotalVideos`, `maxPagesPerProfile`, deleted/private content or temporary TikTok availability.

#### The run stops at `MAX_PAGES`

Increase `maxPagesPerProfile` and run the profile again. Keep a finite `maxVideosPerProfile` or `maxTotalVideos` when you want predictable cost and duration.

#### A profile is reported as an error

Open the diagnostic Dataset item and inspect `errorCode` and `errorMessage`. Verify the username and try the same profile again later. Repeated failures may indicate that the profile is private, unavailable, temporarily restricted or no longer exposes the expected public data.

### FAQ

#### Do I need a TikTok account or login?

No. The Actor is designed for public profile data and does not ask you to provide TikTok credentials.

#### Do I need an official TikTok API key?

No. There is no TikTok API key field in the input.

#### Can I scrape multiple profiles in one run?

Yes. Add multiple usernames or public profile URLs to `profiles`, then use `maxProfilesPerRun` and `maxTotalVideos` to control the batch.

#### Can I scrape all videos from a profile?

Set `maxVideosPerProfile` to `0`. The Actor continues until the public items available during the run are exhausted or a safety limit is reached. Complete historical coverage cannot be guaranteed for content that is private, deleted, unavailable or not returned by TikTok.

#### Can I download the TikTok videos?

No. The Actor returns video metadata, cover URLs when enabled and canonical TikTok video URLs. It does not download MP4 files.

#### Will repeated runs return the same engagement numbers?

Not necessarily. Likes, views, comments, shares and other public counters are live snapshots and may change between runs.

#### How do I export the data?

Open the Dataset associated with the run and use Apify's export options. You can also connect the Dataset to schedules, webhooks, integrations or another workflow from Apify.

#### Is a proxy or special setup required?

No manual proxy setup is required for normal use. You only need to provide the usernames and the limits that match your job.

#### Is scraping TikTok legal?

The Actor is limited to publicly available data, but you are responsible for deciding whether your use complies with applicable law, privacy obligations, TikTok's terms and any contractual restrictions. Do not collect personal data without an appropriate lawful basis.

### Support

When reporting a problem, include the Apify run ID, the username or profile URL used, the relevant `SUMMARY` stop reason and a small example of the affected output. Do not include passwords, tokens or private credentials.

# Actor input Schema

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

Enter @username, username, or a public TikTok profile URL such as https://www.tiktok.com/@username. Video, hashtag, and sound URLs are not accepted.

## `startIndex` (type: `integer`):

Zero-based index in the deduplicated profile list. Use nextStartIndex from SUMMARY to resume a large batch.

## `maxProfilesPerRun` (type: `integer`):

Maximum profiles processed by this run. Increase gradually for large jobs; results stream to the Dataset.

## `maxVideosPerProfile` (type: `integer`):

Stop a profile after this many unique videos. Set 0 for all public items exposed by TikTok.

## `maxTotalVideos` (type: `integer`):

Hard run-wide video limit. Set 0 for no explicit result limit; PPE and Actor timeout guards still apply.

## `maxPagesPerProfile` (type: `integer`):

Safety guard against parser or cursor drift. A normal page contains at most 15 videos.

## `includeCoverUrls` (type: `boolean`):

Include public cover URL fields when TikTok returns them. CDN URLs may expire.

## Actor input object example

```json
{
  "profiles": [
    "@corgibobaa"
  ],
  "startIndex": 0,
  "maxProfilesPerRun": 10,
  "maxVideosPerProfile": 5,
  "maxTotalVideos": 5,
  "maxPagesPerProfile": 100,
  "includeCoverUrls": true
}
```

# Actor output Schema

## `videos` (type: `string`):

One successful Dataset item per public TikTok video, plus non-chargeable diagnostic rows for profile errors or partial stops.

## `summary` (type: `string`):

Per-profile pages, unique videos, stop reasons, proxy fallback usage, and charge event.

# 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 = {
    "profiles": [
        "@corgibobaa"
    ],
    "startIndex": 0,
    "maxProfilesPerRun": 10,
    "maxVideosPerProfile": 5,
    "maxTotalVideos": 5,
    "maxPagesPerProfile": 100,
    "includeCoverUrls": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascraperes/tiktok-profile-videos-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 = {
    "profiles": ["@corgibobaa"],
    "startIndex": 0,
    "maxProfilesPerRun": 10,
    "maxVideosPerProfile": 5,
    "maxTotalVideos": 5,
    "maxPagesPerProfile": 100,
    "includeCoverUrls": True,
}

# Run the Actor and wait for it to finish
run = client.actor("datascraperes/tiktok-profile-videos-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 '{
  "profiles": [
    "@corgibobaa"
  ],
  "startIndex": 0,
  "maxProfilesPerRun": 10,
  "maxVideosPerProfile": 5,
  "maxTotalVideos": 5,
  "maxPagesPerProfile": 100,
  "includeCoverUrls": true
}' |
apify call datascraperes/tiktok-profile-videos-scraper --silent --output-dataset

```

## MCP server setup

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