DEV Community: T3 Data

How to Find a Competitor's Best Google Ads (and What They're Testing Right Now)

T3 Data — Wed, 28 Oct 2026 14:34:57 +0000

Every company that advertises on Google has its ads listed publicly in the Google Ads Transparency Center, across Google Search, YouTube, Shopping, Maps and Play. That's a free view into your competitors' marketing, if you know how to read it.

The two most useful questions to ask it are:

Which ads have they been running the longest? Advertisers kill ads that don't pay off, so an ad that has run for years is almost certainly a winner.
What did they start running this month? New ads show what they're testing right now: new messaging, new offers, new videos.

Here's what that looks like for Canva in the US (real data, October 2026):

100 ads: {'TEXT': 70, 'VIDEO': 26, 'IMAGE': 4}

Longest-running ads:
   1610 days  TEXT   since 2021-10-25  https://adstransparency.google.com/advertiser/AR06374349942554624001/creative/CR11268929032814592001?region=US
   1524 days  TEXT   since 2021-10-25  ...
   1347 days  TEXT   since 2023-01-28  ...

12 new ads in the last 30 days:
  2026-09-17  VIDEO  https://www.youtube.com/watch?v=Vevv7kn9CQE
  2026-09-17  VIDEO  https://www.youtube.com/watch?v=LEzx0y6x0c4
  2026-09-21  VIDEO  https://www.youtube.com/watch?v=yksrKe-tA5Q

So Canva has kept the same text ads running for 4+ years, and this month it's testing a batch of new YouTube videos. That's useful whether you compete with them or just want ideas for your own ads.

The free, manual way

Open adstransparency.google.com.
Type the competitor's name or website, and pick a region.
Filter by platform, format (text, image, video) and date range, then click into each ad.

That's fine for a quick look. It gets painful when you want all the ads, the first and last shown dates for each, a spreadsheet, or a weekly check on five competitors. The site has no export button.

The automated way: a 25-line Python script

Disclosure: I built the tool used here. Google Ads Transparency Scraper is an Apify Actor that pulls the same public data as structured JSON. Each ad comes with its format, first and last shown dates, days running, image, YouTube video link, and text where Google exposes it. You can search by advertiser name, by website domain, or by advertiser ID.

# pip install apify-client   (tested with 3.3.0)
from apify_client import ApifyClient
from collections import Counter
from datetime import datetime, timedelta, timezone

client = ApifyClient("YOUR_APIFY_TOKEN")  # https://console.apify.com/settings/integrations
run = client.actor("t3data/google-ads-transparency").call(run_input={
    "advertisers": ["canva.com"],   # a domain covers every account advertising that site
    "region": "US",
    "maxAdsPerAdvertiser": 100,
})
ads = [a for a in client.dataset(run.default_dataset_id).iterate_items() if a["status"] == "ok"]
print(f"{len(ads)} ads:", dict(Counter(a["format"] for a in ads)))

# 1) Evergreen winners: ads still running after a long time are usually the ones that pay off.
print("\nLongest-running ads:")
for a in sorted(ads, key=lambda a: a["daysShown"] or 0, reverse=True)[:5]:
    print(f'  {a["daysShown"]:>5} days  {a["format"]:<5}  since {a["firstShown"][:10]}  {a["adUrl"]}')

# 2) What they're testing right now: ads first seen in the last 30 days.
cutoff = datetime.now(timezone.utc) - timedelta(days=30)
fresh = [a for a in ads if datetime.fromisoformat(a["firstShown"].replace("Z", "+00:00")) >= cutoff]
print(f"\n{len(fresh)} new ads in the last 30 days:")
for a in fresh[:5]:
    print(f'  {a["firstShown"][:10]}  {a["format"]:<5}  {a.get("videoUrl") or a.get("headline") or a["adUrl"]}')

# 3) Their YouTube video ads, ready to watch.
videos = sorted({a["videoUrl"] for a in ads if a.get("videoUrl")})
print(f"\n{len(videos)} YouTube video ads, e.g. {videos[:3]}")

That printed the output at the top of this post.

Ideas for taking it further

Weekly competitor digest: schedule the run on Apify for 3–5 competitor domains, and send fresh to Slack or email.
Video ad swipe file: collect videoUrls across your niche, then use a transcript tool to pull each video's script and compare hooks.
By country: set region to GB, DE and so on to see how messaging changes per market.
Spreadsheet: every run can be downloaded as CSV or Excel from the Apify Console, with no code.

Good to know

Domain vs. name: searching canva.com catches every advertiser account that promotes that site, including resellers. Searching by name finds the brand's own accounts.
Ad text is only available for some ads (those Google shows as live previews). Image and video ads always come with their image or YouTube link.
No performance data: Google doesn't publish spend, clicks or impressions. "Days running" is the best public proxy for what works.
Cost: $2 per 1,000 ads, and searches that find nothing are free. It runs on Apify, which has a free plan with monthly credit.

Questions or a competitor that doesn't come through? Open an issue on the Actor page and I'll take a look.

Turn Any YouTube Channel into a RAG Index (with Timestamped Citations)

T3 Data — Fri, 16 Oct 2026 21:21:51 +0000

Video is one of the richest knowledge sources there is, and one of the hardest to search. Lectures, conference talks, product reviews and podcasts all sit behind a play button.

In this post we'll turn a YouTube video, playlist or whole channel into a vector index you can query, where every answer links back to the exact second in the video it came from.

Here's the result we're building. I asked "how does self-attention work?" against Andrej Karpathy's 2-hour Let's build GPT lecture:

