# Temu Scraper (`datascrapers/temu-scraper`) Actor

Temu product records from search keywords or Temu URLs, including price, rating, and sales text. Optional product-page fields and reviews stay on the same product row.

- **URL**: https://apify.com/datascrapers/temu-scraper.md
- **Developed by:** [Farhan Ali](https://apify.com/datascrapers) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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?

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

**Temu Scraper** creates a structured dataset of product records collected from Temu. Each dataset item is one product and can include goods id, title, URL, image, current and market price, currency, rating, review count, sales text, mall id, SKU id, and an ad flag. Query the source with search keywords or Temu search, category, and product URLs, then filter by sort, price, rating, ship-from, color, and category. Control volume with `maxItems`. Optional product-page fields and reviews stay on the same row. Retrieve records through the Apify Dataset API or export them as JSON, CSV, Excel, XML, or another supported format. The default charge is $0.001 per product, plus $0.001 when product-page fields are included, plus $0.001 per review.

### Dataset at a glance

| Property | Value |
|---|---|
| Source | temu.com |
| Record unit | One product |
| Input methods | Search queries, Temu URLs, and search filters |
| Main identifiers | `goodsId`, `url` |
| Delivery | Apify Dataset and API |
| Export formats | JSON, CSV, Excel, XML, and other Apify dataset exports |
| Update model | Fresh records per Actor run |
| Pricing | Pay per event. `product` $0.001. `product-extra` $0.001. `product-reviews` $0.001 |

### Coverage and available records

`searchQueries` are keywords such as `sports boxers men`. `startUrls` accepts Temu search, category, or product URLs. A product URL ends in `-g-{id}.html`. Search URLs look like `https://www.temu.com/search_result.html?search_key=sports%20boxers%20men`. Queries and URLs can be combined.

`sortBy` accepts `relevance`, `top_sales`, `newest`, `price_asc`, and `price_desc`. `minPrice` and `maxPrice` are integers in the store currency. `minRating` accepts `any`, `4`, `3`, and `1` (4 stars and up, 3 stars and up, 1 star and up). `shipFrom` accepts `any`, `local` (local warehouse), and `temu`. `colors` and `categories` are names as shown on Temu for that search, such as Black or Men's Underwear. `filterItems` are advanced tokens such as `103:#000000`, combined with the other filters.

`maxItems` of `0` means no product cap. `includeProductDetails` adds a `details` object and charges `product-extra` once per product. `includeReviews` adds a `reviews` array and charges `product-reviews` once per review. `maxReviewsPerProduct` defaults to 10. `0` means all reviews for that product. `detailConcurrency` defaults to 3 and accepts 1 to 50.

A search-only row has `details` null, `reviews` empty, and `scrapedReviewCount` 0. The Actor does not return a historical price series.

The default proxy is Apify residential. Set a country on the proxy so the session stays in one Temu market. The saved sample below is an `it-en` locale with EUR prices.

### Data dictionary

Deduplicate on `goodsId`.

| Field | Type | Nullable | Description | Example |
|---|---|---:|---|---|
| goodsId | string | no | Temu goods id | `601101327894474` |
| title | string | yes | Product title | Men’s boxer underwear title |
| url | string | yes | Product URL, including the query string Temu returned | `https://www.temu.com/it-en/...-g-601101327894474.html` |
| imageUrl | string | yes | Thumbnail URL | `https://img.kwcdn.com/product/fancy/e9fb2693-6dc3-4a41-bd3a-b18e49b388fd.jpg` |
| price | number | yes | Current price in major currency units | `9.57` |
| priceStr | string | yes | Price text from Temu | `9,57€` |
| marketPrice | number | yes | Compare-at price in major units | `24.18` |
| marketPriceStr | string | yes | Compare-at price text | `24,18€` |
| currency | string | yes | Currency code | `EUR` |
| rating | number | yes | Rating score | `4.8` |
| reviewCount | integer | yes | Review count shown on the card | `655` |
| salesTip | string | yes | Sales text | `25K+ sold` |
| mallId | string | yes | Mall id | `634418223812658` |
| skuId | string | yes | Current SKU id | `17599314898424` |
| videoUrl | string | yes | Video URL | `null` |
| isAd | boolean | no | Whether the card was marked as an ad | `true` |
| locale | string | yes | Locale prefix from the URL | `it-en` |
| seed | string | no | Query or URL that produced the row | `sports boxers men` |
| sourceQuery | string | no | Same seed label | `sports boxers men` |
| details | object | yes | Product-page object. Null until details are requested | `null` |
| reviews | array | no | Review objects. Empty until reviews are requested | `[]` |
| scrapedReviewCount | integer | no | How many reviews were stored | `0` |

`details`, when `includeProductDetails` succeeds, includes `goodsId`, `title`, `url`, `locale`, `imageUrl`, `imageUrls`, `minPrice`, `maxPrice`, `priceStr`, `soldQuantity`, `salesTip`, `categoryIds`, `properties`, `extraProperties`, `skus`, `mall`, `reviewSummary`, and `isLocalGoods`. Each SKU can include stock quantity, image URL, and a spec map. `mall` can include `mallId`, `name`, `logo`, `rating`, `goodsCount`, `salesTip`, `followers`, and `url`. `minPrice` and `maxPrice` are major units converted from Temu’s cent values when those values are numbers.

Review objects, when `includeReviews` is on:

| Field | Type | Nullable | Description |
|---|---|---:|---|
| reviewId | string | yes | Review id |
| goodsId | string | no | Parent goods id |
| skuId | string | yes | SKU id |
| comment | string | no | Review text |
| score | number | yes | Star score |
| name | string | yes | Reviewer display name |
| avatar | string | yes | Avatar URL |
| date | string | yes | Date text from Temu |
| timestamp | number or string | yes | Source time value |
| specs | object or string | yes | Spec payload |
| images | array of string | no | Review image URLs |
| productUrl | string | yes | Product URL |

### Example dataset record

This product is from a saved run with `searchQueries` set to `sports boxers men`, details off, and reviews off. The stored URL includes a long tracking query. Only the product path is shown here.

```json
{
  "goodsId": "601101327894474",
  "title": "6pcs Men'S Comfortable Slim Shaping Underwear - Breathable, Elastic, Quick Drying, Elastic Waistband, Suitable for Spring Sports, Sports, And Casual Wear - Long Boxer Underwear - Soft, Lightweight, And Moisture Absorbing",
  "url": "https://www.temu.com/it-en/6pcs-mens-comfortable--shaping-underwear-breathable-elastic-quick-drying-elastic-waistband-suitable-for-spring-sports-sports-and-casual-wear-long-boxer-underwear-soft-lightweight-and-moisture-absorbing-g-601101327894474.html",
  "imageUrl": "https://img.kwcdn.com/product/fancy/e9fb2693-6dc3-4a41-bd3a-b18e49b388fd.jpg",
  "price": 9.57,
  "priceStr": "9,57€",
  "marketPrice": 24.18,
  "marketPriceStr": "24,18€",
  "currency": "EUR",
  "rating": 4.8,
  "reviewCount": 655,
  "salesTip": "25K+ sold",
  "mallId": "634418223812658",
  "skuId": "17599314898424",
  "videoUrl": null,
  "isAd": true,
  "locale": "it-en",
  "seed": "sports boxers men",
  "sourceQuery": "sports boxers men",
  "details": null,
  "reviews": [],
  "scrapedReviewCount": 0
}
```

### Query and input reference

| Input | Type | Required | Default | Accepted values | Description |
|---|---|---:|---|---|---|
| searchQueries | array of string | no | none | Keywords | Temu search terms |
| startUrls | array | no | none | Search, category, or product URLs | Temu URLs |
| sortBy | string | no | `relevance` | relevance, top_sales, newest, price_asc, price_desc | Sort order |
| minPrice | integer | no | none | 0 or more | Minimum price in the store currency |
| maxPrice | integer | no | none | 0 or more | Maximum price in the store currency |
| minRating | string | no | `any` | any, 4, 3, 1 | Any, 4 stars and up, 3 stars and up, 1 star and up |
| shipFrom | string | no | `any` | any, local, temu | Any, local warehouse, or Temu |
| colors | array of string | no | none | Color names shown on Temu | Color filter |
| categories | array of string | no | none | Category names shown on Temu | Category filter |
| filterItems | array of string | no | none | Tokens such as `103:#000000` | Advanced filter tokens |
| includeProductDetails | boolean | no | `false` | `true`, `false` | Add `details` and charge `product-extra` |
| includeReviews | boolean | no | `false` | `true`, `false` | Add `reviews` and charge `product-reviews` per review |
| maxReviewsPerProduct | integer | no | `10` | 0 or more | Review cap per product. `0` means all reviews |
| detailConcurrency | integer | no | `3` | 1–50 | Products enriched at once |
| maxItems | integer | no | `0` | 0 or more | Product cap. `0` means no cap |
| proxyConfiguration | object | no | Apify residential proxy | Apify proxy object | Residential proxy. Set a country for the Temu market |

Minimal request:

```json
{
  "searchQueries": ["sports boxers men"],
  "maxItems": 20
}
```

Advanced request:

```json
{
  "searchQueries": ["sports boxers men"],
  "sortBy": "top_sales",
  "minRating": "4",
  "maxPrice": 20,
  "includeProductDetails": true,
  "includeReviews": true,
  "maxReviewsPerProduct": 10,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "IT"
  }
}
```

### Retrieve the data through the API

1. Start `datascrapers/temu-scraper` with the JSON input.
2. Wait until the run finishes.
3. Read items from the run’s default dataset. One item is one product.
4. Paginate with `offset` and `limit`, or export the dataset.

```bash
curl "https://api.apify.com/v2/acts/datascrapers~temu-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["sports boxers men"],"maxItems":20}'
```

```bash
curl "https://api.apify.com/v2/datasets/$DATASET_ID/items?clean=true&format=json&token=$APIFY_TOKEN"
```

Other languages are on the Actor’s API tab: https://apify.com/datascrapers/temu-scraper

### Data quality and record handling

`price` and `marketPrice` are numbers in major units. `priceStr` keeps Temu’s formatted text, which follows the locale, such as `9,57€` for `it-en`. `currency` is a code such as `EUR` when Temu sends it.

`details` is null and `reviews` is empty unless you enable those inputs. A failed product page leaves `details` unset for that product and does not charge `product-extra`. Reviews are nested on the product. They are not separate dataset items. `scrapedReviewCount` is the number of review objects stored.

The Actor does not deduplicate across runs. Use `goodsId`. `isAd` marks cards Temu labeled as ads. `seed` and `sourceQuery` repeat the query or URL that produced the row so a mixed run can be split later.

There is no historical price. Schedule a new run and store the dataset if you need a timeline. The default residential proxy should include a country that matches the Temu market you want.

### Export and pipeline examples

| Destination | Recommended method | Typical use |
|---|---|---|
| PostgreSQL or Supabase | Dataset API or a webhook consumer | Upsert products on `goodsId` |
| Google Sheets | Apify integration | Track title, price, and rating |
| S3 or other cloud storage | Scheduled dataset export | Archive one file per query |
| Warehouse | JSON items | Flatten `details.skus` and `reviews` in a later step |

Schedule one run per search query when each keyword should have its own dataset. A shared run stores the keyword in `sourceQuery`.

### Pricing and cost examples

Billing is pay per event. The same prices apply to Free, Bronze, Silver, Gold, Platinum, and Diamond.

| Event | Price on every plan | When it is charged |
|---|---:|---|
| product | $0.001 | One product row. This is the primary event |
| product-extra | $0.001 | Once when product-page fields are added |
| product-reviews | $0.001 | Once per review stored |

| Products | Details | Reviews | Estimated event cost |
|---:|---|---:|---:|
| 1,000 | off | 0 | $1.00 |
| 1,000 | on | 0 | $2.00 |
| 1,000 | off | 10,000 | $11.00 |

These are the default prices set for this account. They are placeholders and can be changed in the Actor pricing settings. Estimates do not include Apify platform usage, which is billed to the user in addition to event charges. `maxReviewsPerProduct` changes the review charge.

### Limitations and responsible data use

The Actor returns publicly available Temu product fields for the queries and URLs you submit. It does not guarantee every category, locale, or sold-out SKU. Prices follow the market of the proxy country and the URL locale. Review text is user-generated content. Ad cards are included when Temu returns them and are marked with `isAd`.

Each run is a current snapshot. You are responsible for complying with privacy, contractual, and legal requirements for the records you collect and store.

### Dataset questions

#### What does one dataset item represent?

One Temu product. Product-page fields and reviews are nested on that same item when you enable them.

#### Which field should I use as a unique identifier?

Use `goodsId`. `skuId` is the current SKU on the card, not a separate dataset row.

#### Are fields nullable or conditional?

Yes. Price, rating, video, and mall id can be null. `details` is null until `includeProductDetails` succeeds. `reviews` is empty until `includeReviews` is on.

#### Can I retrieve the records as CSV or JSON?

Yes. JSON keeps `details` and `reviews` nested. Use JSON when you need SKUs or review text intact.

#### How do I paginate large datasets?

Set `maxItems` above 0 to cap products. Set `maxReviewsPerProduct` to cap reviews. Page the dataset afterward with `offset` and `limit`.

#### Does the Actor return historical data?

No. Price, rating, and sales text are the values available at run time.

#### What counts as a billable result?

Each product charges one `product` event at $0.001. Product-page fields add one `product-extra` event. Each stored review adds one `product-reviews` event. Platform usage is separate.

### Related datasets from Data Scrapers

- [Amazon Scraper](https://apify.com/datascrapers/amazon-scraper) covers Amazon product records that can be compared on title and price.
- [eBay Scraper](https://apify.com/datascrapers/ebay-scraper) covers eBay listings for the same kind of product search.
- [Walmart Scraper](https://apify.com/datascrapers/walmart-scraper) covers Walmart product records.
- [Etsy Scraper](https://apify.com/datascrapers/etsy-scraper) covers Etsy listings when the catalog includes marketplace sellers.
- [Alibaba Scraper](https://apify.com/datascrapers/alibaba-scraper) covers Alibaba product records for wholesale comparison.

### Data Scrapers support

Need an additional field, record type, or export workflow? Contact Data Scrapers at stardustspotlight@gmail.com. Include a sample source URL, required fields, expected record volume, and preferred delivery format.

# Actor input Schema

## `categories` (type: `array`):

Categories this Actor can filter. Each one is a real Temu category id.

## `feeds` (type: `array`):

Home-screen rails. These are mixed recommendations, not the clothing category tree. Women's Clothing is a category above; Women is this rail.

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

Maximum products to save across all selected categories and feeds. Use 0 for no limit.

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

Use residential proxies. Germany matches the EUR catalog this Actor requests.

## Actor input object example

```json
{
  "categories": [
    "Party Supplies"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# Actor output Schema

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

Dataset of Temu products from the selected categories or home feeds.

## `runStats` (type: `string`):

Product count and source labels for this run.

# 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 = {
    "categories": [
        "Party Supplies"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascrapers/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 = {
    "categories": ["Party Supplies"],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("datascrapers/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 '{
  "categories": [
    "Party Supplies"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call datascrapers/temu-scraper --silent --output-dataset

```

## MCP server setup

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