# Temu Ad Library Scraper (`lexis-solutions/temu-ad-library-scraper`) Actor

Scrapes ads from the Temu EU Ad Library (ads.temu.com/library), enabling search and extraction of advertising data by keyword, advertiser, or payer for EU compliance and market research.

- **URL**: https://apify.com/lexis-solutions/temu-ad-library-scraper.md
- **Developed by:** [Lexis Solutions](https://apify.com/lexis-solutions) (community)
- **Categories:** Lead generation, E-commerce, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![banner](https://i.ibb.co/ccZ01HWy/temu-ad-library.png)

## Temu Ad Library Scraper

The Temu Ad Library (ads.temu.com/library) is a transparency tool required under Article 39 of the EU Digital Services Act, allowing anyone to search and review ads shown on Temu's EU sites over the past year. This scraper extracts structured ad data from the library, enabling competitive research, brand monitoring, and compliance auditing without manual browsing.

### Introduction

This Apify Actor scrapes the Temu EU Ad Library to extract advertising data including product names, advertiser details, payer information, active periods, and impression counts. It supports filtering by keyword (across product names, advertiser names, or payer names) and by publication date range. No API key or Temu account is needed.

### Use Cases

- **Competitive research**: Monitor which products and brands are being advertised on Temu in the EU
- **Brand monitoring**: Track ads mentioning your brand or competitor brands as advertisers or payers
- **Compliance auditing**: Verify advertising transparency for DSA compliance purposes
- **Market analysis**: Analyze advertising trends and impression volumes for product categories
- **Ad creative research**: Discover active ads for specific product niches

### Input

Provide the following fields:

- `query` (string, optional): Keyword to search for. Leave empty to retrieve all available ads
- `queryType` (integer, optional): What field to search with the keyword — `1` for product name (default), `2` for advertiser name, `3` for who paid
- `dateFrom` (string, optional): Filter ads published on or after this date (`YYYY-MM-DD`)
- `dateTo` (string, optional): Filter ads published on or before this date (`YYYY-MM-DD`)
- `maxItems` (integer, optional): Maximum number of ads to scrape (default: `10`)
- `proxyConfiguration` (object, optional): Proxy settings for the scraper

### Input Examples

**1) Search for shoe ads by product name**

```json
{
  "query": "shoes",
  "queryType": 1,
  "maxItems": 50
}
````

**2) Search for a specific advertiser**

```json
{
  "query": "WhaleCo",
  "queryType": 2,
  "maxItems": 100
}
```

**3) Filter by date range**

```json
{
  "query": "handbag",
  "queryType": 1,
  "dateFrom": "2024-01-01",
  "dateTo": "2024-06-30",
  "maxItems": 200
}
```

### Output

Each dataset item contains the following fields:

```json
{
  "adName": "Women's Leather Handbag",
  "advertiser": "Temu",
  "adPayer": "WhaleCo Inc.",
  "firstShownDate": "2024-03-01",
  "lastShownDate": "2024-06-15",
  "regionName": "Germany",
  "impressions": "500K+",
  "url": "https://www.temu.com/goods.html?goods_id=...",
  "imageUrls": ["https://img.kwcdn.com/..."],
  "scrapedAt": "2024-06-16T10:30:00.000Z"
}
```

### Why use the Temu Ad Library Scraper?

- **DSA compliance data**: The only source of EU-mandated advertising transparency data for Temu
- **No account needed**: Accesses publicly available data without requiring a Temu login
- **Structured output**: Extracts all key ad fields in a clean, dataset-ready format
- **Reliable**: Handles Temu's dynamic page rendering automatically
- **Well-maintained**: Kept up to date with changes to the Temu Ad Library

### FAQ

- **Do I need a Temu account to use this scraper?**

  No, the scraper works without any account or API key. It accesses publicly available data from Temu's DSA-compliant transparency tool.

- **How many ads can I scrape?**

  There is no hard limit on our side. Use the `maxItems` field to control the number of results. Temu's Ad Library covers ads from the past year.

- **Which countries are covered?**

  The Temu Ad Library covers EU countries. The `regionName` field in results indicates the country where the ad was shown.

- **Is this scraper compliant with Temu's terms?**

  This scraper accesses only publicly available data from Temu's EU Ad Library, which Temu is legally required to make public under the Digital Services Act. Always review the website's terms of service before using scraped data.

### Need to scrape other ad library sites?

Check out our other ad library scrapers:

- [Pinterest Ads Scraper](https://apify.com/lexis-solutions/pinterest-ads-scraper)
- [TikTok Ads Scraper](https://apify.com/lexis-solutions/tiktok-ads-scraper)
- [Snapchat Ads Scraper](https://apify.com/lexis-solutions/snapchat-ads-scraper)
- [Google Ads Scraper](https://apify.com/lexis-solutions/google-ads-scraper)

***

Got feedback or need an extension?

Lexis Solutions is a [certified Apify Partner](https://apify.com/partners/find).
We can help you with custom solutions or data extraction projects.

Contact us over [Email](mailto:scraping@lexis.solutions) or
[LinkedIn](https://www.linkedin.com/company/lexis-solutions)

### Support Our Work

If you're happy with our work and scrapers, you're welcome to leave us a
company review [here](https://apify.com/partners/find/lexis-solutions/review)

### Image Credit

Image credit: [ads.temu.com](https://ads.temu.com/library)

# Actor input Schema

## `query` (type: `string`):

Keyword to search for in the Temu Ad Library. Leave empty to retrieve all available ads.

## `queryType` (type: `string`):

What field to search with the keyword: product name, advertiser name, or who paid for the ad.

## `dateFrom` (type: `string`):

Filter ads published on or after this date (YYYY-MM-DD). Only ads from the past year are available.

## `dateTo` (type: `string`):

Filter ads published on or before this date (YYYY-MM-DD).

## `maxItems` (type: `integer`):

Maximum number of ads to scrape.

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

Proxy settings for the scraper. Residential proxies recommended for better reliability.

## Actor input object example

```json
{
  "query": "shoes",
  "queryType": "1",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "query": "shoes"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexis-solutions/temu-ad-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 = { "query": "shoes" }

# Run the Actor and wait for it to finish
run = client.actor("lexis-solutions/temu-ad-library-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "shoes"
}' |
apify call lexis-solutions/temu-ad-library-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lexis-solutions/temu-ad-library-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Temu Ad Library Scraper",
        "description": "Scrapes ads from the Temu EU Ad Library (ads.temu.com/library), enabling search and extraction of advertising data by keyword, advertiser, or payer for EU compliance and market research.",
        "version": "1.0",
        "x-build-id": "ZQxGMYsXWISwCAja2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lexis-solutions~temu-ad-library-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lexis-solutions-temu-ad-library-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/lexis-solutions~temu-ad-library-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lexis-solutions-temu-ad-library-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/lexis-solutions~temu-ad-library-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lexis-solutions-temu-ad-library-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Keyword to search for in the Temu Ad Library. Leave empty to retrieve all available ads."
                    },
                    "queryType": {
                        "title": "Search by",
                        "enum": [
                            "1",
                            "2",
                            "3"
                        ],
                        "type": "string",
                        "description": "What field to search with the keyword: product name, advertiser name, or who paid for the ad.",
                        "default": "1"
                    },
                    "dateFrom": {
                        "title": "Ad published from",
                        "type": "string",
                        "description": "Filter ads published on or after this date (YYYY-MM-DD). Only ads from the past year are available."
                    },
                    "dateTo": {
                        "title": "Ad published to",
                        "type": "string",
                        "description": "Filter ads published on or before this date (YYYY-MM-DD)."
                    },
                    "maxItems": {
                        "title": "Maximum number of items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of ads to scrape.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper. Residential proxies recommended for better reliability.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