https://www.youtube.com/watch?v=kCc8FmEb1nY&t=4299s  ->  ...attention number one attention is a communication mechanism...
https://www.youtube.com/watch?v=kCc8FmEb1nY&t=4490s  ->  ...you will use an encoder block of self attention...
https://www.youtube.com/watch?v=kCc8FmEb1nY&t=4561s  ->  ...the same Source X produces Keys queries and values so these nodes are self attending...

Each link opens the video at the moment the answer starts.

Step 1: get the transcripts

You have two good options.

Option A: `youtube-transcript-api` (free, open source)

For a handful of videos on your own machine, the youtube-transcript-api package is great:

# pip install youtube-transcript-api   (tested with 1.2.4)
from youtube_transcript_api import YouTubeTranscriptApi

transcript = YouTubeTranscriptApi().fetch("kCc8FmEb1nY")
for s in transcript.snippets[:3]:
    print(s.start, s.text)

It gives you raw caption lines. Two things to know before you build a pipeline on it:

Cloud IPs get blocked. YouTube often refuses requests from AWS, GCP and similar servers, so code that works on your laptop can fail in production unless you add proxies.
You do the rest yourself: expanding channels and playlists into video IDs, picking a language, and chunking with timestamps.

Option B: a hosted transcript API that returns RAG-ready chunks

Disclosure: I built this one. YouTube Transcripts is an Apify Actor that takes videos, playlists or channels and returns, per video, the transcript plus overlapping, timestamped chunks with metadata. Proxies and retries are handled for you, and videos without captions cost nothing.

# pip install apify-client   (tested with 3.3.0)
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")  # https://console.apify.com/settings/integrations
run = client.actor("t3data/youtube-transcripts").call(run_input={
    "urls": ["https://www.youtube.com/watch?v=kCc8FmEb1nY"],  # or a playlist, or "https://www.youtube.com/@channel"
    "includeChunks": True,
    "chunkMaxWords": 250,      # ~330 tokens per chunk
    "chunkOverlapWords": 30,   # keeps sentences from being cut in half
    "includeSegments": False,
})
videos = list(client.dataset(run.default_dataset_id).iterate_items())

Each chunk looks like this (real output):

{
  "chunkId": "kCc8FmEb1nY-3",
  "text": "very serious production grade system it is trained on uh a good chunk of internet and then there's a lot of uh pre-train...",
  "startSeconds": 201.36,
  "url": "https://www.youtube.com/watch?v=kCc8FmEb1nY&t=201s",
  "videoId": "kCc8FmEb1nY",
  "title": "Let's build GPT: from scratch, in code, spelled out.",
  "channelName": "Andrej Karpathy"
}

The 2-hour lecture becomes 99 chunks. A channel works the same way: pass its URL and set maxVideosPerPlaylist.

Step 2: embed the chunks

We'll use Chroma because it runs locally and ships with a default embedding model, so there's no API key and nothing to configure:

# pip install chromadb   (tested with 1.5.9)
import chromadb

db = chromadb.PersistentClient(path="./yt_index")
col = db.get_or_create_collection("youtube")

for video in videos:
    if video["status"] != "ok":          # e.g. a video without captions
        continue
    for c in video["chunks"]:
        col.upsert(
            ids=[c["chunkId"]],
            documents=[c["text"]],
            metadatas=[{"title": c["title"], "channel": c["channelName"],
                        "url": c["url"], "start": c["startSeconds"]}],
        )

Using chunkId as the ID makes re-runs idempotent, so you can re-index a channel every week and only new videos are added.

Step 3: ask questions, get timestamped sources

res = col.query(query_texts=["how does self-attention work?"], n_results=3)
for doc, meta in zip(res["documents"][0], res["metadatas"][0]):
    print(f'{meta["url"]}  ->  {doc[:90]}...')

That's the output at the top of this post. To get a written answer, pass the retrieved chunks to any LLM and ask it to cite the url of each chunk it used. Your users can then click straight to the moment in the video.

Tips from building this

Chunk size: 200–400 words works well for most embedding models. Use a smaller size with more overlap for dense lectures and a larger one for chatty podcasts.
Auto-generated captions are good enough for retrieval. They have no punctuation, but embeddings don't mind. Check isAutoGenerated if you want to prefer human captions.
Languages: "languages": ["es", "en"] is a preference order. availableLanguages tells you what each video has.
Keep it fresh: schedule the run weekly on a channel URL with a small maxVideosPerPlaylist, and new uploads flow into the same index.
Cost: the hosted version is $5 per 1,000 transcripts, and videos without captions are free. It's paid per run on Apify, which has a free plan with monthly credit. For a few videos, Option A is free.

Full script

from apify_client import ApifyClient
import chromadb

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("t3data/youtube-transcripts").call(run_input={
    "urls": ["https://www.youtube.com/@AndrejKarpathy"],
    "maxVideosPerPlaylist": 10,
    "includeChunks": True, "chunkMaxWords": 250, "chunkOverlapWords": 30, "includeSegments": False,
})

col = chromadb.PersistentClient(path="./yt_index").get_or_create_collection("youtube")
for video in client.dataset(run.default_dataset_id).iterate_items():
    for c in video.get("chunks", []):
        col.upsert(ids=[c["chunkId"]], documents=[c["text"]],
                   metadatas=[{"title": c["title"], "url": c["url"], "start": c["startSeconds"]}])

res = col.query(query_texts=["how does self-attention work?"], n_results=3)
for doc, meta in zip(res["documents"][0], res["metadatas"][0]):
    print(meta["url"], "->", doc[:90])

If you build something with this, I'd love to hear what you indexed. And if you hit a video that doesn't work, open an issue on the Actor page and I'll fix it.