How to Find Competitor Ads Across Meta, Google and Podcasts with Firecrawl Alexandria

Key takeaways:

• Start with the free libraries like Meta's Ad Library and Google's Ads Transparency Center, and sort the ads by how long they've run. The long runners are the best public hint of which ads are working.
• Use Firecrawl Alexandria to cover every channel with one API key (e.g. Upspring for Meta ads, the Google Ads Transparency Center, and Particle for podcast ad reads). Firecrawl Trends adds search interest. Pass up to 10 provider calls to firecrawl.scrape({ alexandria: [...] }).
• The adfinder-tutorial repo builds this as a 59-line Bun server, one branch per step. A Meta and Google lookup costs about 105 credits and needs a Firecrawl API key.

Say you want to see a competitor's Meta ads, Google ads and podcast sponsorships. That's normally two ad libraries plus a paid data provider. Add search-interest trends and it's a second provider. Firecrawl Alexandria puts all of them behind one API, so you can find competitor ads across every channel from one place.

Meta's Ad Library and Google's Ads Transparency Center are the two free sources for competitor ads. Each shows only the ads running on its own platform, so you search them one at a time. TikTok's ad library has the same limit. Podcast sponsorships have no public library, so most ad research misses them.

An ad library is a public, searchable record of the ads an advertiser is running, published by the ad platform. Each one is built around its own network:

The last row is where paid data providers come in, and where Alexandria saves you a separate account for each.

Firecrawl Alexandria is a catalogue of third-party data providers you call through one Firecrawl API key. Each provider is a data source, and each exposes capabilities, the individual calls it supports, such as "search advertisers" or "list ads". Instead of separate sign-ups and bills, Alexandria charges every call in Firecrawl credits.

You call Alexandria from the official plugins, the Firecrawl MCP server, the CLI or the language SDKs. An MCP server is a program that gives an AI agent a fixed set of tools over the Model Context Protocol. With the Claude connector installed, you can ask "what Meta ads is Factor running?" and get the answer from Alexandria directly. The Alexandria launch post covers the full catalogue.

Four Alexandria providers cover competitor ad research between them. Upspring covers Meta ads, the Google Ads Transparency Center provider covers Google ads, and Particle covers podcast ad reads. Firecrawl Trends adds search interest over time. All four run on the same API key and bill in the same credits.

An ad's hook is its opening line, the part written to stop someone scrolling.

To show what these providers do together, I built adfinder, a free tool built on these providers with one search box in front. It also has an MCP server for agents. If you want to build your own, the last part of this article shows exactly how. The examples below come from adfinder and from calling Alexandria directly.

Ad libraries don't publish performance, so the best public signal is how long an ad has run. Advertisers tend to switch off ads that lose money, so an ad live for months or years is a strong hint it pays for itself. Alexandria's Google and Upspring providers both return run length, so you can sort by it.

HelloFresh shows how far that goes. Paging through the ad-transparency/list_ads capability returned 933 Google ads for hellofresh.com: 481 text, 224 image and 228 video. The longest-running are image ads first shown on June 22, 2023, still live more than three years later.

adfinder sorts the same data longest-first and charts each ad's run:

Note: A long-running ad suggests it's working. It doesn't prove it, because nobody outside the company can see what each ad earns.

Upspring gives the same signal for Meta, plus the hook. Factor has 628 active Meta ads in Upspring, and its longest runners have been live for about eight months, 236 days at the top. The hooks lean on protein and myth-busting, like "Factor isn't just like every other meal kit. It's a high-protein cheat code."

Particle covers the ad channel with no public library. It indexes podcast episodes and finds the ad reads that mention a brand, with the show, episode and audio. It runs through the same Alexandria API and key as the Meta and Google data.

Tailscale is a good example of a brand that leans on podcasts. Particle finds 30 Tailscale ad reads across 12 shows, with Late Night Linux, Accidental Tech Podcast and NetworkChuck near the top. adfinder prices those reads at list rates for each show's audience, which comes to $1,158 to $11,400. Each read links to the snippet of the episode where Tailscale is mentioned.

Note: Podcast spend figures are list-price estimates, not reported spend.

Comparing Tailscale with Twingate shows two different strategies. Particle and the Google provider return these figures:

Tailscale spreads across many shows and keeps Google ads running for years. Twingate put all 14 of its reads into a single show.

Firecrawl Trends, an Alexandria provider, returns search interest over time for a term such as a brand name. Plot it against the dates each ad and podcast read went out, and you can see whether interest rose alongside a push. That turns separate ad lists into one timeline of a competitor's activity.

adfinder draws that timeline for each brand. For Tailscale, search interest sits above rows for Meta ads launched, Google ads launched and podcast ad reads:

Note: The timeline shows correlation, not attribution. You can see search interest rising alongside an ad push, but no outside tool can tell you which ad drove which search.

An AI agent with Firecrawl's plugin installed can already answer a single question about a competitor's ads. The catch is choice. Alexandria has hundreds of providers, and Firecrawl adds search, scrape and interact on top. The agent has to pick the right tool every time, and it won't always manage it first try.

Most use cases need only a handful of providers. Narrowing the tools to exactly those makes results faster and more predictable, and there are two ways to do it:

1. Build your own MCP server that exposes only the tools you want. The FastMCP tutorial shows how in Python.
2. Build an app with a custom UI that calls the providers directly, which is what adfinder is.

The rest of this post takes the second route.

You can build your own version of adfinder in three steps. Scaffold a server with a search box, call an Alexandria provider through the Firecrawl SDK, then stack several providers into one request. The adfinder-tutorial repo has a branch for each step, and main is the finished 59-line server.

