# Temu Scraper - Product Search Data Extractor (`scrapesage/temu-scraper`) Actor

Scrape Temu search results into structured product data: product ID, title, price, discount, seller ID, image and product URL. Bulk search terms or URL import, price filters, and CSV, JSON or Excel export. Built for price monitoring, dropshipping and competitor research.

- **URL**: https://apify.com/scrapesage/temu-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** E-commerce, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.10 / 1,000 products

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Temu Scraper - Product Search Data Extractor

Scrape **Temu search results** into a clean, structured dataset. Give it a search term - or a list of
Temu search URLs - and get back every product Temu shows for it: **product ID, title, price, discount,
seller ID, image and the canonical product URL**, ready for Excel, CSV, JSON or your own pipeline.

Built for **e-commerce price monitoring, competitor research, dropshipping product research, catalog
matching and market analysis** on one of the fastest-growing marketplaces in the world.

- **Up to 120 products per result page**, paginated automatically to the depth you ask for.
- **Need thousands of products? Use more search terms.** Temu itself returns at most **~300 results
  per search** (3 pages of 120) - that is Temu's limit, not this Actor's. Ten terms at 100 each
  returns 1,000 products in a single run; the run tells you when a term ran out early.
- **No Temu account, no cookies, no login.** Nothing to configure but your search terms.
- **Pay only for products you keep** - price and adult-content filters run *during* the scrape, so
  filtered-out products are never charged.
- **Bulk input**: paste search terms, paste a block of Temu search URLs, upload a `.txt`/`.csv` file,
  or link a remote file / Google Sheet.

***

### What you get

One row per product:

| Field | Description |
|---|---|
| `productId` | Temu's numeric product (goods) ID |
| `title` | Full product title |
| `url` | Canonical Temu product URL |
| `price` | Numeric price, e.g. `12.68` |
| `priceText` | Price exactly as shown, e.g. `$12.68` |
| `currency` | Currency code, e.g. `USD` |
| `originalPrice` | Pre-discount price, when the product is discounted |
| `discountPercent` | Discount percentage, when the product is discounted |
| `soldCount` | Units sold, when Temu discloses it |
| `soldText` | The "N sold" badge verbatim, when shown |
| `imageUrl` / `imageWidth` / `imageHeight` | Main product image and its dimensions |
| `sellerId` | Temu seller (mall) ID - group or match listings by seller |
| `sellerType` | `first-party`, `third-party-marketplace` or `local-warehouse` |
| `skuId` | Currently selected SKU ID |
| `tags` | Merchandising badges, e.g. `Only 7 left`, `Used - Like New` |
| `isAdultProduct` | Whether Temu flags the listing as adult content |
| `onFlashDeal` / `dealEndsAt` | Whether the product is in a timed deal, and when it ends |
| `rank` | Position in the result set |
| `searchTerm` | The search term the row came from |
| `sourceUrl` / `scrapedAt` | Provenance of the row |

#### Honest note on field coverage

Temu itself only publishes some of these for some listings, so a few fields are deliberately `null`
rather than guessed. Measured across a full 120-product result page:

- `originalPrice` / `discountPercent` - **~6%**: present only while a product is actually discounted.
- `soldCount` / `soldText` - **~5%**: Temu discloses sales volume for a minority of listings. This
  actor emits `null` when nothing is disclosed rather than a misleading `0`.
- `tags` - **~31%**: only listings Temu badges.
- `dealEndsAt` - **~17%**: only listings on a countdown.

Everything else - `productId`, `title`, `url`, `price`, `priceText`, `currency`, `imageUrl`,
`sellerId`, `sellerType`, `skuId`, `rank` - is **100% populated**.

***

### Input

| Field | What it does |
|---|---|
| **Search terms** | One term per line, exactly what you would type into Temu's search box. |
| **Start URLs** | Temu search-result URLs. Supports **Link remote text file** and **file upload**. |
| **Search URLs from a file or pasted list** | Paste a block of URLs, or one link to a `.txt`/`.csv`/Google Sheet. Ideal from the API or an AI agent. |
| **Max products per search term** | Stop after this many products per term. Temu returns 120 per page. |
| **Minimum / Maximum price** | Keep only products in a price band. Applied while scraping - filtered rows are not charged. |
| **Exclude adult products** | Drop listings Temu flags as adult content. |
| **Proxy configuration** | Residential proxies are strongly recommended and set by default. |

```json
{
  "searchTerms": ["wireless earbuds", "yoga mat"],
  "maxResultsPerTerm": 240,
  "minPrice": 5,
  "maxPrice": 50,
  "excludeAdultProducts": true
}
```

**Product-detail URLs are not supported.** Temu serves individual product pages as an empty
JavaScript shell with no data in it, so this actor scrapes search-result pages only. Every row still
carries the canonical product URL.

