Detect Competitor Campaign Launches Within Days, Not Months

There is a dependable way to detect competitor campaign launches in their first week, and most growth teams never build it. Instead they learn about a rival's push the way you probably did last quarter: the CEO screenshots an ad from his LinkedIn feed, three weeks after it started running, and asks why nobody flagged it.

TL;DR: Every ad in a serious ad library carries a first_seen timestamp. Scan each competitor once to build a baseline, diff the results every morning, and alert when new-creative volume spikes or a never-before-seen landing page shows up. The whole loop runs as a cron job, costs about 6 API credits a day for six competitors, and surfaces launches in 2-4 days instead of 3-6 weeks.

That gap matters more than it sounds. A competitor who launches in week one and gets discovered in week five has had a month of uncontested auctions and unanswered messaging. This guide builds the full detection system, from the launch signal itself through baselines, diffs, spike rules, alerts, and the response playbook. Code included.

Why You Hear About Competitor Launches Last

Your dashboards are lagging indicators of competitor behavior. When a rival pushes serious budget into your market, the first traces in your own data are indirect. CPMs creep up a few percent and CTR softens as your audience sees a fresh angle next to your tired one. CAC starts drifting a week after that. None of those moves is unambiguous on day three. Auction prices wobble for a dozen reasons, and your attribution noise is bigger than a competitor's opening-week spend.

So the signal has to compound before anyone trusts it. In practice that takes three to six weeks, by which point the competitor has finished their learning phase and scaled their winners. You are reacting to a campaign that is already optimized.

Manual checking fails for a different reason. Someone on the team commits to reviewing the Meta Ad Library every Monday. It works for two weeks. Then a launch of your own eats the calendar, the Monday ritual dies, and the next time anyone looks is when the CEO forwards the screenshot. Ongoing competitor ad monitoring survives only when no human has to remember to do it.

The asymmetry is the painful part. Your competitor spent months planning that launch. Your response starts with a lag you chose by not instrumenting the one data source that announces launches on day one. Competitive intelligence is rarely about secret data. It is about reading public data faster than the other side expects, and reading it on a schedule is what lets you detect competitor campaign launches while the campaign is still in its own learning phase.

first_seen: The Timestamp That Turns Forensics Into an Alert

Ad transparency surfaces already publish launch dates. Meta's Ad Library shows "Started running on" for every active ad. The Google Ads Transparency Center shows the date range an ad has run. The LinkedIn Ad Library and the TikTok Commercial Content Library expose similar windows. The launch evidence is public the day it happens. What is missing in all of those browsing interfaces is a way to query the date instead of reading it.

That is what first_seen gives you. In the adlibrary API, every ad object carries first_seen and last_seen as Unix timestamps, plus days_count for runtime. A creative with first_seen inside the last 72 hours is a brand-new creative, full stop. You can sort an entire search on it with sortField: "-first_seen", which means "show me the newest ads in this market first" is a single API parameter rather than an afternoon of scrolling.

One field changes the job description. Without it, launch detection is forensics, digging through ad libraries to reconstruct what already happened. With it, detection is an alert: the timestamp crosses a threshold and a Slack message writes itself.

A note on data sources, because it shapes what you can build. Meta's free Ad Library API is built for transparency research. It is genuinely useful, and it is free, but it returns political and social-issue ads for most of the world, covers Meta only, and requires app review plus identity verification before your first call. It is fine for one platform. The moment you want TikTok, YouTube, or LinkedIn launches in the same diff, you need a commercial ad intelligence source. The adlibrary API is the paid option this guide uses: one adl_ key, eleven platforms, and performance signals like impressions, estimated spend, and a heat score on every commercial ad. Full endpoint details live in the API documentation and implementation guide.

Step 0: Resolve Every Competitor to Advertiser IDs