The tutorial uses the Node SDK. The same alexandria option exists in the Python SDK and the REST API.

You need a Firecrawl API key in a .env file as FIRECRAWL_API_KEY. The tutorial reads it on the server only, so it never reaches the browser. A free account comes with 1,000 credits, and this sign-up link adds 500 more.

The first branch, 1-scaffold, serves an HTML page with a search box from a Bun server. Bun is a JavaScript runtime that can serve HTML imports directly, so there's no separate bundler.

// server.ts
 
import index from "./index.html";
 
Bun.serve({ routes: { "/": index } });

I chose Bun, but you don't have to. The Alexandria calls below work the same from Node, Deno, Next.js or any other JavaScript setup, and the Python SDK covers the same ground. Bun came from my agent harness, the instructions and limits a coding agent works within. Mine restricts new projects to Bun with React, Astro or Rust. The agent harness explainer covers the idea in more depth.

Install the SDK with bun add firecrawl (or npm install firecrawl). Every Alexandria call goes through scrape(), with an alexandria field instead of a URL. The tutorial wraps it in one helper that takes any number of calls:

// server.ts
 
import { Firecrawl } from "firecrawl";
 
const firecrawl = new Firecrawl({ apiKey: process.env.FIRECRAWL_API_KEY });
 
async function alexandria(...calls) {
  const result = await firecrawl.scrape({ alexandria: calls });
  return result.alexandria.map((call) => {
    if (call.error) console.error(call.capability, call.error.message);
    return call.data;
  });
}

result.alexandria holds one entry per call, in the order you sent them. Each entry has either data or an error, so one failing provider doesn't sink the others. The helper logs errors and returns the data array, which keeps the tutorial short. In a real app, return the error to the caller too, so a failed lookup isn't shown as a brand with no ads.

To find a provider and its capability names, browse the Alexandria catalogue in the Firecrawl dashboard, where you can open a provider and test-run it. The MCP server and CLI expose the same catalogue, so an agent can look them up for you. The people enrichment post walks through another set of providers the same way.

Finding a brand's Meta ads takes two Upspring calls. advertisers/search turns a brand name into an advertiser id, and ads/browse returns that advertiser's best ads:

// server.ts
 
async function browseMetaAds(advertiser) {
  if (!advertiser) return null;
 
  const [ads] = await alexandria({
    provider: "upspring",
    capability: "ads/browse",
    options: {
      advertiser_id: [advertiser.id],
      order_by: "best",
      limit: 12,
      include: "media",
    },
  });
  return { advertiser: advertiser.name, ads: ads?.data ?? [] };
}

order_by: "best" returns Upspring's best-ranked ads first, and include: "media" adds each ad's image or video thumbnail. Each returned ad carries hook_text, started_at, is_active, media.thumbnail_url and an ad_library_url linking back to Meta.

Alexandria accepts up to 10 calls in one request. The tutorial sends the Upspring advertiser search and the Google Ads Transparency Center lookup together, so adding Google costs no extra round trip:

// server.ts
 
const server = Bun.serve({
  port: Number(process.env.PORT ?? 3000),
  routes: {
    "/": index,
    "/api/ads": async (req) => {
      const params = new URL(req.url).searchParams;
      const brand = params.get("q") ?? "";
      const domain = params.get("domain") ?? "";
 
      const [advertisers, google] = await alexandria(
        {
          provider: "upspring",
          capability: "advertisers/search",
          options: { name: brand, limit: 1 },
        },
        {
          provider: "adstransparency-google-com",
          capability: "ad-transparency/list_ads",
          options: { domain, region: "anywhere", limit: 12 },
        },
      );
 
      const meta = await browseMetaAds(advertisers?.data?.[0]);
      const googleAds = (google?.ads ?? []).sort((a, b) => b.days_shown - a.days_shown);
 
      return Response.json({ meta, google: googleAds });
    },
  },
});

The /api/ads route reads the brand name from the q query parameter and the website from domain. The Google provider takes the brand's domain rather than its name, which is why the search form asks for both. Its ads arrive in google.ads, each with format, days_shown, first_shown_at and a preview.image_url. Sorting by days_shown puts the long runners first.

The Meta lookup still needs a second request, because ads/browse takes the advertiser id the first call returned. Add Particle and Firecrawl Trends the same way and you have the core of adfinder.

Alexandria prices each capability separately. The tutorial's Meta and Google lookup costs about 105 credits: 50 each for the two Upspring calls and 5 for a page of Google ads. Upspring only bills a call that returns a non-empty page, so a brand it doesn't index costs nothing.

Google ads are cheap to pull in bulk. Fetching all 933 HelloFresh Google ads took 24 pages, about 120 credits. Every result reports its own creditsCost, so you can log the real price as you build.

Note: Upspring indexes direct-to-consumer brands like Factor and Hungryroot. Big brands such as HelloFresh may come back empty from Upspring. adfinder falls back to Meta's own Ad Library for those, which returns keyword matches rather than an exact count.

Nothing in adfinder is specific to ads except the providers. Swap them for others in the Alexandria catalogue and the same three steps give you a different app. Categories include real estate, jobs, company funding, keyword research and YouTube trends.

If you're tracking competitors' websites rather than their ads, Firecrawl Monitor watches pricing pages and changelogs and alerts you when they change. To use Alexandria from a chat app instead, the best Claude connectors roundup covers the Firecrawl connector alongside others.

Alexandria handles structured provider data. For everything else, /search finds pages across the web and /scrape turns any single URL into clean markdown.

Meta ads, Google ads, podcasts and search trends used to mean four places to look, and with Alexandria they're one API.

Check out the Alexandria docs to go deeper.