# TikTok Video Analyzer: Hooks, Scripts & Selling Playbook (`omnipotent_stairway/tiktok-video-analyzer`) Actor

Find TikTok Shop selling videos (ranked by GMV, sales and views) or top organic videos, or paste links. Get each video's transcript, hook, script beats, CTA, voice style and a reusable script template, plus one playbook across all videos.

- **URL**: https://apify.com/omnipotent_stairway/tiktok-video-analyzer.md
- **Developed by:** [FUTUREVERSE TECHNOLOGIES LLC](https://apify.com/omnipotent_stairway) (community)
- **Categories:** Social media, Videos, E-commerce
- **Security:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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 Video Analyzer: Hooks, Scripts & Selling Playbook

Start with **one TikTok video link**: replace the prefilled public example with your own video and run the Actor. You get that video's transcript, hook, beats, voice style and reusable script template. **Cross-video Playbook is off in a new form**; enable it when you want a summary across at least two videos.

You can also find the TikTok videos that sell (TikTok Shop best sellers, ranked by GMV, sales and views) or the organic videos people share and save most, and get every video broken down: **transcript with timestamps, the hook, the script beat by beat, demo and proof shots, the CTA, the creator's voice style, why it works and a reusable script template**. Then get one **playbook across all the videos**: the hooks, script skeletons, CTAs, voice rules and mistakes that repeat in the winners.

Other TikTok video analyzers look at one video at a time. This one also **finds the videos for you** (by commerce data or by shares + saves, not just views) and **sums up what the best ones have in common**.

Made by Alvin's Club for:

- **TikTok Shop sellers and affiliates**: see how the best-selling videos in your niche open, demo, prove and ask for the sale.
- **Ecommerce marketers and UGC / ads agencies**: turn top videos into briefs and script templates for creators.
- **AI video tool builders**: structured hooks, beats and templates as JSON, through the Apify API.

### What you get

For every video (one dataset row):

| Field | What it is |
|---|---|
| `url`, `author`, `postedAt`, `durationSeconds`, `analyzedSeconds` | The video; `analyzedSeconds` is what was analyzed (at most its first 60 seconds) |
| `metrics` | `views`, `likes`, `shares`, `saves`, `comments`, `shareSavePer1k` (shares + saves per 1,000 views) |
| `commerce` (selling mode) | The TikTok Shop product: `productTitle`, `priceUsd`, `gmv7dUsd`, `unitsSold7d`, `gmv30dUsd`, `unitsSold30d`, `unitsSoldLifetime`, `videoGmvUsd` when known |
| `transcript` | Every spoken word in timed segments, plus `wordsPerSecond` and `firstWordsAt` |
| `hook` | The first 3 seconds: `shot`, `line`, `onScreenText`, `type` (problem, question, result first, before/after...) |
| `beats` | The script beat by beat: `start`, `end`, what is `shown`, what is `said`, and the beat's `job` (hook, demo, proof, CTA...) |
| `demoShots`, `proofShots`, `cta` (selling) | How the product is shown, the visual proof, and the call to action: `line`, `type`, `atSeconds` |
| `format`, `retentionDevices`, `payoff`, `whyShared` (content) | The format, what keeps people watching and at which second, the ending, and why people share or save it |
| `voiceStyle` | Who speaks, tone, pace, sentence length, how they talk to the viewer, signature phrasings |
| `whyItWorks` | Why this video sells or spreads, grounded in what is shown and said |
| `template` | The video as a reusable script template with `[placeholders]` |

When `includePlaybook` is enabled and at least two videos are analyzed: a **`PLAYBOOK`** record in the key-value store (also the last dataset row, `type: "playbook"`).

### Three modes

1. **`selling`: TikTok Shop selling videos.** Give a keyword (`"wig"`, `"necklace"`, `"kitchen gadgets"`) or pick a category. The Actor finds the keyword's TikTok Shop best sellers and their affiliate videos, ranked by GMV and sales (the product's 7-day / 30-day GMV, per-video GMV when TikTok Shop publishes it) and then views.
2. **`content`: top organic videos.** Give hashtags (`wigtok`, `kitchenfinds`) and/or a keyword. The Actor scans the feed, drops ads, paid partnerships, slideshows and selling posts (TikTok Shop links, "link in bio", discount codes), and ranks what is left by **shares + saves per 1,000 views**: the videos people keep and send, not just watch. Videos of 5 seconds to 3 minutes.
3. **`urls`: your links.** Paste TikTok video links (full links or vm.tiktok.com share links) and choose whether to analyze them as selling or content videos.