Brand names are ambiguous. "Nike" on Meta is Nike, Nike Football, Nike Run Club, and a pile of regional pages. Before any monitoring runs, resolve each competitor name to concrete platform IDs, because everything downstream diffs per advertiser, and a diff against the wrong page is noise with a confident face.

The resolution call is free:

curl -G "https://adlibrary.com/api/advertisers/search" \
  -H "Authorization: Bearer adl_your_api_key" \
  --data-urlencode "q=nordicsleep" \
  --data-urlencode "country=US"

The response returns a best_match with the Meta page ID, the Google advertiser ID, and the LinkedIn company ID, plus a confidence score that tells you whether the platforms agree they found the same brand. Candidates are listed per platform so you can pick the right account when a brand runs several.

Save each resolved competitor so the IDs persist:

curl -X POST "https://adlibrary.com/api/advertisers" \
  -H "Authorization: Bearer adl_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "NordicSleep",
    "domain": "nordicsleep.com",
    "meta_page_ids": ["104233456789012"]
  }'

Saving is free, and a saved advertiser can hold every account a brand operates. Do this once for your whole competitive set. Resolving six competitors for a competitor ad research project took me under ten minutes, and the IDs almost never change. For choosing which competitors deserve a slot at all, the ads spy guide covers selection in depth.

Build the Baseline: One Scan Per Competitor

A diff needs something to diff against. The baseline scan answers one question per competitor: what does normal look like right now?

Pull the current portfolio with a search sorted by first_seen:

curl -X POST "https://adlibrary.com/api/search" \
  -H "Authorization: Bearer adl_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "keyword": "nordicsleep",
    "appType": "3",
    "sortField": "-first_seen",
    "daysBack": 90,
    "pageSize": 60
  }'

Each search costs one credit per page, and the response tells you total so you know how deep to paginate. For a typical DTC competitor, two or three pages capture the active portfolio. Store four fields per ad: ad_key, first_seen, landing_page_url, and ads_type. The ad_key is the stable identifier across calls, so it is the dedup key for everything that follows.

While you are in there, record two baseline statistics per competitor. First, portfolio size: how many distinct active creatives they run. Second, creative cadence: how many new first_seen values appear per week across the 90-day window. Those two numbers calibrate every alert threshold later, because a brand that ships 20 creatives a week needs a very different spike rule than one that ships two.

Two honesty notes about the data, since your thresholds live on top of it. Impression figures are bucketed ranges, not exact counts, so treat them as bands. Spend is always an estimate derived from reach signals, never a number reported by the advertiser. Both are still excellent for relative comparison, which is all launch detection needs. And because the API covers eleven platforms through the same endpoint, the identical baseline logic works whether the competitor lives on Meta, TikTok, or LinkedIn.

Daily Diffs: How to Detect Competitor Campaign Launches Automatically

The detection loop is deliberately boring. Every morning, re-run a narrow search per competitor, compare the returned ad_key values against your stored baseline, and record anything new. New keys with a first_seen inside the window are your launch candidates.

Here is a compact version of the daily job in Python:

import json
import requests

API = "https://adlibrary.com/api"
HEADERS = {"Authorization": "Bearer adl_your_api_key"}
COMPETITORS = ["nordicsleep", "dreamcloud", "softlayer"]

def pull_recent(keyword):
    r = requests.post(f"{API}/search", headers=HEADERS, json={
        "keyword": keyword,
        "appType": "3",
        "sortField": "-first_seen",
        "daysBack": 7,
        "pageSize": 60,
    })
    r.raise_for_status()
    return r.json()["results"]

def run_diff():
    with open("baseline.json") as f:
        baseline = json.load(f)

    alerts = []
    for brand in COMPETITORS:
        known = baseline.setdefault(brand, {})
        fresh = [a for a in pull_recent(brand) if a["ad_key"] not in known]
        for ad in fresh:
            known[ad["ad_key"]] = {
                "first_seen": ad.get("first_seen"),
                "landing_page": ad.get("landing_page_url"),
                "ads_type": ad.get("ads_type"),
            }
        if fresh:
            alerts.append({"brand": brand, "new_ads": len(fresh), "ads": fresh})

    with open("baseline.json", "w") as f:
        json.dump(baseline, f)
    return alerts

