Hook Mining Ads: Extract Winning Hooks from 1,000 Competitors

Your competitors have already paid to test thousands of hooks. Every long-running video ad in a niche is a hook that survived: the first three seconds stopped enough thumbs that the advertiser kept funding it week after week. Hook mining ads at scale means extracting those opening seconds from a thousand competitor creatives, clustering them into named patterns, and feeding the proven ones into your own content engine.

TL;DR: The hook mining ads pipeline has three steps. Pull long-running competitor video ads through an ad library API, enrich them for timestamped transcripts, then cluster the opening lines with an LLM into hook patterns scored by runtime. Roughly 160 credits turns 1,000 competitor ads into a ranked hook library. This guide covers the full hook taxonomy, working code for every step, longevity scoring, and a worked example that produced three brief-ready patterns.

This is written for creative strategists who feed a production pipeline and are tired of guessing which opening line deserves the next shoot day.

Why the First Three Seconds Carry the Whole Ad

A video ad is a sequence of decisions, and the viewer makes the most brutal one immediately. Either the opening frame and line earn a pause, or your CPM bought a blur in someone's feed. Hook rate, the share of impressions that watch past three seconds, is the metric that captures this — and on Meta it routinely separates creatives that scale from creatives that die in week one. We've covered why hook rate decides Meta ads in depth, but the short version: a 35% hook rate ad and a 20% hook rate ad with identical mid-rolls produce wildly different CPAs, because everything downstream of second three is multiplied by who's still watching.

The frustrating part is that hooks are cheap to write and expensive to validate. A thumb-stop moment costs nothing to script. Proving it works costs ad spend, a learning phase, and a week of your testing calendar. Most teams can validate maybe 10-20 hooks a month against cold traffic.

Your market, collectively, validates thousands. Every funded brand in your niche is running hook experiments right now and killing the losers. The results are sitting in public ad libraries. That asymmetry is the entire case for mining.

Hooks also transfer unusually well between products. An offer is specific to a brand and a price point, but "name the pain in the viewer's own words" works for serums, software, and supplements alike. Mining at the hook level means the patterns you extract from a competitor's account survive contact with your own product in a way that whole-ad copying never does.

What Hook Mining Actually Is

Hook mining is competitor research narrowed to one creative element. Instead of analyzing whole ads (offer, edit, landing page, the works) you extract only the first three to five seconds of copy and visual concept from a large set of competitor video ads, then look for the patterns that repeat among the survivors.

The survivorship logic does the heavy lifting. Ad platforms are ruthless markets: advertisers kill creatives that don't convert, usually within days. An ad that has run for 60, 90, 120 days is an ad somebody is choosing to keep paying for. When you detect winning ads programmatically by runtime, you're reading the market's revealed preference rather than its claims. The same logic powers the broader practice of reverse-engineering winning ads — hook mining just applies it to the three seconds where the stakes are highest.

You can do a manual version of this today. Meta's Ad Library shows any page's active ads, Google's Ads Transparency Center covers YouTube and Search, TikTok's Creative Center ranks top ads by engagement, and the LinkedIn Ad Library does the same for B2B. Manual mining works for 20 ads. It collapses at 1,000, which is the scale where patterns stop being anecdotes. For that you need the data as JSON, which is what an ad library API is for.

A Working Hook Taxonomy: Eight Patterns That Repeat

Clustering works better when the model has names to anchor on, so before mining anything, internalize the taxonomy. Across DTC and app niches, the overwhelming majority of video hooks land in one of eight buckets:

1. Problem call-out. Names the viewer's pain in their own words, fast. "If your moisturizer pills under sunscreen, watch this." The dominant pattern in cold-audience DTC creative because it self-selects the right audience in one line.
2. Social proof receipt. Leads with evidence instead of claims — review counts, sold-out screenshots, a wall of duplicate orders. Borrowing trust is faster than building it, which is why social proof hooks age so well.
3. Demo-first. No setup, no talking head. The product does the impressive thing in frame one. Cleaning products, kitchen tools, and software UI ads live here.
4. Contrarian. Attacks a belief the viewer holds. "Stop drinking your collagen." Pattern-interrupts earn attention by creating a small, urgent argument.
5. Curiosity gap. Withholds the noun. "I found the reason your laundry smells, and it's behind this panel." Risky, because weak payoffs train audiences to ignore you.
6. Confession / founder story. A person admits something costly. "I almost shut this company down in March." The native register of UGC ads, and the hardest to fake.
7. Us-vs-them comparison. Positions against the category default. "Why we don't use plastic pods." Implicitly competitive, great for switchers.
8. News hijack. Frames the product against a change in the world. "Since the algorithm update, sellers are doing this instead." Highest decay rate of the eight.

