# Snapchat Ads Library Scraper | by Brand, from $0.50/1K Ads (`alexmorain/snapchat-ads-library-scraper`) Actor

Scrape the Snap Ads Gallery (EU) by brand, not only by paying entity: Temu, Samsung or Betclic ads bought through agencies, which a plain search returns as 0. Impressions per country, targeting, media, app IDs. Plain HTTP, no login.

- **URL**: https://apify.com/alexmorain/snapchat-ads-library-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Social media, Marketing, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 ads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Snapchat Ads Library Scraper

This Actor turns the [Snap Ads Gallery](https://adsgallery.snap.com/), Snapchat's public library of ads shown in the European Union, into structured data. Give it a brand as you see it on Snapchat (`Temu`, `Samsung`, `McDonald's`) or the name of the company that pays for the ads, and it returns every matching ad: headline, call to action, image or video link, app or website promoted, start date, status, total impressions, impressions per country, and the targeting the advertiser chose (age, gender, language, device).

It runs over plain HTTP against the same JSON endpoint the Ads Gallery website calls. No browser, no Snapchat account, no Snap Marketing API token. A run fits in 256 MB, and pricing is pay per event: $1.00 per 1,000 ads at the entry price, down to $0.50 per 1,000 on the Gold plan, plus $0.002 per run.

If you were looking for a **Snapchat Ads Library API** or a **Snap ad library export**, this is it: input in, JSON, CSV or Excel out, from the console, the Apify API, a schedule or an AI agent.

**What makes it different:** the Ads Gallery search box only searches the name of the legal entity that pays for an ad, not the brand that signs it. On Snapchat the payer is often an agency or a subsidiary, so a search for `Temu`, `Samsung` or `Betclic` returns nothing, or almost nothing. This Actor keeps a directory of which entities pay for which brands and searches all of them for you.

***

### The brand is not the payer: why a plain Snapchat ads search misses most ads

Every ad in the Snap Ads Gallery carries two names. The **profile** is the brand the viewer sees (`Temu`, `Samsung Belgium`, `betclic`). The **paying advertiser** is the legal entity billed for the ad (`TECDO HONG KONG LIMITED`, `PUBLICIS MEDIA FRANCE`, `Equinox Limited, Suite 2B, Mansion House`). The search only looks at the second one.

We measured it on 1 November 2026. In a sample of 311 ads that had a profile, **234 (75%) were signed by a brand whose name does not appear in the name of the payer**. Here is what a search by brand name returns, compared with this Actor, for ads delivered in France and active in 2026:

| Brand | Search of the brand name in the Ads Gallery | This Actor | Who actually pays |
|---|---|---|---|
| Temu | 0 | 15,934 or more | TECDO HONG KONG LIMITED, Elementary Innovation Pte. Ltd. |
| Samsung | 0 | 596 | Publicis Media France, Starcom Germany, Mindshare and others |
| Betclic | 0 | 1,217 | Equinox Limited, Suite 2B, Mansion House |
| Unibet | 0 | 1,276 | Française des Jeux, Publicis Media France, Kindred London |
| McDonald's | 33 | 2,269 | Gen'K Conseil, Omnicom Media Group, Publicis, local franchisees |
| Decathlon | 4 | 3,241 | MOBSUCCESS |

The Temu run stopped at its timeout while still reading, so its figure is a floor.

Other Snapchat ads scrapers on the Apify Store pass your search term straight to that payer field, so they return the left-hand column. If you follow a brand that buys media through an agency, which is most large brands, that column is not a smaller sample of its ads. It is close to none of them.

#### How the brand search works

1. **A directory of brands and payers.** We read the Ads Gallery every day and record, for each ad, which payer paid for which profile and brand. On 1 November 2026 the directory held 7,027 brand names and 4,473 payers, built from 92,820 ads, and it grows with every daily pass.
2. **Resolution.** When you type `Samsung`, the Actor looks it up, finds the payers that paid for Samsung ads (up to 12, the most frequent first), and searches each of them. It also searches the brand name itself as a payer, since many brands pay for their own ads (`Zalando SE`, `Netflix, Inc.`).
3. **Filter.** An agency pays for many brands, so the Actor keeps only the ads whose profile, brand or account name contains the brand you asked for, as a whole word. The log tells you how many ads were read and how many were dropped because another brand signed them.
4. **One ad, one row.** An ad found through two payers, or by two of your searches, is returned and charged once.

The log of every run prints the payers each brand was resolved to, for example:

```
Brand 'Samsung' resolved to 10 payer search(es): Samsung, PUBLICIS MEDIA FRANCE (27), Starcom Germany (15), ...
Brand 'Betclic' resolved to 2 payer search(es): Betclic, Equinox Limited, Suite 2B, Mansion House (69).
```

If a brand is not in the directory yet, the Actor still searches its name as a payer, and the status message says the brand was not resolved. If you know the payer, put it in **Advertisers** and you get every ad it paid for.

### What this Snapchat ads scraper does

It searches in two ways, and both can be used in the same run.

**Search by brand.** List brands the way they appear on Snapchat. Each one is resolved to its payers through the directory, and only ads signed by that brand come out. This is the search you want for competitor monitoring.

**Search by advertiser (paying entity).** List payer names. Each one is passed to Snapchat as it is, which matches it as a case-insensitive part of the payer name: `Nike` returns `Nike, Inc.` and also `Oya Nike Botanica`. Tick **Exact advertiser match** to keep only the payer you typed, ignoring case, punctuation and legal forms such as `Inc.`, `Ltd`, `SE` or `GmbH`. Use this search to follow an agency (`PUBLICIS MEDIA FRANCE`) or a holding that pays for several brands.

On top of both you get the Ads Gallery filters (countries, active period, active or paused), a cap per search, a **New ads only** mode with a persistent registry for scheduled monitoring, and an optional webhook at the end of the run.

### Why scrape the Snap Ads Gallery?

- **Snapchat competitor ad analysis.** What a brand runs on Snapchat, since when, in which EU countries, with which creative and call to action.
- **Impressions as a budget signal.** Snap publishes the number of impressions of every ad, in total and per country. Sum them by brand, by country or by month and you have a proxy for media weight that no other social ad library gives for commercial ads.
- **Targeting research.** The minimum and maximum age, gender, languages and device targeting of each ad, as set by the advertiser.
- **App marketing intelligence.** App install ads carry the app name, the App Store ID and the Google Play package. Track which mobile games and apps buy Snapchat inventory in Europe, and through which agencies.
- **Agency and media buying research.** Search an agency as an advertiser to see which brands it buys for on Snapchat.
- **Creative swipe files.** Image and video links for every ad, ready to download.
- **Alerts.** Schedule the Actor daily in New ads only mode and get a webhook when a competitor launches something.

### How to scrape Snapchat ads

#### From the Apify console

1. Open the Actor and type one or more brands in **Brands**, for example `Zalando`.
2. Pick the countries you care about, or leave it empty for every country of the library.
3. Optionally set the active period and the status (active or paused ads).
4. Set **Max ads per search**, or `0` for everything. A large brand can have tens of thousands of ads.
5. Press Start, then download the results as JSON, CSV, Excel or HTML, or read them through the API.

#### From the API

Start a run with the input as JSON and read the dataset when it finishes. Examples in Python, JavaScript and cURL are further down.

### Which fields should I fill?

| You want | Fill |
|---|---|
| A competitor's Snapchat ads | **Brands**: `Temu` |
| Every ad a company paid for, whatever brand it signed | **Advertisers**: `TECDO HONG KONG LIMITED` |
| Ads of one legal entity only, no lookalikes | **Advertisers**: `Nike`, **Exact advertiser match** on |
| What an agency buys on Snapchat | **Advertisers**: `PUBLICIS MEDIA FRANCE` |
| Ads in one market | **Countries**: `fr` |
| Ads running right now | **Ad status**: Active |
| Ads that ran during a campaign | **Active from** and **Active until** |
| Daily alerts on new ads | **Mode**: New only, plus a schedule and a **Webhook URL** |

### Input examples

A brand in two countries, last quarter, capped at 500 ads:

```json
{
  "brands": ["Samsung"],
  "countries": ["fr", "de"],
  "startDate": "2026-07-01",
  "endDate": "2026-09-30",
  "maxAdsPerSearch": 500
}
```

A payer, exact name only, active ads:

```json
{
  "advertisers": ["Nike"],
  "exactAdvertiserMatch": true,
  "status": "ACTIVE"
}
```

Daily monitoring of three competitors, with a Slack webhook:

```json
{
  "brands": ["Temu", "Shein", "AliExpress"],
  "countries": ["fr"],
  "status": "ACTIVE",
  "mode": "new-only",
  "webhookUrl": "https://hooks.slack.com/services/..."
}
```

### Details that need a word

- **Countries.** The library covers the 27 EU countries and Türkiye. Use two-letter codes in lower case; Greece is `el`, not `gr`. Snapchat lists no ad for the United States or the United Kingdom in this library, and the Actor refuses those codes instead of returning nothing.
- **Dates select ads active in the period**, not ads created in it. An ad launched in 2025 and still running in October 2026 is returned for October 2026. The library goes back to 2024. If you fill only one date, the other is completed (today, or 2024-01-01) and the log says so.
- **Order.** Snapchat returns ads in no particular order, so the Actor reads each search to the end (or to your cap). It does not sort by impressions.
- **Disapproved ads.** Some ads rejected by Snap's review have no payer, profile or brand name at all. A brand search cannot attribute them, so they are left out.
- **Speed.** Snapchat serves 10 ads per request. Expect about 1,000 ads every two to four minutes per search, with searches running in parallel. A brand bought through a large agency takes longer, because the agency's ads for other brands are read and dropped. A single brand search reads at most 30,000 ads per payer, and the status message says so if it hits that limit.

### What data can it extract? Every output field

#### Advertiser

| Field | What it is |
|---|---|
| `brandName` | The brand that signs the ad: the profile name, or Snap's brand name when the profile is empty |
| `profileName` | Name of the Snapchat public profile that ran the ad |
| `adBrandName` | Brand name field of the ad as Snap stores it, often the full brand (`Betclic Paris Sportifs & Poker`) |
| `payingAdvertiserName` | Legal entity that paid for the ad |
| `adAccountName` | Name of the ad account, often revealing the agency, market or campaign line (`FR_Betclic_Sportsbook`) |
| `profileLogoUrl` | Logo of the profile |

#### Ad identity and timing

| Field | What it is |
|---|---|
| `adId` | Snap ID of the ad |
| `adUrl` | Link that opens the ad in the Snap Ads Gallery |
| `adName` | Internal name the advertiser gave the ad, often a campaign naming convention |
| `startDate` | When the ad started, ISO 8601 |
| `status` | `ACTIVE` or `PAUSED` |
| `reviewStatus` | Result of Snap's ad review, for example `APPROVED` |
| `rejectionReasons` | Reasons given when the review rejected the ad |

#### Creative

| Field | What it is |
|---|---|
| `headline` | Headline shown on the ad |
| `callToAction` | Button label, for example `SHOP NOW`, `DOWNLOAD`, `INSTALL NOW` |
| `adType`, `creativeType`, `adRenderType` | Format of the ad: `APP_INSTALL`, `WEB_VIEW`, `DEEP_LINK`, `COLLECTION`, `STORY`, `LENS`, dynamic product ads... |
| `mediaType` | `IMAGE` or `VIDEO` for the main snap |
| `mediaUrl` | Direct link to the image or video |
| `mediaCropPosition` | Crop of the main snap |
| `destinationUrl` | Website the ad opens, for web view ads |
| `deepLinkUrl` | App deep link, for deep link ads |
| `appInstall` | For app install ads: `appName`, `iosAppId`, `androidApp`, `iconUrl`, `playableUrl` |
| `stickers` | Stickers placed on the ad |
| `languages` | Languages of the ad |

#### Reach and targeting

| Field | What it is |
|---|---|
| `impressionsTotal` | Total impressions of the ad in the EU, as published by Snap |
| `impressionsByCountry` | Impressions per country, only countries above zero, for example `{"fr": 265116}` |
| `countries` | Countries where the ad had impressions |
| `targeting.minAge`, `targeting.maxAge`, `targeting.ageGroups` | Age targeting |
| `targeting.genders` | Gender targeting, when set |
| `targeting.languages` | Language targeting |
| `targeting.osTypes` | Device targeting: `IOS`, `ANDROID` |
| `targeting.regulatedContent` | Whether Snap flagged the ad as regulated content |
| `targeting.raw` | The targeting object exactly as Snap returns it, for anything the flat fields do not cover |

#### Provenance

| Field | What it is |
|---|---|
| `searchType` | `brand` or `advertiser` |
| `searchTerm` | The brand or advertiser from your input that found the ad |
| `resolvedPayer` | The payer that was searched to find it |
| `scrapedAt` | When the row was produced |

Fields that do not apply to an ad are `null` rather than missing, so a CSV export keeps the same columns.

### Example output

A Betclic ad found through its payer, Equinox Limited (media links shortened):

```json
{
  "adId": "ebd2c4e2-97aa-409d-834e-5c2c725fa9b2",
  "adUrl": "https://adsgallery.snap.com/?adId=ebd2c4e2-97aa-409d-834e-5c2c725fa9b2",
  "adName": "Static_Specific_EDF_PARvFRA_WC26",
  "brandName": "betclic",
  "profileName": "betclic",
  "adBrandName": "Betclic Paris Sportifs & Poker",
  "payingAdvertiserName": "Equinox Limited, Suite 2B, Mansion House",
  "adAccountName": "FR_Betclic_Sportsbook",
  "headline": "Jusqu'à 100€ reversés en Feebets*",
  "callToAction": "DOWNLOAD",
  "status": "PAUSED",
  "reviewStatus": "APPROVED",
  "rejectionReasons": [],
  "adType": "APP_INSTALL",
  "creativeType": "APP_INSTALL",
  "adRenderType": "STATIC",
  "mediaType": "IMAGE",
  "mediaUrl": "https://cf-st.sc-cdn.net/d/IWBet3k1kmtCoJNgUGWof.380?...",
  "mediaCropPosition": "MIDDLE",
  "profileLogoUrl": "https://cf-st.sc-cdn.net/aps/bolt/...",
  "destinationUrl": null,
  "deepLinkUrl": null,
  "appInstall": {
    "appName": "Betclic Paris Sportifs",
    "iosAppId": "441081528",
    "androidApp": "sport.android.betclic.fr",
    "iconUrl": "https://cf-st.sc-cdn.net/d/J6EfvoAbcJW4T1TpaQ24J.438?...",
    "playableUrl": null
  },
  "startDate": "2026-06-04T15:46:32.000Z",
  "impressionsTotal": 265116,
  "impressionsByCountry": { "fr": 265116 },
  "countries": ["fr"],
  "languages": ["fr"],
  "targeting": {
    "minAge": 18,
    "maxAge": null,
    "ageGroups": [],
    "genders": ["MALE"],
    "languages": [],
    "osTypes": ["ANDROID"],
    "regulatedContent": false,
    "raw": { "...": "..." }
  },
  "stickers": [],
  "searchType": "brand",
  "searchTerm": "Betclic",
  "resolvedPayer": "Equinox Limited, Suite 2B, Mansion House",
  "scrapedAt": "2026-11-01T05:26:52Z"
}
```

A search for `Betclic` in the Ads Gallery itself returns 0 ads.

### Monitor competitor ads on Snapchat: New ads only mode

Set **Mode** to New only and schedule the Actor (daily is typical). The first run returns everything it finds and records each ad in a registry kept in a key-value store of your Apify account (`snapchat-ads-library-registry`). The next runs return, and charge, only ads never returned before for the same searches and filters.

Snapchat does not sort ads by date, so a new ad can appear anywhere in the results. Each run therefore reads every search to the end and compares; reading costs you nothing, only returned ads are charged. If you want several schedules to share one registry, give them the same **Registry key**.

#### Webhook at the end of the run

Fill **Webhook URL** and, when a run returns at least one ad, the Actor POSTs a short JSON summary to it:

```json
{
  "actor": "snapchat-ads-library-scraper",
  "runId": "wfZFIOnBUY44sIP2f",
  "mode": "new-only",
  "items": 12,
  "searches": 3
}
```

Slack and Discord incoming webhook URLs work as they are. The URL is treated as a secret: it never appears in the log, the status message or the dataset. A failed webhook call is logged and never fails the run.

### Using the Snapchat Ads Library API from your code

Replace `YOUR_APIFY_TOKEN` with the token from your Apify console (Settings, API and Integrations).

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("alexmorain/snapchat-ads-library-scraper").call(run_input={
    "brands": ["Temu"],
    "countries": ["fr"],
    "status": "ACTIVE",
    "maxAdsPerSearch": 200,
})
for ad in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(ad["startDate"][:10], ad["impressionsTotal"], ad["payingAdvertiserName"], ad["headline"])
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('alexmorain/snapchat-ads-library-scraper').call({
    brands: ['Temu'],
    countries: ['fr'],
    status: 'ACTIVE',
    maxAdsPerSearch: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const ad of items) {
    console.log(ad.startDate.slice(0, 10), ad.impressionsTotal, ad.payingAdvertiserName, ad.headline);
}
```

#### cURL

Run synchronously and get the ads in the response (for runs under five minutes):

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~snapchat-ads-library-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"brands": ["Zalando"], "countries": ["fr"], "maxAdsPerSearch": 50}'
```

### What people use it for

#### Snapchat competitor ad analysis

Put your competitors in **Brands**, one market in **Countries**, and the last 90 days in the period. Sort by `impressionsTotal` to see which creatives carried the campaign, and by `startDate` to see the rhythm of launches. `adName` often follows the advertiser's naming convention, which tells you the campaign, the format and sometimes the audience.

#### Estimating media weight from impressions

Snap publishes impressions for every commercial ad, which Meta and Google do not. Group the rows by brand and country and sum `impressionsByCountry`: you get a comparable measure of how hard each competitor pushes on Snapchat in each EU market, and when.

#### Who buys for whom

Search an agency as an advertiser (`PUBLICIS MEDIA FRANCE`, `Starcom Germany`, `TECDO HONG KONG LIMITED`) and group by `brandName`. You get the list of brands that agency buys Snapchat media for, which is useful for agency new business and for media sales teams.

#### Mobile app and game marketing

App install ads come with `appInstall.iosAppId` and `appInstall.androidApp`. Filter `adType` on `APP_INSTALL` to list which apps and games advertise on Snapchat in a country, how many impressions each gets, and which publishers buy through Asian agencies such as TECDO or BlueFocus.

#### Creative research before a brief

Download `mediaUrl` for the top ads by impressions in your category and read the headlines and calls to action side by side.

#### Regulated and sensitive categories

Betting, alcohol and finance brands often buy through dedicated entities. `targeting.regulatedContent`, the age targeting and the payer name together show how an advertiser handles a regulated category on Snapchat.

### Snapchat Ads Library scraper pricing

Pay per event, no subscription on top of your Apify plan:

| Event | Free plan | Bronze | Silver | Gold, Platinum, Diamond |
|---|---|---|---|---|
| Run start (per GB of memory, 256 MB by default) | $0.002 | $0.002 | $0.002 | $0.002 |
| Ad returned | $1.00 per 1,000 | $0.80 per 1,000 | $0.70 per 1,000 | $0.50 per 1,000 |

Some examples at the Free plan price:

- A first test capped at 100 ads: about $0.10.
- One brand in one country over a quarter, 1,000 ads: about $1.
- Daily monitoring of five brands in New ads only mode, 50 new ads a day: about $1.50 a month.

Ads read and dropped because another brand signed them are never charged. You can also set a maximum charge per run in the Apify console; the Actor stops cleanly when it is reached.

#### How this compares to other options

| Option | Brand resolution through payers | Countries per run | Price per 1,000 ads |
|---|---|---|---|
| This Actor | Yes, directory of 7,000+ brands | Any number | $1.00 to $0.50 |
| Other Snapchat ads scrapers on the Store | No, the term goes to the payer field | One | $0.60 to $2.00 |
| Snap Ads Gallery website | No | One or all | Free, manual, no export |
| Snap Marketing API | Your own ad accounts only | | Free, needs an approved app |

### Why this Snapchat ads scraper

#### Brand search through the payers

The directory and the brand filter above. It is the reason the Temu, Samsung and Betclic rows of the first table are not zero.

#### Plain HTTP, no browser, no login

The Actor calls the JSON endpoint behind the Ads Gallery directly. No headless browser, no Snapchat account, nothing that breaks when the website changes its layout. That is why it runs in 256 MB.

#### It handles rate limits

When Snapchat answers "too many requests", the Actor waits and retries with backoff, and if that persists it moves to the Apify datacenter proxy on its own. On our test runs, 7,884 requests in a row went through without a single refusal.

#### Failure that tells you what to do

A brand that cannot be resolved, a country code Snapchat refuses, a date in the wrong format: the run says which one and why, in plain words. A search that fails does not sink the others, and a run where every search fails ends as Failed, not as an empty success.

#### One ad, one charge

Ads are deduplicated across searches before they are pushed, and charging goes through Apify's own pay-per-event mechanism, which respects the maximum charge you set.

### Limits and what this scraper does not do

- **EU and Türkiye only.** The Snap Ads Gallery is a transparency library required by the EU Digital Services Act. There is no equivalent for ads shown in the United States or the United Kingdom.
- **No spend.** Snap publishes impressions, not budgets, for commercial ads.
- **The directory is built from what Snap shows.** A brand that started advertising today may not be resolved until the next daily pass; search its payer in Advertisers meanwhile. Brands that advertise a lot are the first to be in the directory.
- **Up to 12 payers per brand**, the most frequent first. The log lists any payer left out, which you can search in Advertisers.
- **Disapproved ads without any name** cannot be attributed to a brand.
- **No Spotlight, Stories or profile data.** This Actor covers ads only.

### FAQ

#### Is there a Snapchat Ads Library API?

Snap has no public API for its ad library. The Snap Marketing API only gives access to ad accounts you manage. The Ads Gallery website calls an internal JSON endpoint, which this Actor uses, and it exposes the result through the Apify API, so you get a Snapchat ads API with an API token and nothing else.

#### Why does a search for a brand return 0 ads on the Snap Ads Gallery?

Because the search box only matches the name of the entity that pays for the ads. Temu ads are paid by TECDO Hong Kong Limited and Elementary Innovation, Samsung ads by media agencies such as Publicis or Starcom, Betclic ads by Equinox Limited. Put the brand in **Brands** and the Actor finds the payers for you.

#### How do I find who pays for a brand's Snapchat ads?

Run the Actor with the brand in **Brands** and read the log: it lists the payers the brand was resolved to, with the number of ads seen for each. The `payingAdvertiserName` field of each row gives it ad by ad.

#### Can I scrape Snapchat ads without an account?

Yes. The Snap Ads Gallery is public and the Actor needs no Snapchat login, cookie or developer token.

#### How far back does the Snap Ads Gallery go?

To 2024. A period that ends before 2024 returns nothing.

#### Which countries are covered?

The 27 EU member states and Türkiye. Greece uses the code `el`.

#### Can I see impressions per country?

Yes, in `impressionsByCountry`, for every ad, along with the total in `impressionsTotal`.

#### How much does it cost to scrape 1,000 Snapchat ads?

$1.00 on the Free plan, $0.80 on Bronze, $0.70 on Silver and $0.50 on Gold and above, plus $0.002 per run.

#### How do I export Snapchat ads to CSV or Excel?

After the run, open the Output tab and pick CSV or Excel, or call the dataset endpoint of the Apify API with `format=csv` or `format=xlsx`.

#### Why does a search for Nike also return other companies?

Snapchat matches the advertiser name as a part of the payer's name, so `Nike` also returns `Oya Nike Botanica`. Tick **Exact advertiser match**, or use **Brands**, which keeps only ads signed by the brand.

#### Can I run it every day and be told about new ads?

Yes. Set **Mode** to New only, add a **Webhook URL**, and schedule the Actor in the Apify console. Only new ads are returned and charged.

#### Is it legal to scrape the Snap Ads Gallery?

The Ads Gallery is a public transparency archive published under the EU Digital Services Act so that anyone can inspect the ads shown in the EU. The Actor reads only what the public website shows, without login. Check the rules that apply to your own use of the data, especially for personal data.

### Integrations, exports and agents

Results go to an Apify dataset that you can export as JSON, CSV, Excel, XML or HTML, send to Google Sheets, or pipe into Make, Zapier, n8n or your own code through the Apify API. The Actor also works from AI agents through the Apify MCP server: ask for "the Snapchat ads Temu ran in France last month" and the agent can call it with the right input.

### Support

Something wrong, a brand that is not resolved, or a field you need? Open an issue on the Issues tab of this Actor. Issues are read and answered quickly, and fixes ship as new builds.

# Actor input Schema

## `brands` (type: `array`):

Brands as you see them on Snapchat, one per line: <code>Temu</code>, <code>Samsung</code>, <code>McDonald's</code>. Each brand is resolved to the entities that pay for its ads (the log lists them) and only ads signed by the brand come out. A brand the directory does not know yet is searched as a payer name only, and the run says so.

## `advertisers` (type: `array`):

Name of the paying entity, passed as is to Snapchat, which matches it as a case-insensitive part of the name: <code>Nike</code> also returns <code>Oya Nike Botanica</code>. Use it when you know the payer (<code>TECDO HONG KONG LIMITED</code>), or to follow an agency.

## `exactAdvertiserMatch` (type: `boolean`):

Keep only ads whose paying entity is the term you typed, ignoring case, punctuation and legal forms (<code>Inc.</code>, <code>Ltd</code>, <code>SE</code>...). Removes <code>Oya Nike Botanica</code> from a search for <code>Nike</code>. Applies to Advertisers.

## `countries` (type: `array`):

Only ads delivered in these countries. Leave empty for all EU countries and Türkiye. Snapchat lists no ad outside them (no US). Greece is <code>el</code>.

## `startDate` (type: `string`):

Only ads that ran during the period <code>YYYY-MM-DD</code>. Snapchat keeps ads from 2024. If only one of the two dates is filled, the other is completed (today, or 2024-01-01) and the log says so.

## `endDate` (type: `string`):

End of the period, <code>YYYY-MM-DD</code>. See <b>Active from</b>.

## `status` (type: `string`):

Active ads run now, paused ads have stopped.

## `maxAdsPerSearch` (type: `integer`):

Stops each brand or advertiser after this many ads. <code>0</code> means no limit: a big brand can have tens of thousands of ads, and you pay per ad.

## `mode` (type: `string`):

<b>All</b> returns every ad found. <b>New only</b> returns only ads never returned before for the same searches (a registry is kept in your account), for monitoring on a schedule. Each run still reads the whole search, but only new ads are returned and charged.

## `registryKey` (type: `string`):

New-only mode: name of the registry. Leave empty to get one registry per set of searches and filters; set it to share one registry between runs or tasks.

## `webhookUrl` (type: `string`):

At the end of a run that returned ads, a summary (<code>actor</code>, <code>runId</code>, <code>mode</code>, <code>items</code>, <code>searches</code>) is POSTed here as JSON. Slack and Discord URLs work. A failure never fails the run.

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

Not needed: Snapchat answers a plain connection. Leave empty. If Snapchat rate-limits the run persistently, the Actor switches to the Apify datacenter proxy by itself.

## Actor input object example

```json
{
  "brands": [
    "Zalando"
  ],
  "exactAdvertiserMatch": false,
  "status": "ALL",
  "maxAdsPerSearch": 20,
  "mode": "all"
}
```

# Actor output Schema

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

All ads in the default dataset.

# 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 = {
    "brands": [
        "Zalando"
    ],
    "maxAdsPerSearch": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/snapchat-ads-library-scraper").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 = {
    "brands": ["Zalando"],
    "maxAdsPerSearch": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/snapchat-ads-library-scraper").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 '{
  "brands": [
    "Zalando"
  ],
  "maxAdsPerSearch": 20
}' |
apify call alexmorain/snapchat-ads-library-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/snapchat-ads-library-scraper"
        }
    }
}
```

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/s6s3MNO5OQNI5C5KF/builds/DNcIUiVumdxaLWIaD/openapi.json