**Each video is analysed up to its first 60 seconds (hooks, structure and CTA usually happen there); price per video, any length** (up to 10 minutes and a 60 MB file).

Filters: `country` (default US), `maxVideos` (5-100, default 20; finding modes only: in links mode every link is analyzed, up to 100), `maxAgeDays`, `minViews`. Descriptions are written in English by default (11 more languages); speech and on-screen text are quoted as spoken. Instagram Reels and YouTube Shorts are coming next.

#### Example input

Single video (the new form starts here; replace this public example):

```json
{
  "mode": "urls",
  "videoUrls": ["https://www.tiktok.com/@6711492781058130950/video/7649770069446135054"],
  "urlVideoType": "selling",
  "includePlaybook": false
}
```

Optional discovery with a cross-video Playbook:

```json
{
  "mode": "selling",
  "keyword": "necklace",
  "country": "US",
  "maxVideos": 20,
  "includePlaybook": true
}
```

Organic discovery with a cross-video Playbook:

```json
{ "mode": "content", "hashtags": ["kitchenfinds", "kitchengadgets"], "maxAgeDays": 60, "minViews": 50000, "includePlaybook": true }
```

### Example output

One video (shortened):

```json
{
  "type": "video",
  "mode": "selling",
  "rank": 1,
  "rankedBy": "product_gmv_7d",
  "url": "https://www.tiktok.com/@creator/video/7400000000000000001",
  "author": "creator",
  "durationSeconds": 21,
  "analyzedSeconds": 21,
  "metrics": { "views": 1804430, "likes": 93471, "shares": 8991, "saves": 15013, "comments": 552, "shareSavePer1k": 13.3 },
  "commerce": { "productTitle": "Gold cross necklace", "priceUsd": 27.19, "gmv7dUsd": 17701, "unitsSold7d": 651 },
  "transcript": {
    "segments": [{ "start": 0.4, "end": 2.6, "text": "Stop scrolling if your chain keeps turning green." }],
    "wordsPerSecond": 2.6,
    "firstWordsAt": 0.4
  },
  "hook": { "shot": "Close-up of a hand holding the pendant at sunset", "line": "Stop scrolling if your chain keeps turning green.", "onScreenText": "NO MORE GREEN NECK", "type": "problem" },
  "beats": [
    { "start": 0, "end": 3, "shown": "Pendant close-up in golden-hour light", "said": "Stop scrolling if...", "job": "hook" },
    { "start": 3, "end": 12, "shown": "The chain on a neck bust", "said": "I wear it every single day", "job": "proof" },
    { "start": 18, "end": 21, "shown": "Creator points down to the cart", "said": "Tap the orange cart", "job": "cta" }
  ],
  "proofShots": ["Close-up of the shine in sunlight"],
  "cta": { "line": "Tap the orange cart before it sells out.", "type": "cart_or_link", "atSeconds": 18.2 },
  "voiceStyle": { "speaker": "creator voiceover", "tone": "confident", "pace": "fast", "sentenceLength": "short" },
  "whyItWorks": "It names a pain in the first second and proves the fix on screen before asking for the sale.",
  "template": "0-3 s: [product close-up] / says \"Stop scrolling if [problem]\"; 3-12 s: [proof on a model] / says \"[benefit]\"; 18-21 s: [point to the cart] / says \"Tap the cart before [scarcity]\""
}
```