Schedule it with cron at 06:00, and respect the rate limit of 10 requests per minute by keeping the pulls sequential. The job costs one credit per competitor per day, because daysBack: 7 keeps each pull to a single page in almost every case.

Most mornings the diff returns one or two new creatives per brand, or nothing. That is the point. The system's value is concentrated in the handful of mornings per quarter when it returns fourteen.

If you would rather not host a script, the same loop builds cleanly in workflow tools. There are production-ready recipes for n8n, Make.com, and Zapier, and the end-to-end pipeline pattern is covered in automated competitor ad monitoring. A sibling post covers the resolve, save, curate, diff architecture in more depth.

Volume Spikes Are the Launch Fingerprint

A single new ad means nothing. Brands refresh creative constantly, and a healthy creative testing program produces a steady trickle of new first_seen dates that you must learn to ignore.

Launches look different. A campaign launch is an organizational event: a creative team produced a batch of assets, a media buyer set up new campaigns, and everything went live inside the same 48-72 hours. The data signature is unmistakable. Ten, fifteen, sometimes twenty new ad_key values appear in one diff, clustered tightly on first_seen, often sharing one creative angle and one destination.

The spike rule that has held up best for me: alert when the trailing 7-day new-creative count exceeds three times the trailing 8-week weekly median for that competitor. The per-brand median matters. A brand whose normal cadence is 2 new creatives a week trips the alarm at 7. A brand that ships 15 a week needs 45 before you care. Hard-coded global thresholds are how monitoring systems drown their owners.

Format mix sharpens the read. Check ads_type across the new batch: 1 is image, 2 is video, 3 is carousel, 4 is collection. A burst that is 80 percent video from a brand that historically runs static images signals real production budget, which signals a planned push rather than a desperate refresh. Runtime data from ad timeline analysis then tells you within two weeks whether the batch is sticking or being culled. Volume plus clustering is enough to detect competitor campaign launches without a human reading a single creative.

Landing Page Changes Confirm the Launch

Volume says something happened. The landing page says what. Every search result includes landing_page_url, and diffing that field against your baseline separates the three events that all look like spikes:

The strongest single confirmation in the whole system is a cluster of new creatives pointing at a URL path that has never appeared in your baseline. Brands build the landing page before the campaign goes live. When /products/cooling-duvet shows up in landing_page_url for nine new ads and your baseline has never once contained that path, the launch is confirmed without a human looking at a single creative.

Path families are worth normalizing before you compare. Strip query strings and tracking parameters, keep the path, and bucket on the first two segments. Otherwise every UTM variation registers as a new page and the false-positive rate climbs until someone mutes the channel.

The geo field deserves the same treatment. New creatives, known landing page, but geo suddenly includes DEU and FRA where the baseline was USA-only? That is a market entry, and arguably more strategically urgent than a product launch at home.

Alert Design That Survives Noise

Most systems built to detect competitor campaign launches die of alert fatigue within a month, not of missed detections. The diff is easy. Keeping the channel trustworthy is the actual engineering problem.

Four noise sources account for nearly all false alarms. Routine creative refreshes, which the per-brand spike multiple already handles. Retargeting variants, where one concept ships in eight near-identical executions, handled by grouping new ads that share a landing page and counting concepts instead of creatives. Seasonal promos, where every brand spikes simultaneously around Black Friday, handled by suppressing alerts when the whole portfolio moves together. And platform churn, where an ad gets re-indexed under a fresh key, handled by checking that the creative text is genuinely new to your stored set.

Then route by severity instead of treating every event the same:

• Info (logged, weekly digest): 1-3 new creatives, known landing pages. Normal operations.
• Watch (daily digest): spike multiple exceeded, but all destinations known. Probably a refresh wave, possibly a soft launch.
• Act (instant Slack ping): spike multiple exceeded AND a never-seen landing page or geo. This is the one that interrupts someone's morning.

The instant tier should fire a handful of times per quarter. If it fires weekly, your thresholds are wrong, and the team will learn to ignore it. Posting to Slack is the trivial part:

def notify(alert):
    requests.post(SLACK_WEBHOOK_URL, json={
        "text": (
            f"*{alert['brand']}* launch signal: {alert['new_ads']} new creatives, "
            f"new LP {alert['new_lp']}, first_seen within 48h"
        )
    })

Add a cooldown so the same brand cannot page the channel twice in 72 hours. The second day of a launch is rarely news once the first day fired correctly.

Case Walkthrough: Catching a Launch in Four Days

Concrete numbers show what it looks like to detect competitor campaign launches in practice. The scenario: you run growth at a sleep-products DTC brand, tracking six competitors. NordicSleep is the one that scares you. Baseline from your initial scan: 238 active creatives, a median of 3 new creatives per week, every landing page on nordicsleep.com/products/ paths you have catalogued, geo US-only.

Day 0, Tuesday. NordicSleep launches a cooling duvet. You do not know this yet. Nothing in your metrics moves.

Day 1, Wednesday 06:00. The cron job runs its usual six searches, six credits. The NordicSleep diff returns 6 new ad_key values, all with first_seen inside the previous 36 hours, and 5 of the 6 point at /products/cooling-duvet, a path with zero baseline matches. Spike multiple: 6 against a weekly median of 3, with a brand-new landing page. The Act alert fires at 06:04. Your performance lead reads it with her first coffee.

Day 2, Thursday. The diff adds 8 more keys, 14 total. Eleven are video against a baseline portfolio that was 40 percent video, so production budget is confirmed. Impression bands on the earliest creatives are already a tier above their usual test ads. This is a push, scaled deliberately.

Day 3, Friday. You spend 3 credits running AI enrichment on the three highest-heat creatives. The teardowns come back with the hook ("sleep 27% cooler, or your money back"), the offer architecture (100-night trial, bundle pricing), and the proof stack (a thermal-imaging demo). Your creative strategist has a counter-angle brief drafted by lunch using the framework from the competitor ad analysis manual.

Day 4, Saturday. Total monitoring cost for the week: 42 search credits plus 3 enrichment credits. Your CEO has a two-page summary in his inbox with creative examples, estimated commitment, and your recommended response. Three weeks later, when his LinkedIn feed finally serves him one of the ads, your counter-campaign is already through its learning phase.

The contrast case matters as much. Four months earlier, the same alert fired on a different competitor, your team checked days_count two weeks later, and the entire batch had been killed. You did nothing, correctly, and spent zero response budget on a failed launch.

The Response Playbook

An alert without a decision process just relocates the panic. When the Act tier fires, run the same five steps every time.

1. Classify the launch. New product, new market, or new angle on an existing product? The landing page tells you which product, geo tells you which market, and the creative copy tells you which angle. Three different launches, three different threat levels.

2. Size the commitment. Pull impression bands and estimated spend across the new batch, then sanity-check the numbers against the ad spend estimator. A launch backed by meaningful spend deserves a meeting. A thin test deserves a calendar reminder to re-check in two weeks.

3. Tear down the creative. Run enrichment on the two or three strongest new ads and map the hook plus the offer structure behind them. You are not copying it. You are mapping what claim space they just occupied so you can position against it.

4. Decide: respond, watch, or ignore. A meaningful share of detected launches die within three weeks, and days_count plus the diff history tells you which ones. Respond only when the launch overlaps your core audience AND survives its own first two weeks. Otherwise schedule the re-check and move on.

