# Temu Scraper - Products, Prices & New-Product Alerts (`lukehunter/temu-scraper`) Actor

Scrape Temu search results: product title, price, currency, image and product link, about 40 per page. Turn on new-product alerts to get only products you have not seen, sent to Discord, Telegram, Slack or any webhook. No login, no cookies. $0.003 per product.

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

## Pricing

$3.00 / 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.

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 - Products, Prices & New-Product Alerts

**For dropshipping product research, price monitoring and trend spotting on Temu.** Give it search terms (or your own Temu search URLs) and it returns one row per product on the results page - title, price, currency, image and product link - read straight from Temu's own public search pages, with the sold count, rating and review count filled in whenever Temu's page states them. No login, no cookies, no proxy. Turn on **new-product alerts** (`onlyNewSinceLastRun`) and run it on a schedule to get only the products that were not in your results last time.

Pay-per-result: **$0.003 per product - 1,000 products = $3.**

### Quick start (1 minute)

1. Open the **Input** tab and enter one or more search terms, e.g. `phone case`.
2. Set **Maximum products** (the prefilled 20 costs $0.08).
3. Click **Start**. Export the dataset to CSV/Excel/JSON, or pull it through the API shown below.

```json
{
  "searchTerms": ["phone case"],
  "maxItems": 20
}
```

### How it works

Temu's search page (`/search_result.html?search_key=...`) is server-rendered: the product list is embedded in the HTML, so no login, cookie or browser is needed to read it. This Actor:

1. Checks `www.temu.com/robots.txt` before reading anything, and again for every page and every redirect it is sent to. If a path is disallowed, or robots.txt cannot be read, it reads nothing and says why.
2. Reads the search page politely: one request about every 2 seconds, with an honest, self-identifying User-Agent.
3. Parses each product into one flat row. The product link is the page's own link with Temu's tracking parameters removed.
4. Follows the page's own "next page" link for more results, only while your **Maximum products** cap is not reached.
5. Reports honestly - never disguises or evades - a bot-check or verification page, a block, or a search with genuinely no products. A page without product data produces no rows and no charge.

### Use cases

- **Dropshipping product research**: run a niche keyword (`desk lamp`, `phone case`, `pet hair remover`) and export titles, prices and images of what Temu is surfacing for it, to see price bands and how crowded a niche is before you source anything.
- **Price monitoring with alerts**: schedule the same searches daily and compare `price` over time, or turn on new-product alerts to get only products that have appeared since the last run.
- **Trend spotting**: schedule a list of category keywords and use `searchTerm`, `position` and `scrapedAt` to see which products and price points enter a keyword's results, and when.

### New-product alerts: get only new products

Turn on `onlyNewSinceLastRun` and put this Actor on a **schedule**. Every run after the first delivers (and charges for) only products it has not delivered before for that exact search.

1. Set your search as usual, plus:

```json
{
  "searchTerms": ["desk lamp"],
  "onlyNewSinceLastRun": true,
  "maxItems": 100
}
```

2. Click **Schedule** on the run page (or create one under **Schedules** in the Apify Console) - daily works well.
3. **The first scheduled run is a baseline**: it delivers every product currently listed (it is all new to you) and remembers it, so you are charged normally for that run. Every run after that only delivers products it has not seen for this search.
4. Add a **Webhook** under the schedule's **Integrations** for `ACTOR.RUN.SUCCEEDED` (Slack, email, or a Zapier/Make step) to be told when a run finds something new.

The status message tells you what happened: `"First run for 1 search: 40 product(s) delivered and remembered; next runs return only new ones."`, then `"3 new product(s) since last run across 1 search (37 already seen)."`. A run that finds nothing new still **succeeds** with an empty dataset - that is the point of the mode. A product is remembered only after it was delivered, so one cut by your `maxItems` cap shows up on the next run instead of being lost. Each search term and each URL is its **own watch**; `stateStoreName` only needs changing to isolate or reset a watch's memory.

### Get Temu alerts in Discord, Telegram, Slack, Teams, Google Chat, your phone (ntfy/Pushover) or any app (webhook)