***

### Use with AI assistants (MCP)

This actor works as a tool for AI assistants and agents through the
[Apify MCP server](https://docs.apify.com/platform/integrations/mcp) - ask for Temu products in
natural language and the agent runs this scraper and reads the dataset back.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

***

### Pricing

Pay-per-event: you are charged **per product returned**. Products removed by your price or
adult-content filters are never charged, and a run that returns nothing costs nothing.

### Reliability - read this before you buy

**Temu rate-limits its own search pages.** That is the single thing that decides how much data a
run returns, and this Actor is built around it rather than pretending otherwise:

- it rotates a pool of search-engine crawler identities, because Temu's limit applies per identity;
- a throttled response is detected and **retried on a fresh IP and a different identity**, never
  mistaken for "no results";
- any search still refused at the end gets a **second pass** after a deliberate pause, because the
  throttle usually lifts within a few minutes;
- searches run **several at a time**, so the run waits out one slow patch instead of every one.

**What this means in practice.** Small and medium jobs - up to a few hundred products - normally
come back complete, in a couple of minutes. On a large multi-term job, **some searches can still come
back empty**, and we would rather tell you than quietly hand you a short file. When that happens the
run status says exactly which searches are missing, for example:

> ⚠ INCOMPLETE: 8 of your 10 searches returned data. Temu rate-limited the other 2 (`water bottle`,
> `hair clips`) even after a second attempt, so they are MISSING from this dataset. This is Temu
> throttling its own search pages, not a failure of your input - re-run just those searches in a few
> minutes and they will usually come through. You were not charged for the missing ones.

**You are never charged for a search that returned nothing**, and a run that gets nothing at all
costs nothing at all. If completeness matters more than speed, run fewer search terms per run and
space the runs a few minutes apart - that reliably returns everything.

### Legal

This actor collects **only publicly available** product listings from Temu search pages - no login,
no personal data, and nothing behind an account. Temu's `robots.txt` places no restriction on
search-result pages for general agents. You are responsible for how you use the data, including
compliance with Temu's terms and applicable law.

*Not affiliated with, endorsed by, or sponsored by Temu. "Temu" is a trademark of its respective
owner and is used here only to describe what this actor scrapes.*

# Actor input Schema

## `searchTerms` (type: `array`):

What to search Temu for, one term per line - exactly what you would type into Temu's search box (for example <code>wireless earbuds</code>). Each term is scraped independently and every product row carries the term it came from.

## `startUrls` (type: `array`):

Temu search-result URLs to scrape instead of, or as well as, search terms. Use <b>Link remote text file</b> or <b>Upload file</b> to import a list - a plain text file with one URL per line works. Product-detail URLs are not supported: Temu serves those as an empty JavaScript shell, so only search pages are accepted.

## `urlsFromFile` (type: `string`):

Paste a block of Temu search URLs (one per line), or paste a single link to a text/CSV file containing them. Useful from the API or an AI agent, where no file picker is available. Blank lines, <code>#</code> comments and quotes are ignored.

## `maxResultsPerTerm` (type: `integer`):

Stop after this many products for each search term. <b>Temu itself returns at most about 300 results per search</b> (3 pages of 120), so setting this above ~300 will not return more for a single term - to collect more, add more search terms. For example, 10 terms at 100 each gives 1,000 products.

## `minPrice` (type: `integer`):

Skip products cheaper than this, in the store currency (USD). Filtering happens while scraping, so filtered-out products are never charged.

## `maxPrice` (type: `integer`):

Skip products more expensive than this, in the store currency (USD). Filtering happens while scraping, so filtered-out products are never charged.

## `excludeAdultProducts` (type: `boolean`):

Drop listings Temu flags as adult content.

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

Temu only serves its rendered product data to search-engine crawlers and rate-limits that view hard, so this Actor needs proxies with a large address pool. Residential proxies are strongly recommended; the defaults are already set correctly.

## Actor input object example

```json
{
  "searchTerms": [
    "wireless earbuds"
  ],
  "maxResultsPerTerm": 120,
  "excludeAdultProducts": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Every Temu product scraped by this run, one row per product.

# 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 = {
    "searchTerms": [
        "wireless earbuds"
    ],
    "maxResultsPerTerm": 120
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/temu-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 = {
    "searchTerms": ["wireless earbuds"],
    "maxResultsPerTerm": 120,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/temu-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 '{
  "searchTerms": [
    "wireless earbuds"
  ],
  "maxResultsPerTerm": 120
}' |
apify call scrapesage/temu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapesage/temu-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/ExmLA8TXvdcFqsnnx/builds/g4c1KbwKSogzHRWh0/openapi.json