Real hooks blend buckets, and your niche will surface sub-patterns the taxonomy doesn't name yet. That's fine. The list is scaffolding for the clustering step, not a cage. Each bucket is also a distinct creative angle, which matters later when you turn clusters into briefs.

The Hook Mining Ads Pipeline at a Glance

The full hook mining ads workflow has three stages, each feeding the next:

1. Filter. Query an ad library API for video ads in your niche, sorted by runtime, and collect roughly 1,000 of them. Long runtime is your survivorship filter.
2. Enrich. Run AI enrichment on the strongest candidates to get timestamped transcripts and a structured read of each creative. The hook text lives in the first scenes of the transcript.
3. Cluster. Feed the extracted hooks to an LLM, map them onto the taxonomy, and score each cluster by longevity.

I'll build it on the AdLibrary API, because it's the setup I know and it covers eleven platforms (Facebook, Instagram, TikTok, YouTube, Google, LinkedIn, Twitter, Pinterest, Yahoo, Unity Ads, and AdMob) through one key. Worth saying plainly: Meta's own Ad Library API is free, and if EU/UK Meta ads or political transparency data are all you need, use it and save the money. It won't return commercial ad data outside those regions, performance signals, or transcripts, which is exactly the data this pipeline runs on. The AdLibrary API is a paid upgrade on that idea, not a free replacement.

Budget math up front, since everything is credit-based: collecting 1,000 ads costs 10 search credits, and enriching the top 150 costs about 150 more. Call it 160 credits per niche-sized mining run, comfortably inside one month of a Business plan allowance. If you already script your research, the patterns below will look familiar from our Python ad library cookbook.

Step 1: Filter 1,000 Long-Running Video Ads

The query that does the work sorts by -days (runtime descending), restricts to video, and looks back a full year. Sorting by likes or impressions surfaces viral outliers. Sorting by runtime surfaces ads that keep earning their budget, which is the signal a hook mining ads run needs.

import requests, time

API_KEY = "adl_your_api_key"
BASE = "https://adlibrary.com/api"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def collect_ads(keyword, target=1000):
    ads, page = [], 1
    while len(ads) < target:
        r = requests.post(f"{BASE}/search", headers=HEADERS, json={
            "keyword": keyword,
            "appType": "3",            # e-commerce vertical
            "adsType": ["2"],          # video only
            "platform": ["facebook", "instagram", "tiktok", "youtube"],
            "geo": ["US"],
            "daysBack": 365,
            "sortField": "-days",      # longest-running first
            "page": page,
            "pageSize": 100,
        })
        if r.status_code == 429:
            time.sleep(int(r.headers.get("Retry-After", 10)))
            continue
        r.raise_for_status()
        data = r.json()
        ads.extend(data["results"])
        print(f"page {page}: total pool {data['total']}, "
              f"credits left {data['_credits']['remaining']}")
        if page * 100 >= data["total"]:
            break
        page += 1
        time.sleep(6)  # stay under 10 requests/min
    return ads

ads = collect_ads("skincare serum")

On keyword choice: one keyword rarely covers a niche. "Skincare serum" misses ads that open on "retinol" or "niacinamide" without ever saying serum. Run the collector across three to five keyword variants and merge the results, since deduplication on ad_key handles the overlap for free. Broader keywords pull more noise but catch the category-adjacent advertisers whose hooks you'd never see from inside your own vertical.

A few practical notes. Each page is one credit, and a failed search refunds itself, so a 500 never costs you anything. The search response includes a total count, so you know after page one whether the niche even has 1,000 video ads — if total comes back at 220, broaden the keyword instead of paging into thin air. Rate limits are 10 requests per minute and 10,000 per day per key, and the Retry-After header tells your client exactly how long to back off.