The playbook (shortened):

```json
{
  "type": "playbook",
  "videosAnalyzed": 20,
  "summary": "Name the pain in second one, prove it on screen, end on the cart.",
  "hooks": [{ "line": "Stop scrolling if [problem]", "shot": "[product] close-up in hand", "type": "problem" }],
  "scriptSkeletons": [{ "name": "Pain, proof, cart", "beats": "0-2 s: [close-up] / says [pain]; 2-10 s: [proof] / says [benefit]; ..." }],
  "ctas": [{ "line": "Tap the orange cart before [scarcity]", "type": "cart_or_link", "when": "last 3 s" }],
  "voiceRules": ["Short sentences, talk to one viewer."],
  "avoid": ["Long intros before the product is in view."]
}
```

Content runs give `formats`, `openings`, `retentionDevices`, `payoffs` and `shareTriggers` instead of CTAs.

### Pricing

Pay per result. You pay only for videos that were analyzed and delivered.

| Event | Price | When |
|---|---|---|
| Video analyzed (your links) | **$0.06** | per video you linked, any length |
| TikTok Shop selling video found and analyzed | **$0.07** | per selling video, any length, includes finding it from best sellers |
| Top organic video found and analyzed | **$0.11** | per organic video, any length, includes scanning about 8 feed videos for each one kept |
| Cross-video playbook | **$0.25** | once per run |

- **Your first 3 videos are free** (per Apify account), and so is the playbook of a run where every video was free.
- One price per video, whatever its length: each video is analysed up to its first 60 seconds, and `analyzedSeconds` / `durationSeconds` show when a longer one was trimmed. Videos over 10 minutes or 60 MB, files that cannot be read, private or removed videos and photo slideshows are skipped and never charged.
- Set a maximum charge on the run and the Actor stays within it: it only looks for as many videos as the maximum charge (plus your free videos) covers, keeps room for the playbook, and tells you in the run's status (and a `status` row for links) what it skipped. A maximum charge too low for even the smallest search ends the run before anything is fetched. Finding videos has a fixed cost, so a paid run needs a maximum charge of at least $0.06 for links (one video), $0.42 for selling and $0.44 for content ($0.55 with 7-8 hashtags and keyword, $0.66 with 9-10, $0.77 with 11), plus $0.25 when you ask for the playbook. Your free videos always run on their own.

### Good to know

- **Per-video GMV**: TikTok Shop does not publish it today, so `videoGmvUsd` is usually empty; selling videos are ranked by their product's GMV and sales, then views. `gmv30dUsd` fills in once 30 days of sales history exist.
- **Speed**: a single link skips keyword discovery and the optional cross-video summary. Discovery and larger batches can take more than five minutes; runtime depends on TikTok and the analysis service. Videos are processed two at a time.
- **Memory**: runs at 1 GB with 2 videos at a time: files (up to 60 MB) are downloaded to disk and only the (at most 60-second, 14 MB) clip sent to the analysis is held in memory.
- **Faithful, not filtered**: the analysis reports what each video shows and says. Check claims, prices and offers against your own product before you reuse them.
- **Public videos only**: analyze public videos only, and do not redistribute them. The videos and their words belong to their creators; use the analysis and templates to make your own original videos.

Turn a playbook into your own product video with Alvin's Club Studio (studio.alvinsclub.ai).

### FAQ

**Can I use it through the API?** Yes: use the single-video example above, then read the dataset (one row per video). Read `PLAYBOOK` only when you enabled it and at least two videos were analyzed. The new form uses `prefill` values for its one-video example. `includePlaybook` defaults to `false` in the form and API; set it to `true` to request a cross-video summary. Saved tasks that explicitly enable it keep doing so. Existing API calls or tasks that omit this field now return only the per-video analyses; add `includePlaybook: true` if you need the summary. API calls that omit `mode` still default to `selling`, so send `mode: "urls"` for a single-video link.