5. Brief and reallocate. If you respond, the response is a brief and a budget line, not a vibe. Reallocate with the ad budget planner rather than skimming spend off every campaign equally. Teams running agent-based workflows can wire steps 1-3 into a single automated chain, and the Claude Code competitor intelligence workflows post shows that pattern end to end.

The discipline that makes the playbook work is the watch list. Detection without patience turns every competitor test into your fire drill. The system's job is to make you early. Your job is to stay calm anyway.

What It Costs to Detect Competitor Campaign Launches at Scale

The arithmetic is small enough to run in your head. Six competitors, one search each per morning: 6 credits a day, about 180 a month. Add a deeper weekly sweep at 12 credits a month and perhaps 20 enrichment credits for teardowns. Call it 210-220 credits a month for a six-competitor system running every day.

That fits inside the Business plan at €329/mo, which includes 1000+ monthly credits and is the tier where API access lives. The remaining ~780 credits cover the rest of your research, from winners scans to market-wide creative sweeps. To see the data shape before committing, the Starter tier at €29/mo lets you run real searches in the app first, then upgrade when the cron job is ready. Failed searches refund their credit automatically, so error handling costs nothing but a retry. Full tier details are on the pricing page.

Worth comparing the alternatives honestly. Meta's free Ad Library API costs nothing and works if political and social-issue ads on Meta are genuinely your scope, and this breakdown of whether the free Ad Library is enough walks that decision through. Scraping the Ad Library UI breaks on every markup change and violates platform terms, a tradeoff the scraping tools comparison covers in detail. And for teams who want the API inside an agent rather than a cron job, you can build an MCP server around it in about 60 lines.

Against the cost of being late, the math stops being interesting. One launch detected in week one instead of week five buys your team a month of response time. Most heads of growth I know would pay €329 for the month back without finishing the sentence.

Frequently Asked Questions

What does first_seen actually mean in ad library data?

It is the Unix timestamp of the first time the library observed the creative running. It marks when an ad entered circulation, not when the campaign was configured. For launch detection that distinction is irrelevant: a cluster of fresh first_seen values is live spend, which is the only launch definition that matters competitively.

How many credits does daily launch monitoring cost?

One credit per competitor per day with a 7-day search window, since recent ads fit on one page. Six competitors run about 180 credits a month, plus 20-40 for weekly deep sweeps and enrichment teardowns. The Business plan's 1000+ monthly credits absorb that with most of the allowance left for other research.

Can I detect competitor campaign launches with Meta's free Ad Library API?

Partially. Meta's API exposes start dates and works well for political and social-issue ads, and for EU/UK ad coverage. For most commercial advertisers elsewhere, coverage is the constraint, and it is Meta-only either way. If your competitors also launch on TikTok, YouTube, or LinkedIn, a multi-platform commercial API is the only way to catch those launches in the same diff.

How do I avoid false alarms from routine creative refreshes?

Calibrate per brand and require two signals. Alert only when the 7-day new-creative count exceeds roughly three times that competitor's own weekly median, and escalate to instant alerts only when the batch also points at a never-seen landing page or new geo. Group near-identical variants by landing page so one concept in eight executions counts once.

How fast can I realistically detect a competitor launch?

With a daily diff, typically 1-3 days after the first creative goes live, depending on indexing lag and your scan time. The case timeline in this guide caught a 14-creative launch on day one and confirmed it by day two. Compare that with the 3-6 weeks it takes for a launch to become undeniable in your own performance metrics.

The pattern is simple. Launches announce themselves in public data on day one, and the first_seen field turns that announcement into something a script can read. Baseline once, diff daily, alert on spikes plus new landing pages, respond with a process instead of adrenaline. That is the whole system to detect competitor campaign launches before they show up in your CAC, and it runs unattended for a few credits a day.

Build it this week. Get an API key on the Business plan, wire the six-line diff into a cron job, and let the next launch in your market interrupt your morning coffee instead of your quarterly review.