Want a **Temu Discord alert**, a **Temu Telegram bot**, or new products pushed to Slack, Teams, Google Chat or your phone instead of checking a dataset? Add one or more destinations in the Actor's **Notifications (optional)** section and each run sends the products it delivered. It is a **monitor that notifies you**: it only reads public Temu search pages and never buys anything or logs in anywhere, and the messages go only to the places you set up.

| Channel | Fill in | What you get |
|---|---|---|
| Discord | `discordWebhookUrl` | One card per product, 10 per message |
| Telegram | `telegramBotToken` + `telegramChatId` | Up to 10 products per message, one line each |
| Slack | `slackWebhookUrl` | Block Kit message, up to 10 products per message |
| Mattermost, Rocket.Chat | `slackCompatibleWebhookUrl` | Slack-style incoming webhook: a Markdown list (these apps do not render Slack Block Kit) |
| Microsoft Teams | `teamsWebhookUrl` | Adaptive Card from a Teams Workflows webhook, up to 10 products per card |
| Google Chat | `googleChatWebhookUrl` | Card in a space, up to 10 products per message |
| ntfy (phone push, no account) | `ntfyTopic` (optional `ntfyServer`, `ntfyToken`) | A push per product, up to 10, then one "...and N more" |
| Pushover (phone push) | `pushoverUserKey` + `pushoverAppToken` | A push per product, up to 10, then one "...and N more" |
| Any app: Zapier, Make, n8n, Pipedream, IFTTT, Home Assistant | `webhookUrl` | One JSON POST per run with the delivered rows |

Fill in as many as you like; each channel works on its own and a failing one never stops the others.

#### Setup, channel by channel

- **Discord (1 minute):** Server Settings → Integrations → Webhooks → New Webhook → pick the channel → **Copy Webhook URL**.
- **Telegram (2 minutes):** chat with **@BotFather**, send `/newbot`, paste the token into `telegramBotToken`. Add the bot to the chat or channel (administrator for a channel; for a chat with yourself press **Start** on the bot). `telegramChatId` is a numeric id (`123456789`, or `-1001234567890` for a group or channel) or a public `@channelusername`.
- **Slack:** at api.slack.com/apps create an app (**From scratch**) → **Incoming Webhooks** → switch it on → **Add New Webhook to Workspace** → pick the channel → copy the `https://hooks.slack.com/services/...` URL.
- **Mattermost or Rocket.Chat:** create an **incoming webhook** in the app and paste its public `https://` URL into `slackCompatibleWebhookUrl`. Localhost, private IP addresses and `.local` / `.internal` names are rejected.
- **Microsoft Teams:** in the channel open **... → Workflows** → **Post to a channel when a webhook request is received** → finish the wizard and copy the URL (a host ending in `.logic.azure.com` or `.powerplatform.com`). The old "Office 365 connector" webhooks are retired and not supported.
- **Google Chat:** in the space open **Apps & integrations → Webhooks → Add webhook**, name it and copy the `https://chat.googleapis.com/v1/spaces/...` URL (needs a Google Workspace account that allows webhooks).
- **ntfy (free, no account):** install the ntfy app (or open ntfy.sh), subscribe to a topic with a long random name, and put the same name in `ntfyTopic`. Anyone who knows the topic can read it, so make it unguessable. Own server or a protected topic: set `ntfyServer` (public `https://` address) and `ntfyToken`.
- **Pushover:** copy your user key from pushover.net into `pushoverUserKey`, create an application at pushover.net/apps/build and put its API token in `pushoverAppToken`. Pushover itself is a separate paid app after its trial: check their pricing.
- **Any app (webhook):** paste the catch-hook URL from Zapier, Make, n8n, Pipedream, IFTTT or Home Assistant into `webhookUrl`. It must be a public `https://` address.

#### The recipe: a Temu new-product alert in five steps

1. Set your search in `searchTerms` (for example `phone case`) or paste a Temu search URL into `startUrls`.
2. Turn on `onlyNewSinceLastRun`, so only products not delivered before are sent.
3. Add your destination(s) from the table above.
4. Run it once. The first run is the baseline and sends what is currently listed (up to `maxNotifications`).
5. Create a **Schedule** (for example every few hours). From then on you only hear about products it has not delivered before for that search.