**Which countries?** Selling mode covers the TikTok Shop markets: US, GB, ID, MY, TH, VN, PH, SG, JP, MX, BR. Content and links mode browse TikTok from almost any country.

**Why is a video missing?** It may be private, removed, region-locked, a photo slideshow, over 60 MB, or a file that cannot be read: it appears as a row with an `error`. A video over 10 minutes appears as a `status` row (skipped; in the finding modes the next video takes its place). Neither costs anything.

**Long videos?** Up to 10 minutes (and a 60 MB file) costs the same as a short one: the analysis covers the first 60 seconds, where the hook, the structure and the CTA usually are. Longer videos are skipped for free.

# Actor input Schema

## `mode` (type: `string`):

Start with one TikTok video link. Select selling or content to find videos instead; discovery can take longer than five minutes.

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

One public example is prefilled. Replace it with your TikTok video link (full links or vm.tiktok.com share links). To analyze a batch, add more links, up to 100. Only used in urls mode.

## `urlVideoType` (type: `string`):

Selling: hook, beats, demo and proof shots, CTA. Content: format, retention devices, payoff and why people share it.

## `keyword` (type: `string`):

Selling: the TikTok Shop search (e.g. "wig", "necklace", "kitchen gadgets"). Content: also search TikTok videos for this phrase. Leave empty to use the category's keyword.

## `category` (type: `string`):

A preset when you have no keyword or hashtags; also tells the analysis what the videos sell.

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

Hashtags to find top organic videos in, with or without # (up to 10), e.g. wigtok, kitchenfinds.

## `country` (type: `string`):

Two-letter market. Selling: a TikTok Shop market (US, GB, ID, MY, TH, VN, PH, SG, JP, MX, BR). Content: the country TikTok is browsed from.

## `maxVideos` (type: `integer`):

How many videos to find and analyze in selling and content mode (5-100). In urls mode every link you give is analyzed (up to 100); the run's maximum charge is what limits spending.

## `maxAgeDays` (type: `integer`):

Only videos posted in the last N days; 0 = any age. Empty: selling any age, content 60 days.

## `minViews` (type: `integer`):

Only videos with at least this many views. Empty: selling 0, content 20,000.

## `includePlaybook` (type: `boolean`):

Optional summary across at least two analyzed videos. Off in a new form; each video already includes its own transcript, hook, beats and reusable template. Adds one $0.25 event when paid; free when all analyzed videos are free.

## `language` (type: `string`):

Descriptions are written in this language; speech and on-screen text are quoted as spoken.

## Actor input object example

```json
{
  "mode": "urls",
  "videoUrls": [
    "https://www.tiktok.com/@6711492781058130950/video/7649770069446135054"
  ],
  "urlVideoType": "selling",
  "country": "US",
  "maxVideos": 20,
  "includePlaybook": false,
  "language": "English"
}
```

# Actor output Schema

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

No description

## `playbook` (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 = {
    "mode": "urls",
    "videoUrls": [
        "https://www.tiktok.com/@6711492781058130950/video/7649770069446135054"
    ],
    "includePlaybook": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("omnipotent_stairway/tiktok-video-analyzer").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 = {
    "mode": "urls",
    "videoUrls": ["https://www.tiktok.com/@6711492781058130950/video/7649770069446135054"],
    "includePlaybook": False,
}

# Run the Actor and wait for it to finish
run = client.actor("omnipotent_stairway/tiktok-video-analyzer").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 '{
  "mode": "urls",
  "videoUrls": [
    "https://www.tiktok.com/@6711492781058130950/video/7649770069446135054"
  ],
  "includePlaybook": false
}' |
apify call omnipotent_stairway/tiktok-video-analyzer --silent --output-dataset

```

## MCP server setup

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

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/3semsAkVfukKJdT7n/builds/TveBSRhWDTSXGUGfr/openapi.json