Once collected, do a cheap local pass before spending anything on enrichment. Deduplicate on ad_key, drop ads with a days_count under 21 (they haven't proven anything yet), and sort the remainder by runtime. The age of each creative is also worth eyeballing against its advertiser's broader cadence — ad timeline analysis shows whether a 90-day runtime is exceptional for that brand or just how they operate. Keep the top 150 to 200. Those are your enrichment candidates.

Step 2: Enrich for Transcripts, Themes, and Hook Text

Raw search results give you copy, creative URLs, and engagement, but a video hook lives inside the video. To mine it you need the spoken words and on-screen text from the opening seconds, which means transcription. That's what AI ad enrichment is for: point the endpoint at an ad and it returns a structured teardown with a full scene-by-scene, timestamped transcript, a strategic read of the targeting and message, and a persuasion analysis that explicitly identifies the hook and why it stops the scroll.

def enrich(ad):
    r = requests.post(f"{BASE}/enrichment", headers=HEADERS, json={
        "ad": {
            "ad_key": ad["ad_key"],
            "platform": ad["platform"],
            "video_url": ad.get("video_url"),
            "advertiser_name": ad.get("advertiser_name"),
        }
    })
    r.raise_for_status()
    return r.json()["enrichment"]

candidates = sorted(ads, key=lambda a: a.get("days_count", 0), reverse=True)
enriched = []
for ad in candidates[:150]:
    e = enrich(ad)
    enriched.append({
        "ad_key": ad["ad_key"],
        "advertiser": ad.get("advertiser_name"),
        "days": ad.get("days_count"),
        "transcript": e["transcription"],
        "analysis": e["analysis"],
    })
    time.sleep(3)  # 20/min enrichment limit

Each analysis costs one credit for text and standard-length video, refunded automatically if it fails, and videos past the three-minute mark bill extra. That cost structure is why you filter hard in step 1: enrich the 150 proven survivors, not the full thousand. We've covered what enrichment extracts at scale separately if you want the full field-by-field breakdown.

From each transcript, slice the hook. The first one or two scene blocks (everything before roughly the five-second mark) are your hook text. Store it alongside the ad's runtime and advertiser name. After this step you have 150 rows of hook_text, advertiser, days_running, which is the actual ore this whole hook mining ads operation exists to produce.

Step 3: Cluster Hooks into Patterns with an LLM

Reading 150 hooks in a spreadsheet, you'll spot maybe four patterns before your eyes glaze. An LLM spots the rest, and more importantly, it labels them consistently. Feed it the taxonomy from earlier as anchor categories and let it propose emergent sub-patterns the anchors don't cover.

A prompt that works well:

You are a creative strategist analyzing video ad hooks.
Below are 150 hooks (opening ~5s transcript) from long-running
competitor ads, each with runtime in days.

1. Assign each hook to one primary pattern: problem-call-out,
   social-proof, demo-first, contrarian, curiosity-gap,
   confession, comparison, news-hijack — or propose a new
   pattern name if none fits.
2. For each pattern, return: pattern name, count, median
   runtime, 3 representative hooks (verbatim), and the
   structural template ("If your {pain}, watch this").
3. Flag patterns used by 3+ distinct advertisers.

Return JSON: [{pattern, count, median_days, advertisers,
examples, template}].

HOOKS:
{rows}

Two details matter here. Asking for the structural template is what turns a pile of examples into something a copywriter can run with, because "If your {pain}, watch this" generates fifty hooks while "here are three skincare ads" generates a shrug. And the 3+ advertisers flag separates patterns the market has converged on from one brand's house style. A single advertiser running 12 variants of the same hook tells you about their tastes. Five advertisers independently paying for the same structure tells you about the customer.

This clustering step is also where the AI creative iteration loop plugs in: the same LLM session that names the patterns can immediately draft on-brand variants of each, which compresses the distance between research and production to a single context window.

Score Hooks by Longevity, Not Likes

Engagement metrics flatter the wrong hooks. Likes reward entertainment and shares reward controversy. Neither rewards conversion. Runtime does, because runtime is a recurring decision made by someone staring at the actual ROAS, and that person has every incentive to turn off what isn't paying back. So score each cluster on longevity-weighted signals:

Spend here is always an estimate (no platform reports actual competitor budgets), so treat it as a tiebreaker rather than a verdict — our ad spend estimator explains how those estimates are derived and where they wobble. The recency signal deserves emphasis. A hook pattern with a 90-day median but no new entries in four months is a pattern the market is quietly abandoning, probably to creative fatigue. You want patterns that are both proven and alive.

The output of this step is a ranked shortlist, usually three to six patterns with scores that clearly separate from the pack. Resist the urge to test all of them at once. A focused creative testing slate of two or three patterns, each with multiple executions, resolves faster than a scattershot of ten.

From Mined Hook to Brief

A pattern isn't a brief. The handoff to production needs five fields per pattern, and at this point you have all of them:

• Pattern name and template. From the clustering output: "Problem call-out: 'If your {pain}, {watch/stop} this.'"
• Evidence block. Median runtime, advertiser count, and two verbatim examples with their runtimes. This is what gets a skeptical media buyer to approve the shoot.
• Why it works. One paragraph from the enrichment analysis, in plain language a creator can act on.
• Five hook variants. Written for your product and proof points. Enrichment's replication briefs include hook variations for UGC formats, which make strong raw material, but rewrite them in your brand voice rather than shipping them verbatim.
• Kill criteria. The hook rate threshold below which you stop spending. Decide it before launch, not after.

We've published a full walkthrough of turning a competitor ad into a creative brief with an LLM in the loop, and the brief format slots straight into a creative strategist workflow. One caution that separates mining from theft: you are extracting structures, never sentences. Copying a hook verbatim is plagiarism with extra steps and it reads as stale to any audience that saw the original. The pattern is the asset. Your product supplies the words. The same rule applies to your swipe file generally.

Worked Example: Three Patterns from One Hook Mining Ads Run

Here's what this looks like end to end. We ran the hook mining ads pipeline on US skincare: 1,000 video ads collected with sortField: "-days", top 150 enriched, clustered with the prompt above. Corpus median runtime was 23 days. Three patterns cleared the scoring bar:

Pattern 1 — SPF-conflict problem call-out. Template: "If your {product A} {fails} under {product B}, this is why." 14 hooks, 9 advertisers, median runtime 71 days. Every one names a compatibility pain (pilling under sunscreen, makeup separating over moisturizer) rather than a generic one. The brief direction wrote itself: find the compatibility complaint in your own reviews and lead with it verbatim.

Pattern 2 — receipts-on-screen social proof. Template: open on a screen recording of {review count / sold-out notice / reorder cart}, voiceover reads one skeptical-sounding review. 11 hooks, 6 advertisers, median runtime 64 days. Notably, the highest-runtime examples used lukewarm reviews ("I didn't expect much...") instead of five-star gush, which reads as more credible in the first second.

Pattern 3 — routine-reduction contrarian. Template: "Stop {common routine step}." 8 hooks, 5 advertisers, median runtime 58 days, and the freshest cluster, with three entries under 30 days old. The structure works because it threatens a habit the viewer performed this morning. The danger is payoff debt: the body of the ad has to genuinely justify the claim or hook rate converts to outrage in the comments.

Worth noting what didn't clear the bar. The run surfaced a large curiosity-gap cluster (19 hooks) with a median runtime of only 26 days, barely above the corpus median, and a demo-first cluster that scored well on runtime but came from just two advertisers. Both got logged and skipped. A mining run earns its keep as much by what it tells you to ignore as by what it tells you to test.

Each pattern became a brief with five product-specific hook variants, and the two-week test slate launched with pattern 1 and 2 executions head-to-head. That's the whole loop: from a thousand strangers' ad spend to a ranked, evidenced test slate in an afternoon of compute. Because niches shift, the run is worth repeating: automated competitor monitoring on a monthly schedule catches new patterns the month they emerge, and the 3-second hook landscape moves fast enough to make that worthwhile.

Frequently Asked Questions

What is hook mining in advertising?

Hook mining is the practice of extracting the opening three to five seconds from large sets of long-running competitor video ads, then clustering those openings into named, reusable hook patterns. Runtime acts as the quality filter: ads that run for months are ads that keep converting, so their hooks carry validated attention-capture structures you can adapt for your own creative.

How many competitor ads do you need to mine hooks effectively?

Around 1,000 collected ads filtered down to 100-200 enriched transcripts is a practical sweet spot for one niche. Below a few hundred collected ads, clusters are too thin to distinguish market-validated patterns from one brand's house style. The key threshold is advertiser diversity: a pattern needs three or more independent advertisers before it counts as market-proven.

Can you do hook mining with Meta's free Ad Library API?

Only partially. Meta's Ad Library API is free but built for transparency: full ad coverage is limited to EU/UK ads from the last 12 months, it covers Meta platforms only, and it returns no runtime-sortable performance signals or transcripts. It works for manual spot-checks. For cross-platform mining at scale with runtime sorting and AI transcripts, you need a paid ad intelligence API such as AdLibrary's.

How much does a hook mining run cost?

On the AdLibrary API, collecting 1,000 ads costs 10 search credits (100 ads per page) and enriching the top 150 costs roughly 150 credits, so a full run lands around 160 credits. The Business plan at €329/month includes 1000+ monthly credits and API access, which covers several mining runs plus ongoing monitoring.

How do you score which mined hooks are worth testing?

Weight median cluster runtime most heavily (about 40%), then advertiser diversity, recency of the newest ad in the cluster, and estimated spend. Longevity beats engagement metrics because advertisers kill ads that stop converting, while likes only measure entertainment. Patterns that are proven, used by several advertisers, and still attracting fresh entries go to the top of the test slate.

Mine What the Market Already Paid to Learn

A hook mining ads pipeline flips the economics of creative research. Instead of paying to validate twenty hooks a quarter, you read the validation your competitors already bought, across a thousand competitor ads, and spend your own budget only on executing the patterns that survived. The method itself is mechanical: filter by runtime, enrich for transcripts, cluster with an LLM, score by longevity, then hand production a brief with the evidence attached.

The pipeline above runs on one API key, no app review, and about 160 credits per niche. API access ships with the Business plan at €329/month with 1000+ credits, enough to mine your category and keep a monthly monitoring job running on top — see pricing for the details. Your competitors finished this quarter's hook testing already. The results are sitting in the libraries, waiting for someone to mine them.