# Ad Library Video Transcripts & Hooks: TikTok, Facebook, Google (`zephyrous_lampshade/ad-library-video-transcripts`) Actor

Get transcripts and AI breakdowns of competitors' video ads from the TikTok Ad Library, Facebook/Instagram (Meta) Ad Library and Google Ads Transparency Center: hook, hook type, angle, offer, CTA, persona, script structure. Find winning ads and build a swipe file.

- **URL**: https://apify.com/zephyrous_lampshade/ad-library-video-transcripts.md
- **Developed by:** [Jonathan Smith](https://apify.com/zephyrous_lampshade) (community)
- **Categories:** Social media, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 video transcribeds

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

## Ad Library Video Transcripts & Hooks: TikTok, Facebook (Meta) & Google Ads

Get the **transcripts of your competitors' video ads**, plus the **hook, angle, offer and CTA** behind each one. This Actor searches the public **TikTok Ad Library**, **Meta Ad Library** (Facebook & Instagram) and **Google Ads Transparency Center**, downloads every video ad it finds, transcribes the voice-over with Whisper and has an LLM break the script down. You get a clean dataset (JSON, CSV, Excel) and a **swipe file** you can share, with long-running ads (the likely winners) at the top.

Enter a keyword, a competitor name or an ad library URL. You don't need an account or an API key, and you don't have to watch hundreds of ads yourself.

### What does it do?

1. **Finds video ads** in public ad libraries:
   - **TikTok Ad Library**: the DSA transparency library for TikTok ads shown in the EU/EEA, Switzerland, the UK and Turkey
   - **Meta Ad Library**: Facebook and Instagram ads
   - **Google Ads Transparency Center**: YouTube and Google video ads
2. **Downloads each video** and extracts the audio. Only the first *N* seconds are used, so long videos don't add cost.
3. **Transcribes the speech** with Whisper. It detects the language automatically and handles English, German, French, Spanish, Italian, Dutch, Polish and more.
4. **Analyzes the script with AI**. For each ad you get:
   - `hook`: the opening line that stops the scroll
   - `hook_type`: question, pain point, bold claim, social proof, offer, curiosity, UGC testimonial, demonstration or story
   - `angle`: the marketing angle
   - `offer`: discount, free trial, bundle and similar
   - `cta`: the spoken call to action
   - `target_persona`: who the ad is aimed at
   - `script_structure`: the copywriting framework, e.g. PAS, AIDA, before/after/bridge, problem/solution, listicle, testimonial, demo or story
   - `key_claims`: the main promises the ad makes
   - `summary`: a three-sentence description of the ad
5. **Exports** the results:
   - a dataset with one row per ad
   - an **HTML swipe file** (`OUTPUT.html` in the key-value store), sorted by days running
   - a run summary (`OUTPUT`)

### Use cases

- **Creative research for agencies.** See which UGC ad scripts, hooks and offers a niche is using right now, before you write your own.
- **Swipe files.** Build a library of winning ads and their transcripts in a few minutes and share the HTML report with clients or your creative team.
- **Competitor hook tracking.** Track the hooks and angles a competitor tests over time. An ad that has been running for 60+ days is usually profitable.
- **Input for LLM ad-script generators.** Give the transcripts and structured hooks to ChatGPT, Claude or your own GPT as few-shot examples of real ads that perform in your market.
- **Automation with n8n, Make or Zapier.** Run the Actor on a schedule, then send new competitor ads to Slack, Notion, Airtable or Google Sheets through the Apify integrations or webhooks.
- **Market and brand research.** Find out how a category talks to its customers: pain points, promises, social proof and CTAs.

### Use it from Claude, ChatGPT, Cursor or any AI agent

This Actor is built to be called by AI agents through the [Apify MCP server](https://docs.apify.com/mcp): one simple input, a small default run, and every output field described. Ask your assistant things like:

- *"What hooks are HelloFresh's video ads using in Switzerland right now?"*
- *"Get the transcripts of the 10 longest-running TikTok ads for protein powder in Germany and summarize the angles."*
- *"Compare the offers in Nike's and Adidas's Facebook video ads."*
- *"Write 5 new ad scripts in the style of the top competitor ads for 'skincare app'."*

**Add it as a tool** (MCP server URL):

```
https://mcp.apify.com?tools=zephyrous_lampshade/ad-library-video-transcripts
```

**Minimal input** an agent needs:

```json
{ "query": "hellofresh", "country": "CH", "sources": ["tiktok", "meta", "google"], "maxAdsPerSource": 10 }
```

- One required idea: a `query` (keyword or brand), an `advertiser`, or ad library `startUrls`. Everything else has sensible defaults.
- **Cost is predictable**: about **$0.033 per fully analyzed video ad**; a default run (10 ads, TikTok) costs about $0.33. Duplicates and failed steps are free. Set a max charge per run to cap spending; the Actor stops cleanly at the limit.
- **Output** is one row per ad with `transcript`, `hook`, `hook_type`, `angle`, `offer`, `cta_spoken`, `target_persona`, `script_structure`, `key_claims`, `summary`, `daysRunning` and links. A run summary is stored as `OUTPUT`.
- Pay-per-event only and limited permissions, so it can be run by agents that pay per request.

### How to use it

1. Click **Try for free**.
2. Pick the ad libraries (TikTok is selected by default).
3. Enter a **keyword** (e.g. `skincare`), an **advertiser** (e.g. `Nike`), or paste **ad library URLs**.
4. Choose the **country**, e.g. `DE`, `FR`, `IT`, `ES` or `NL`.
5. Click **Start**. Results appear in the **Overview** table as ads are processed. When the run finishes, open `OUTPUT.html` in the key-value store to see the swipe file.

#### Input example

```json
{
    "sources": ["tiktok", "meta", "google"],
    "query": "protein powder",
    "country": "DE",
    "maxAdsPerSource": 25,
    "activeOnly": true,
    "transcribe": true,
    "aiAnalysis": true,
    "outputLanguage": "en",
    "maxVideoSeconds": 120,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

You can also start from ad library links:

```json
{
    "startUrls": [
        { "url": "https://library.tiktok.com/ads?region=FR&adv_name=example&sort_type=last_shown_date,desc" },
        { "url": "https://www.facebook.com/ads/library/?active_status=active&ad_type=all&country=DE&q=sneakers" },
        { "url": "https://adstransparency.google.com/advertiser/AR00000000000000000000?region=DE" }
    ]
}
```

#### Input fields

| Field | Description | Default |
|---|---|---|
| `sources` | `tiktok`, `google`, `meta` | `["tiktok"]` |
| `query` | Keyword search | – |
| `advertiser` | Advertiser name or ID | – |
| `startUrls` | Ad library URLs. The source is detected from each URL. | – |
| `country` | ISO country code, e.g. `DE`. Meta and Google also accept `ALL`. | `DE` |
| `maxAdsPerSource` | Max video ads per library (1–500) | `20` |
| `dateFrom` / `dateTo` | Only ads shown in this date range | – |
| `activeOnly` | Only ads that are still running | `false` |
| `transcribe` | Transcribe each video with Whisper | `true` |
| `aiAnalysis` | Extract hook, angle, offer, CTA, script framework and more | `true` |
| `outputLanguage` | Language of the analysis: `original`, `en`, `de` | `original` |
| `maxVideoSeconds` | How many seconds of each video to transcribe | `180` |
| `proxyConfiguration` | Apify Proxy. Meta uses RESIDENTIAL automatically. | Apify Proxy |

### Output example

Each video ad is one dataset item:

```json
{
    "source": "tiktok",
    "adId": "1790000000000001",
    "adUrl": "https://library.tiktok.com/ads/detail/?ad_id=1790000000000001",
    "advertiserName": "Example Nutrition GmbH",
    "firstShown": "2026-07-02",
    "lastShown": "2026-10-20",
    "daysRunning": 110,
    "isActive": true,
    "countries": ["DE", "AT"],
    "reach": 1250000,
    "adText": "Der Shake, über den alle reden 💪",
    "videoUrl": "https://...mp4",
    "thumbnailUrl": "https://...jpeg",
    "durationSec": 27,
    "transcript": "Ich hab drei Proteinpulver getestet, damit du es nicht musst. Nummer eins ...",
    "transcriptLanguage": "de",
    "transcribedSeconds": 27,
    "hook": "I tested three protein powders so you don't have to.",
    "hook_type": "curiosity",
    "angle": "Honest side-by-side test that ends with one clear winner",
    "offer": "15% off with code PROTEIN15",
    "cta_spoken": "Link in bio, use code PROTEIN15",
    "target_persona": "Gym-goers aged 18–30 who don't trust supplement marketing",
    "script_structure": "listicle",
    "key_claims": ["Best taste of the three", "Mixes without clumps", "25 g protein per serving"],
    "summary": "A UGC creator compares three protein powders. The advertised brand wins on taste and mixability. The ad closes with a discount code.",
    "analysisSource": "transcript",
    "error": null,
    "skipped": [],
    "scrapedAt": "2026-10-22T09:15:00.000Z"
}
```

The dataset has two views:

- **Overview**: advertiser, library, days running, hook, hook type, angle, CTA and ad link
- **Full**: every field, including the full transcript

You can export either view to JSON, CSV, Excel, XML or RSS, or read it through the Apify API.

### Pricing: pay per event

You pay only for results. A step that fails (download error, silent video, AI error) is recorded in the row and **is not charged**.

| Event | Price | When it is charged |
|---|---|---|
| Video ad scraped | $0.003 | Each unique video ad saved with its metadata |
| Video transcribed | $0.02 | Only when a non-empty transcript was produced |
| AI hook & script analysis | $0.01 | Only when the analysis succeeded (also for music-only videos analyzed from their ad copy) |
| Actor start | $0.00005 | Once per run, charged by the Apify platform |

**Same video, several ads:** advertisers often run one video under many ad IDs. Each video is transcribed and analyzed **once per run**; every further ad with the identical video gets the same transcript and analysis, marked with `duplicateOfAdId`, and costs only the $0.003 scrape fee.

**Cost per 100 ads**

| What you get | Cost per 100 ads |
|---|---|
| Metadata only (`transcribe: false`) | **$0.30** |
| Metadata + transcripts (`aiAnalysis: false`) | **$2.30** |
| Metadata + transcripts + AI hook analysis | **$3.30** |

Platform compute is included. You can cap your spend with **Max cost per run** in the run options. When the cap is reached, the Actor stops collecting new ads, finishes the ones it is working on, saves the dataset and the swipe file, and ends with a clear status message. It never charges more than your limit.

### FAQ

#### Is it legal to scrape ad libraries?

The Actor reads **public ad transparency data** — only what any visitor can see without logging in. No accounts, no private data.

- **EU (DSA):** the Digital Services Act requires large platforms to publish a searchable repository of the ads they show in the EU. The TikTok Ad Library and the EU part of the Meta Ad Library are such repositories.
- **Google Ads Transparency Center:** Google's own public transparency site, worldwide.
- **No affiliation:** this Actor is not affiliated with, endorsed or sponsored by TikTok, Meta or Google. All trademarks belong to their owners.
- **Videos are not stored:** each video is downloaded to a temporary file only to extract the audio and is deleted right after. The dataset contains links, metadata, the transcript and the analysis.
- **Your responsibility:** you are responsible for how you use the results. Analyzing ads and taking inspiration is common practice; copying a competitor's creative 1:1 can infringe copyright. If you are unsure, ask a lawyer.

#### Which ad libraries are supported?

- **TikTok Ad Library** (library.tiktok.com)
- **Meta Ad Library** (Facebook and Instagram, facebook.com/ads/library)
- **Google Ads Transparency Center** (adstransparency.google.com, including YouTube video ads)

Only **video ads** are returned. Image and text ads are skipped and not charged.

#### Which countries can I search?

- **TikTok**: EU/EEA countries plus Switzerland (`CH`), the UK (`GB`) and Turkey (`TR`), about one year back. US-only ads are not in this library. Examples: `DE`, `FR`, `IT`, `ES`, `NL`, `PL`, `SE`, `AT`, `BE`, `IE`.
- **Meta**: most countries, or `ALL`. Ads that have stopped running are kept mainly for EU countries (because of the DSA). In other countries you see mostly ads that are still active.
- **Google**: most countries, or `ALL`.

#### Why does Meta need a residential proxy?

The Meta Ad Library blocks datacenter IP addresses. When the Meta source is selected and you use Apify Proxy, the Actor switches to the **RESIDENTIAL** proxy group for Meta automatically, so you don't have to change anything. If you use your own proxies, they must be residential.

#### Which languages are supported?

Whisper detects the spoken language automatically and supports almost every common language. The transcript always stays in the original language. With `outputLanguage` you can get the AI analysis in English or German.

#### Why do some ads have no transcript?

The video may be music-only (no speech), the video file may no longer be available, or the run may have reached your max cost. The `skipped` and `error` fields show the reason for each ad. No transcript is charged in these cases.

For music-only or silent videos that have a headline or ad text, the AI analysis is still made from that **ad copy**, so the hook, angle and CTA columns are filled. These rows have `analysisSource: "ad_copy"` (instead of `"transcript"`) and are charged as one AI analysis.

#### Can I connect it to n8n, Make, Zapier or my own app?

Yes. Use the Apify integrations, webhooks or the API (`run-sync-get-dataset-items`) to send new ad transcripts to Google Sheets, Notion, Airtable, Slack or an LLM pipeline that writes your own ad scripts.

#### How fast is it?

About 4 ads are processed in parallel. Run time depends mostly on the ad library:

- **TikTok and Meta** are the fastest sources. TikTok limits how fast ad details can be read, so large TikTok runs slow down.
- **Google Ads Transparency Center** is the slowest. Google rate-limits datacenter IPs, and the Actor waits and retries instead of failing, which can add several minutes. In our tests, 3 Google ads plus 3 TikTok ads took about 3.5 minutes on a datacenter IP.

Start with a small `maxAdsPerSource` (for example 5) to see the speed for your query, then scale up.

### Examples and code

Real teardowns (HelloFresh, Duolingo, Trade Republic), Python/Node scripts, MCP configs and prompt templates: [github.com/video-ad-research/competitor-video-ads-ai](https://github.com/video-ad-research/competitor-video-ads-ai).

### Related keywords

TikTok ads transcript, Facebook ads transcript, Facebook Ad Library scraper, Facebook ads spy, competitor video ads, MCP tool for ad research, AI agent ad analysis, Meta Ad Library scraper, TikTok Ad Library scraper, Google Ads Transparency Center scraper, video ad transcript, ad hook extractor, competitor ads, ad spy tool, ad swipe file, UGC ad script, winning ads, creative research, ad intelligence.

# Actor input Schema

## `sources` (type: `array`):

Which public ad libraries to search. TikTok = TikTok Ad Library (EU DSA transparency), Google = Google Ads Transparency Center (YouTube/Display video ads), Meta = Meta Ad Library (Facebook & Instagram; needs a residential proxy, which is selected automatically). Sources implied by Start URLs are added automatically.

## `query` (type: `string`):

Search term, e.g. a product category ("protein powder"), a brand or a topic. Leave empty if you use Advertiser or Start URLs. If Query, Advertiser and Start URLs are all empty, a small demo search runs (TikTok, "skincare", 5 ads).

## `advertiser` (type: `string`):

Optional advertiser name or ID to restrict results to one competitor (e.g. "Nike" or a Google advertiser ID like AR0123...).

## `startUrls` (type: `array`):

Optional. Paste search, advertiser or single-ad URLs from library.tiktok.com, adstransparency.google.com or facebook.com/ads/library. The matching source is detected from the URL.

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

Two-letter country code (ISO 3166-1 alpha-2), e.g. DE, FR, IT, ES, NL, PL, SE. The TikTok Ad Library only covers EU/EEA countries (+CH, UK). Use "ALL" where supported (Meta, Google).

## `maxAdsPerSource` (type: `integer`):

Maximum number of video ads to collect from each selected ad library (default 10). You are charged per ad (about $0.033 for a fully transcribed and analyzed ad), so start small.

## `dateFrom` (type: `string`):

Only ads shown on or after this date (YYYY-MM-DD).

## `dateTo` (type: `string`):

Only ads shown on or before this date (YYYY-MM-DD).

## `activeOnly` (type: `boolean`):

Skip ads that are no longer running. Long-running active ads are usually the winners.

## `transcribe` (type: `boolean`):

Download each video and transcribe the voice-over with Whisper (multilingual, auto language detection). Charged only when a transcript is produced.

## `aiAnalysis` (type: `boolean`):

Run an LLM on each transcript to extract hook, hook type, angle, offer, CTA, target persona, script structure and a summary. Requires transcription. Charged only on success.

## `outputLanguage` (type: `string`):

Language of the AI analysis fields. The transcript itself always stays in the original spoken language.

## `maxVideoSeconds` (type: `integer`):

Only the first N seconds of each video are transcribed. Hooks live in the first 3 seconds, most ads are under 60 s.

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

Apify Proxy is used by default. The Meta Ad Library blocks datacenter IPs, so the Meta source automatically uses the RESIDENTIAL proxy group (you don't need to change anything). Custom proxy URLs are used as-is for all sources.

## Actor input object example

```json
{
  "sources": [
    "tiktok"
  ],
  "query": "skincare",
  "country": "DE",
  "maxAdsPerSource": 10,
  "activeOnly": false,
  "transcribe": true,
  "aiAnalysis": true,
  "outputLanguage": "original",
  "maxVideoSeconds": 180,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One item per video ad: advertiser, dates, days running, links, the full transcript and the AI analysis (hook, hook type, angle, offer, CTA, persona, script structure, summary).

## `swipeFile` (type: `string`):

Readable HTML swipe file: one card per video with thumbnail, hook, analysis, transcript snippet and links, sorted by days running.

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

Counts per source (found, transcribed, analyzed, errors), charged events and the link to the swipe file.

# 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 = {
    "sources": [
        "tiktok"
    ],
    "query": "skincare",
    "country": "DE",
    "maxAdsPerSource": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zephyrous_lampshade/ad-library-video-transcripts").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 = {
    "sources": ["tiktok"],
    "query": "skincare",
    "country": "DE",
    "maxAdsPerSource": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("zephyrous_lampshade/ad-library-video-transcripts").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 '{
  "sources": [
    "tiktok"
  ],
  "query": "skincare",
  "country": "DE",
  "maxAdsPerSource": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call zephyrous_lampshade/ad-library-video-transcripts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zephyrous_lampshade/ad-library-video-transcripts"
        }
    }
}
```

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/5bnBk7dHJrN7wdJ7X/builds/48hoBCTzprhrwaDDr/openapi.json