```json
{
  "searchTerms": [
    "phone case"
  ],
  "onlyNewSinceLastRun": true,
  "maxItems": 100,
  "ntfyTopic": "your-long-random-topic-name",
  "maxNotifications": 25
}
```

#### The generic webhook (`webhookUrl`)

Each run sends **one POST per 100 delivered rows** (so usually one) with this body, followed by whatever your tool does with it:

```json
{
  "source": "apify",
  "actor": "temu-scraper",
  "runId": "HG7ML7M8z78YcAPEB",
  "count": 2,
  "total": 2,
  "part": 1,
  "parts": 1,
  "items": [ { "...": "the full dataset rows" } ]
}
```

`count` is the number of rows in this POST, `total` the number in the run, and `part` / `parts` number the POSTs when a run delivers more than 100 rows. `maxNotifications` does not cap the webhook. Your endpoint should answer with a 2xx status; redirects are not followed and a failure is reported in the run status, never retried in a loop.

#### What to expect

- **What a message contains:** title, price as Temu displays it, sold count, rating and review count when the page carries them, and a thumbnail, plus the link and the search term it matched.
- **Only delivered products are sent.** A run that finds nothing new sends nothing, so there is no "no new products" spam. Rows the run could not deliver (for example because your spending limit was reached) are not sent.
- **`maxNotifications` (default 25, max 100)** caps how many products go to chat and phone channels per run (the webhook is not capped). The rest are still in the dataset and the status message says so. ntfy and Pushover send at most 10 individual pushes, then one "...and N more" summary.
- **Cost: notifications are free.** You pay only for delivered products at the usual price, exactly as without alerts. There is no extra charge for any channel.
- **Failures never fail the run.** A deleted webhook or an unreachable service leaves the run successful and the dataset complete, and the status message says what happened, for example `Notified: Discord 12, Slack 12, ntfy 10 (+summary). Teams failed (HTTP 404) - check the webhook URL.` The logs show the channel name and HTTP status only, never a URL or token.
- **Your URLs, tokens and ntfy topic are stored as secret inputs.** Anyone holding a webhook URL can post to that channel, so treat it like a password.
- **The dataset is unchanged.** The output rows are identical whether or not you set a destination; the run's status message just gains a short note such as `Notified: Discord 12, ntfy 10 (+summary).`
- **It is a monitor that notifies you.** It never buys anything or logs in to Temu, and the messages go only to the destinations you set up.

### Input

```json
{
  "searchTerms": ["phone case"],
  "startUrls": [],
  "maxItems": 100,
  "onlyNewSinceLastRun": false,
  "stateStoreName": "temu-scraper-seen-products"
}
```

