# TikTok Outlier Finder: TikTok Viral Videos vs Creator Median (`vant47/tiktok-outlier-finder`) Actor

Find TikTok videos that beat a creator's normal views for TikTok competitor analysis or your niche: outlier score against the creator's median, views, likes, shares, caption, hashtags and sound. $0.0032 per video analysed: 100 videos cost $0.32. No login.

- **URL**: https://apify.com/vant47/tiktok-outlier-finder.md
- **Developed by:** [fortbrand](https://apify.com/vant47) (community)
- **Categories:** Social media, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.56 / 1,000 videos

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 Outlier Finder: TikTok Viral Videos vs Creator Median

For creators, agencies and brands finding unusually successful public TikTok videos, with their captions, hashtags and sounds.

**$0.0032 per video analysed. Analysing 100 videos costs $0.32 before tier discounts**, plus Apify's small start fee. Enter public profiles and get scored videos directly. No TikTok login, account cookies or separate scraper required.

Compare each video's views with its creator's own median, flag scores above your threshold and read a free creator summary with the baseline and top outlier.

### What you get

| Field | Meaning |
|---|---|
| `summary` | A readable answer with the score, views and median |
| `videoUrl`, `postUrl`, `videoId` | Public video link, compatible post-link alias and stable video ID |
| `creator`, `creatorUrl`, `creatorFollowers` | Public handle, profile link and follower count |
| `postedAt`, `postedDate` | Publication time in UTC and calendar date |
| `views`, `likes`, `comments`, `shares`, `saves` | Public video counts exposed by TikTok |
| `durationSeconds` | Duration reported by a public list; photo posts can have zero duration |
| `durationSource`, `durationSourceField`, `durationSourceUrl` | Creator-list or hashtag-list surface and field supplying duration |
| `durationVerified` | False: duration is not cross-checked against the public video page |
| `caption`, `hashtags`, `hook` | Caption text, hashtags and first caption line |
| `soundTitle`, `soundId` | Public sound information |
| `creatorMedianViews` | Median views over the creator's selected recent sample |
| `creatorMedianSample` | Number of videos with a known view count in that baseline |
| `outlierScore` | Video views divided by the creator median |
| `isOutlier` | Whether the score reaches your `minOutlierScore` |
| `engagementRate`, `engagementRatePct` | Percentage: 100 x (likes + comments + shares) / views |
| `viewsToFollowers` | Views divided by the creator's follower count |
| `rankInCreator` | Rank among that creator's returned scored videos, highest score first |
| `baselineStart`, `baselineEnd` | Oldest and newest publication times in the baseline sample |
| `baselineStatus` | Whether the sample supports a score |
| `foundVia` | Requested profile or hashtag that found the video |
| `scrapedAt` | Run snapshot timestamp (UTC), fixed across restart recovery |

Shared fields match the TikTok Sponsored Posts family. Both engagement fields use percentage units: `9.5` means 9.5%.

Each free `type: "creator summary"` row has `recordType: "SUMMARY"`, sample size, median, delivered count, outlier count, top outlier and notes. The key-value store contains the run-level `SUMMARY` and an `OUTLIERS` record sorted by score.

### How the score works

The Actor reads public chronological video lists and removes repeated IDs. It keeps videos inside your optional date window, then calculates the median of their known view counts. If TikTok explicitly marks a video as pinned, that video is excluded from the baseline but can still be scored.

The median is the middle sorted count, averaging the middle pair for an even sample. Every video from a creator uses this same denominator, including itself.

`outlierScore = views / creatorMedianViews`

A score of `3` means three times the median. The default threshold marks scores of at least `3`; raising it to `10` selects larger breakouts. The threshold changes the flag and export. All scored videos are returned and charged.

A score needs at least three videos with known views and a positive median. Smaller samples and zero medians produce free, unscored rows. Missing metrics remain `null`.

### How to use it

1. Add public handles or full TikTok profile URLs to `profiles`.
2. Choose how many recent videos to analyse per profile and the outlier threshold.
3. Start the run, read the creator summaries and open the OUTLIERS view or JSON export.

The prefill uses `duolingo` and `redbull`, 30 videos each. Its 4 November 2026 test returned 60 videos and 11 outliers in 33.263 seconds. Counts and conditions can change.

Basic input:

```json
{
  "profiles": ["duolingo", "redbull"],
  "maxVideosPerProfile": 30,
  "minOutlierScore": 3
}
```

Larger sample:

```json
{
  "profiles": ["espn", "nba", "nfl"],
  "maxVideosPerProfile": 100,
  "minOutlierScore": 5,
  "postedAfter": "2026-10-01"
}
```

### Input reference

| Input | Default | What to enter |
|---|---|---|
| `profiles` | Form prefill: two public brands | Handles, `@handles`, or HTTPS TikTok profile URLs; up to 200 profiles |
| `hashtags` | None | Optional public hashtags; up to 10, without needing a profile list |
| `maxVideosPerProfile` | `30` | Videos per explicit profile, 1 to 2,000; hashtag baselines cap at 30 |
| `minOutlierScore` | `3` | Minimum views-to-median ratio for the outlier flag, from 1 to 1,000 |
| `postedAfter` | None | Inclusive ISO date or datetime; applies to both videos and their baseline |
| `proxyConfiguration` | Automatic datacenter route | Optional Apify proxy for HTTP requests |
| `allowAutomaticProxyFallback` | `true` | Allow automatic routing if a selected residential connection fails; `false` keeps residential HTTP routing strict |

Aliases: `creators`, `usernames` or `startUrls` for profiles; `dateFrom` for `postedAfter`. Duplicates are merged and malformed entries become free notes.

Dates without a time mean midnight UTC. Keep date windows consistent.

### Find outliers from a hashtag

Hashtag mode discovers up to 30 public videos per tag, or your smaller video limit. Each author's latest public videos supply a baseline of up to 30 videos. Only the discovered hashtag videos are delivered and charged; baseline-only videos are free.

```json
{
  "hashtags": ["wigs"],
  "maxVideosPerProfile": 30,
  "minOutlierScore": 3
}
```

Combine hashtags and profiles if useful. Explicit profiles return their recent sample; discovered authors contribute hashtag videos. Video IDs are deduplicated across inputs.

### Example output

A real scored video from the 4 November 2026 test, with the caption omitted here for brevity:

```json
{
  "summary": "@duolingo: 5.49x the creator median (4,300,000 views / 782,950); outlier",
  "type": "video",
  "videoId": "7704019694994345230",
  "videoUrl": "https://www.tiktok.com/@duolingo/video/7704019694994345230",
  "creator": "@duolingo",
  "creatorFollowers": 18413596,
  "views": 4300000,
  "likes": 1300000,
  "comments": 23300,
  "shares": 400700,
  "creatorMedianViews": 782950,
  "creatorMedianSample": 30,
  "outlierScore": 5.492049,
  "isOutlier": true,
  "soundTitle": "original sound"
}
```

Filter `type == "video"` for video-only imports. Console views show analysed videos, OUTLIERS, creator summaries and content details. The Output tab links to results, outlier JSON and the run summary.

### Pricing and spending limits

| Apify tier | Price per scored video |
|---|---:|
| Free | $0.0032 |
| Bronze | $0.00304 |
| Silver | $0.00288 |
| Gold and above | $0.00256 |

| Example | Videos delivered | Approximate list-price charge |
|---|---:|---:|
| One creator, 30 videos | 30 | $0.10 |
| Two creators, 30 videos each | 60 | $0.19 |
| Ten creators, 30 videos each | 300 | $0.96 |
| A larger sample | 1,000 | $3.20 |

Apify's start fee is $0.00005 per GB of run memory, with a minimum of one start event. Platform compute and proxy usage are included in this Actor's price. There is no additional AI charge.

Summaries, notes, duplicates, unavailable profiles and unscored videos have no video charge. Baseline-only videos in hashtag mode are not charged. The free Apify plan has the same input limits as paid plans.

Set a maximum total charge in run options. It stops at the spending limit. A cap reduces delivered rows without changing the prepared baseline.

### Monitor creators on a schedule

Save the inputs as an Apify task and attach a daily or weekly schedule. Previously seen videos can return with updated counts and be charged again.

Store history by `(videoId, scrapedAt)`, or replace the latest snapshot by `videoId`. A success webhook can load outliers into Make, n8n, Zapier, Slack or Google Sheets.

Within a run, saved snapshots protect the sample across restarts. Accepted video charges are reconciled before delivery resumes.

### API examples

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("vant47/tiktok-outlier-finder").call(
    run_input={
        "profiles": ["duolingo", "redbull"],
        "maxVideosPerProfile": 30,
        "minOutlierScore": 3,
    }
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("type") == "video" and row.get("isOutlier"):
        print(row["outlierScore"], row["videoUrl"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('vant47/tiktok-outlier-finder').call({
  profiles: ['duolingo', 'redbull'],
  maxVideosPerProfile: 30,
  minOutlierScore: 3,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const outliers = items.filter(row => row.type === 'video' && row.isOutlier);
console.log(outliers.map(row => [row.outlierScore, row.videoUrl]));
```

curl:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/vant47~tiktok-outlier-finder/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"profiles":["redbull"],"maxVideosPerProfile":30}'
```

Scheduled integrations can use the asynchronous run endpoint and success webhooks. Download JSON, CSV or Excel from the dataset.

### Use with AI agents (MCP)

Connect an Apify-compatible assistant to `https://mcp.apify.com` and ask it to run `vant47/tiktok-outlier-finder`. Ask: "Compare the latest 30 TikTok videos from these public profiles, show videos above three times each creator's median, and include caption, hashtags and sound."

Read scores with `creatorMedianViews` and `creatorMedianSample` so the comparison stays inspectable. Shared fields also connect with TikTok Sponsored Posts for branded-content research.

Duration keeps the creator-list value when the video is in the baseline. A hashtag candidate absent from that baseline keeps its hashtag-list value. Source provenance follows the value actually used, independently of foundVia discovery contexts. One of ten saved November 4 handchecks (video 7704019694994345230) disagreed with its video page; the saved evidence does not establish why. No reconciled playback duration is claimed.

### Limits

- Apify rejects incorrect JSON field types before a run starts. Invalid profile entries or dates that reach the Actor become free notes.
- Residential profile requests can fall back to an automatic datacenter connection; browser discovery uses that automatic connection. Set `allowAutomaticProxyFallback: false` for strict residential HTTP routing. Inaccessible profiles or hashtags then return free notes.
- Public, signed-out TikTok data only. Private, deleted, restricted or unavailable posts cannot be collected. No login, account-cookie import or CAPTCHA solving is supported.
- The baseline is the returned recent sample, not the creator's lifetime performance. TikTok can stop its public timeline before your requested maximum, and some fields or videos can be unavailable. Creator statuses and notes identify incomplete samples.
- Hashtag ordering is TikTok's public ordering, not a guaranteed recent-first feed or complete hashtag census. Up to 30 candidate videos per tag are discovered, then scored against their authors' profile samples. A refused hashtag route returns a free note.
- View and engagement counts change and TikTok sometimes rounds them. The public profile card, video page and list endpoint can update at different moments. Unknown fields stay `null`.
- Scores are descriptive, not a prediction of future reach or evidence that a video should be copied. New videos have had less time to accumulate views; the score does not adjust for age, paid distribution or audience differences.
- A sample below three usable videos or a zero median has no valid score. Pinned posts are excluded only when TikTok explicitly provides that marker; the chronological feed does not always provide a pinned flag.
- Dates filter the baseline as well as the output. Changing the date or sample size changes the denominator, and therefore the score.
- TikTok's terms restrict automated extraction. Use public data responsibly and comply with the terms and laws that apply to your use. This is an independent tool with no affiliation to TikTok.

### FAQ

**Why use the median rather than average views?** The median reduces the influence of a single unusually large hit. The same baseline is shown on every returned video from a creator.

**Does changing the threshold reduce the bill?** The threshold changes the outlier flag and export. The charge applies to every delivered video with a valid score, including those below the threshold.

**Are saves part of engagementRate?** No. It follows the sibling Actor's convention: likes, comments and shares divided by views, expressed as a percentage. Saves are supplied separately when TikTok exposes them.

**Can I use it repeatedly for competitors?** Yes. Save the same inputs as a task, schedule it, and retain snapshots using the stable video ID and collection timestamp.

**Where are the outliers?** In the OUTLIERS dataset view and the `OUTLIERS` JSON record linked from the Output tab. The run summary also gives each creator's highest-scoring delivered outlier.

**What happens if no useful data is found?** You receive free notes or creator summaries. There is no video analysis charge without a delivered video carrying a valid score; Apify's start fee still applies.

**Is a reboot charged as a second analysis?** Within the same run, saved rows and settled billing counts are reconciled before delivery resumes. A separate new run is a new analysis of current data.

TikTok outlier finder, TikTok viral videos, TikTok competitor analysis, creator baselines.

# Actor input Schema

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

Public TikTok handles or profile URLs, for example duolingo or https://www.tiktok.com/@redbull. Up to 200. Duplicates are free.

## `hashtags` (type: `array`):

Discover public hashtag videos, then compare each author with their own recent videos. TikTok chooses hashtag ordering; it is not guaranteed chronological. Hashtag samples can be unavailable.

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

Newest public videos per explicit profile, up to 2,000. Hashtag baselines use at most 30 per creator. At least 3 videos and a positive median are needed for a score. One delivered analysed video costs $0.0032 before tier discounts.

## `minOutlierScore` (type: `number`):

Views divided by the creator median. 3 marks videos at least 3 times the baseline. All analysed videos are returned, including those below this threshold.

## `postedAfter` (type: `string`):

ISO date such as 2026-10-01 or datetime. Filters the video sample and its median. Leave empty for the newest videos without a date restriction.

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

Default datacenter proxy pool first. Residential or a different country can help if TikTok refuses a connection. No account cookies or login are used.

## `allowAutomaticProxyFallback` (type: `boolean`):

Use the automatic datacenter connection when a selected residential connection cannot read a public profile, and for browser discovery. Switch off to require the chosen residential connection; unavailable results then become free notes.

## Actor input object example

```json
{
  "profiles": [
    "duolingo",
    "redbull"
  ],
  "maxVideosPerProfile": 30,
  "minOutlierScore": 3,
  "allowAutomaticProxyFallback": true
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `outliers` (type: `string`):

No description

## `summary` (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 = {
    "profiles": [
        "duolingo",
        "redbull"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vant47/tiktok-outlier-finder").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": [
        "duolingo",
        "redbull",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("vant47/tiktok-outlier-finder").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": [
    "duolingo",
    "redbull"
  ]
}' |
apify call vant47/tiktok-outlier-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vant47/tiktok-outlier-finder"
        }
    }
}
```

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/hyTiGoagPgvZZp5z0/builds/vmeOlPMpbzTnyhVQE/openapi.json