| Field | Type | Default | Description |
|---|---|---:|---|
| `searchTerms` | string\[] | *(none)* | Words to search for, e.g. `"phone case"`. Up to 50 per run. |
| `startUrls` | string\[] | *(none)* | Temu search URLs, e.g. `https://www.temu.com/search_result.html?search_key=desk%20lamp`. Only `www.temu.com` search pages are accepted (product, category and account pages are not). Tracking parameters and `page` are dropped. Up to 50 per run. At least one of `searchTerms` or `startUrls` is required. |
| `maxItems` | integer | 100 | 1-5,000. Hard cap on products delivered across the whole run - your cost cap. |
| `onlyNewSinceLastRun` | boolean | `false` | New-product alerts mode - see above. |
| `stateStoreName` | string | `temu-scraper-seen-products` | Name of the store that remembers what each alert-mode search has delivered. |
| `discordWebhookUrl` | string (secret) | *(none)* | Discord webhook URL. Must look like `https://discord.com/api/webhooks/<id>/<token>`. Empty means no Discord messages. |
| `telegramBotToken` | string (secret) | *(none)* | Telegram bot token from @BotFather. Needs `telegramChatId`. |
| `telegramChatId` | string | *(none)* | Telegram chat to post to: a numeric chat id or `@channelusername`. The bot must be added to that chat or channel. Needs `telegramBotToken`. |
| `slackWebhookUrl` | string (secret) | *(none)* | Slack incoming webhook, `https://hooks.slack.com/services/...`. |
| `slackCompatibleWebhookUrl` | string (secret) | *(none)* | Mattermost / Rocket.Chat incoming webhook (public `https://` URL; Markdown list, no Block Kit). |
| `teamsWebhookUrl` | string (secret) | *(none)* | Microsoft Teams Workflows webhook (host ending `.logic.azure.com` or `.powerplatform.com`). |
| `googleChatWebhookUrl` | string (secret) | *(none)* | Google Chat space webhook, `https://chat.googleapis.com/v1/spaces/...`. |
| `ntfyTopic` | string (secret) | *(none)* | ntfy topic name; setting it turns ntfy phone pushes on. Pick a long, unguessable name. |
| `ntfyServer` | string | `https://ntfy.sh` | ntfy server. Only change it for your own public `https://` ntfy server. |
| `ntfyToken` | string (secret) | *(none)* | Optional ntfy access token for a self-hosted server or protected topic. Needs `ntfyTopic`. |
| `pushoverUserKey` | string (secret) | *(none)* | Pushover user key. Needs `pushoverAppToken`. |
| `pushoverAppToken` | string (secret) | *(none)* | Pushover application API token. Needs `pushoverUserKey`. |
| `webhookUrl` | string (secret) | *(none)* | Generic JSON webhook (Zapier, Make, n8n, Pipedream, IFTTT, Home Assistant): the delivered rows, 100 per POST. Public `https://` only. |
| `maxNotifications` | integer | 25 | 1–100. Most products sent to chat and phone channels per run (the webhook is not capped). Extra rows are still in the dataset. Only used when a destination is set. |

There is no country or currency input: Temu does not let a page choose its region through the URL without cookies, so you get the region and currency Temu serves to the Actor's run location (US dollars in our checks). `currency` on every row says what you got.

### Output fields

| Category | Fields |
|---|---|
| Identity | `productId`, `url` |
| Listing | `title`, `imageUrl` |
| Price | `price`, `currency`, `priceText` |
| Demand signals | `soldCount`, `rating`, `reviewCount` (only when Temu's page states them, otherwise `null`) |
| Search context | `searchTerm`, `page`, `position`, `scrapedAt` |

Missing values are returned as `null`. Nothing is invented.

### Output example

```json
{
  "productId": "607667892360443",
  "title": "Phone Case - Phone Case, New High-End Tianyan Ladder Phone Case, Suitable for Apple Iphone 18/17/16/15/14/13/12/11/Plus/Pro/Max Series, Matte Feel, Creative Pattern Phone Protective Case, Anti-Drop Soft Case",
  "url": "https://www.temu.com/phone-case-phone--high-end--ladder-phone-case-suitable-for--iphone-18-17-16-15-14-13-12--pro--matte--pattern-phone-protective-case-anti-drop-soft-case-g-607667892360443.html",
  "price": 4.46,
  "currency": "USD",
  "priceText": "$4.46",
  "soldCount": null,
  "rating": null,
  "reviewCount": null,
  "imageUrl": "https://img.kwcdn.com/product/open/46aba906605945e8a48411a12d2f7ff1-goods.jpeg",
  "searchTerm": "phone case",
  "page": 1,
  "position": 1,
  "scrapedAt": "2026-10-06T10:00:00.000Z"
}
```

### Use it as an API

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("lukehunter/temu-scraper").call(
    run_input={
        "searchTerms": ["phone case", "desk lamp"],
        "maxItems": 200,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["currency"])
```

### Pricing and cost control

Pay per delivered product.

**$0.003 per product - 1,000 products = $3.**

| Products delivered | Cost |
|---:|---:|
| 20 | $0.06 |
| 100 | $0.30 |
| 1,000 | $3.00 |
| 5,000 | $15.00 |

There is no charge for starting a run, and no charge for a search that is skipped, blocked, or produces no products. `maxItems` gives you a hard upper bound on cost, and your run's own spending limit is honoured too: the Actor never delivers a product the limit cannot pay for.

Notifications to Discord, Telegram, Slack, Teams, Google Chat, ntfy, Pushover and webhooks are free: you pay only for delivered products, never for messages sent.

### Limitations

- **About 40 products per search page.** The two search pages this Actor was built against listed 40 products each. For more, it follows the page's own "next page" link, but only as far as Temu serves product data for it: if a later page comes back without products (or Temu answers with a bot-check), that search ends there, keeps what it already delivered, and the status message says so. You are charged only for products delivered. Plan around one page (about 40 products) per search term, and use more specific search terms rather than expecting deep result lists.
- **Sold counts, ratings and review counts are usually empty.** They are filled only when Temu's search page states a real figure. In the signed-out search pages captured for this Actor, none of the 80 products carried them (the sold-count field was a placeholder `0`, which this Actor does not report as "0 sold"), so expect `null` for most or all rows. There is no original-price or discount field for the same reason: the page does not provide one.
- **Region and currency are Temu's choice.** No country or currency input; `currency` shows what Temu served.
- **Search pages only.** No product detail pages, variants, shipping, seller or review text, and no category browsing.
- **No login, no cookies, no Temu API.** A bot-check, verification or login page is reported honestly (per search, in the run's status message) and nothing is charged for it; this Actor does not try to get past it, and stops sending requests for the rest of that run.
- Prices and rankings reflect the page at scrape time and change often.
- This is an independent tool, not affiliated with, endorsed by, or connected to Temu. You are responsible for using the collected data in accordance with Temu's terms and applicable law.

### Use it from your code, Make, Zapier or n8n

Built for automated pipelines: small runs, stable field names, one row per item, and you pay only for rows actually delivered.

**One API call that runs the Actor and returns the data** (replace `$APIFY_TOKEN` with your token from Apify Console → Settings → Integrations):

```bash
curl -s -X POST "https://api.apify.com/v2/acts/lukehunter~temu-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms": ["phone case"], "maxItems": 20}'
```

**JavaScript** (`npm i apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lukehunter~temu-scraper').call({
  "searchTerms": [
    "phone case"
  ],
  "maxItems": 20
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python** (`pip install apify-client`):

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('lukehunter~temu-scraper').call(run_input={"searchTerms": ["phone case"], "maxItems": 20})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

**Schedules, webhooks and no-code tools:** save your input as a Task, add a Schedule (e.g. hourly or daily), and attach a webhook or one of the Integrations tab's connectors (Make, Zapier, n8n, Google Sheets, Slack) to push each run's results into your own system.

**Only new items each run:** set `"onlyNewSinceLastRun": true` on a scheduled Task and every run after the first delivers, and charges for, only items it hasn't delivered before for that same input. That makes it a ready-made change feed.

**Reliability:** an automated test runs this Actor's parser against the live site every day, and failures are fixed fast.

**Feedback:** an honest rating on the Store page, good or bad, helps others decide if this Actor fits their needs. Missing a field or found a problem? Open an issue on the Actor page.

### FAQ

#### Does this collect seller or customer data?

No. Only product fields from the search page - see "Output fields".

#### Why are `soldCount`, `rating` and `reviewCount` null?

Temu's signed-out search page does not state them for most products, and this Actor never guesses a number. When the page does include a figure, it is returned.

#### Can I get more than one page of results?

The Actor follows the page's own next-page link while your `maxItems` cap allows and Temu serves product data. If Temu stops serving it, the search ends with what was delivered and says so in the status message. See "Limitations".

#### Can I choose the country or currency?

Not at the moment: Temu does not select the region through the URL without cookies. `currency` shows what was served.

#### Can I use my own Temu search URL?

Yes - paste it into `startUrls`. Only `www.temu.com` search pages are accepted.

#### How do I get only new products instead of the same ones every time?

Set `onlyNewSinceLastRun: true` and put the Actor on a schedule - see "New-product alerts". The first run delivers everything and remembers it; later runs deliver only what is new.

#### Can I get Temu alerts by email?

Not natively. There are two routes. (1) Set `webhookUrl` to a Zapier, Make or n8n catch hook and add an email or Gmail step: the webhook delivers the products as JSON, so the email can list them. (2) Apify's own run integrations and run notifications can email you when a run finishes, but they only send a link to the run or dataset, not the products themselves. For instant alerts without building anything, Telegram, ntfy or Pushover reach your phone directly.

#### Can I get Temu alerts in WhatsApp?

Not natively, and we do not use unofficial WhatsApp APIs, which risk getting your number banned. The official route is the WhatsApp Business Platform (Cloud API) with its own business account, message templates and pricing: point `webhookUrl` at a Zapier, Make or n8n flow that calls it. For free phone alerts use Telegram or ntfy instead.

### Related Actors

Other data tools from the same developer, built to the same standard: official or public sources, hard cost caps, and honest documentation of limits.

- **[Shopify Product Scraper by URL](https://apify.com/lukehunter/shopify-product-tracker)**: price, compare-at price and stock for specific Shopify product URLs, with a change-only feed.
- **[Walmart Category Scraper](https://apify.com/lukehunter/walmart-category-scraper)**: product names, prices, was-prices and ratings from Walmart category pages.
- **[Shopify Store Products Scraper](https://apify.com/lukehunter/shopify-store-products-scraper)**: full product catalogues from any Shopify store, with prices, sale prices, variants and stock.
- **[Vinted Cross-Country Price Comparison](https://apify.com/lukehunter/vinted-cross-country-prices)**: compare the same search across Vinted country markets with EUR-normalized summaries and median price gaps.
- **[Vinted Scraper](https://apify.com/lukehunter/vinted-scraper)**: Vinted search results with prices, brands and sizes in any Vinted country, plus scheduled new-listing alerts sent to Discord or Telegram.
- **[Vinted Item Scraper by URL](https://apify.com/lukehunter/vinted-item-tracker)**: price-drop and sold alerts for specific Vinted item URLs: price, brand, size, condition and availability, with a changes-only mode.
- **[AliExpress Search Scraper](https://apify.com/lukehunter/aliexpress-scraper)**: AliExpress search results with prices, discounts, ratings and sold counts, by keyword.
- **[YouTube Channel Scraper](https://apify.com/lukehunter/youtube-stats-tracker)**: new-video alerts and channel monitoring for any list of YouTube channels: subscribers, latest videos and a new-uploads-only mode for scheduled runs.

# Actor input Schema

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

Words to search for on Temu, e.g. "phone case". Each term is one Temu search. Maximum 50 terms per run.

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

Temu search page URLs to scrape instead of (or alongside) search terms, e.g. "https://www.temu.com/search_result.html?search_key=desk%20lamp". Only www.temu.com search pages are accepted; product, category and account pages are not. Maximum 50 per run.

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

Hard cap on the number of products delivered across all searches, 1-5000, default 100. You are charged $0.003 per delivered product, so this is your cost cap. Temu lists about 40 products per page and the Actor reads further pages only while this cap is not reached.

## `onlyNewSinceLastRun` (type: `boolean`):

Turn this on and run the Actor on a schedule to get only products you have not seen before: products already delivered on a previous run for the same search are skipped and never charged again. The first run for a search delivers everything and remembers it. Each search term or URL is tracked as its own watch. Off by default, so a one-off run returns everything it finds.

## `stateStoreName` (type: `string`):

Only used when "New-product alerts" is on. Name of the key-value store that remembers which products each search has already delivered, so it persists across scheduled runs. Leave the default unless several tasks must not share their alert history. Letters, numbers and hyphens only.

## `discordWebhookUrl` (type: `string`):

Post results to a Discord channel. In Discord: Server Settings -> Integrations -> Webhooks -> New Webhook -> choose the channel -> Copy Webhook URL. Looks like https://discord.com/api/webhooks/<id>/<token>. Leave empty to skip Discord.

## `telegramBotToken` (type: `string`):

Post results to Telegram. Create a bot by chatting with @BotFather on Telegram (send /newbot) and paste the token it gives you, e.g. 123456789:AA.... Needs "Telegram chat ID" below. Leave empty to skip Telegram.

## `telegramChatId` (type: `string`):

Where the bot should post: a numeric chat id (e.g. 123456789, or -1001234567890 for a group or channel) or a public @channelusername. The bot must be added to that chat or channel first (as an administrator for a channel), and for a private chat you must press Start on the bot. Needs "Telegram bot token" above.

## `slackWebhookUrl` (type: `string`):

Post results to a Slack channel (Block Kit cards, up to 10 per message). Create an incoming webhook at api.slack.com/apps -> Create New App -> Incoming Webhooks -> Add New Webhook to Workspace. Looks like https://hooks.slack.com/services/T000/B000/XXXX. Leave empty to skip Slack.

## `slackCompatibleWebhookUrl` (type: `string`):

Post results to a Mattermost or Rocket.Chat incoming webhook, which accept Slack-style webhook payloads. Must be a public https:// address (no localhost, private IP or .local/.internal hosts). These apps do not render Slack Block Kit, so they get a plain Markdown list. For real Slack use "Slack webhook URL" above. Leave empty to skip.

## `teamsWebhookUrl` (type: `string`):

Post results to a Teams channel as an Adaptive Card. In Teams: channel -> ... -> Workflows -> "Post to a channel when a webhook request is received" -> copy the URL. The host must end in .logic.azure.com or .powerplatform.com. The retired Office 365 connector webhooks are not supported. Leave empty to skip Teams.

## `googleChatWebhookUrl` (type: `string`):

Post results to a Google Chat space. In the space: Apps & integrations -> Webhooks -> Add webhook -> copy the URL. Looks like https://chat.googleapis.com/v1/spaces/<space>/messages?key=...\&token=.... Leave empty to skip Google Chat.

## `ntfyTopic` (type: `string`):

Get a phone push with no account via ntfy (ntfy.sh). Install the ntfy app, subscribe to a topic name, and enter the same name here. Anyone who knows the topic can read it, so pick a long, unguessable name (letters, numbers, - and \_). At most 10 individual pushes per run, then one "...and N more". Leave empty to skip ntfy.

## `ntfyServer` (type: `string`):

Only used with "ntfy topic". Leave as https://ntfy.sh, or enter the public https:// address of your own ntfy server.

## `ntfyToken` (type: `string`):

Only used with "ntfy topic", for a self-hosted server or a reserved topic that needs a login. An access token from ntfy (starts with tk\_). Leave empty for open topics.

## `pushoverUserKey` (type: `string`):

Get a phone push via Pushover. Your user key is shown on the Pushover dashboard (pushover.net). Needs "Pushover app token" below. At most 10 individual pushes per run, then one "...and N more". Leave empty to skip Pushover.

## `pushoverAppToken` (type: `string`):

The API token of a Pushover application you create at pushover.net/apps/build (name it after this Actor). Needs "Pushover user key" above.

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

POST the delivered rows as JSON to any public https:// URL: {source, actor, runId, count, items}. At most 100 rows per POST; every delivered row is sent regardless of the max-notifications cap. Use it to route results to email, a spreadsheet or any app. Localhost, private IP and .local/.internal addresses are rejected. Leave empty to skip.

## `maxNotifications` (type: `integer`):

Caps how many results are sent to chat and phone channels per run (Discord, Telegram, Slack, Teams, Google Chat, ntfy, Pushover), 1-100, default 25. Extra results are still in the dataset. The generic webhook is not capped. Only used when a destination above is set.

## Actor input object example

```json
{
  "searchTerms": [
    "phone case"
  ],
  "startUrls": [],
  "maxItems": 20,
  "onlyNewSinceLastRun": false,
  "stateStoreName": "temu-scraper-seen-products",
  "ntfyServer": "https://ntfy.sh",
  "maxNotifications": 25
}
```

# Actor output Schema

## `products` (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 = {
    "searchTerms": [
        "phone case"
    ],
    "startUrls": [],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("lukehunter/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": ["phone case"],
    "startUrls": [],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("lukehunter/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": [
    "phone case"
  ],
  "startUrls": [],
  "maxItems": 20
}' |
apify call lukehunter/temu-scraper --silent --output-dataset

```

## MCP server setup

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