Scrape Temu Product Data as JSON With the Temu Plugin

Temu is one of the hardest large e-commerce sites to scrape, and the reason is structural. When you load a Temu product page in a browser, the HTML that arrives is almost empty. There is no product name in the source, no price, no rating - just a shell. Everything you actually see gets filled in afterward by a client-side request, and that request is built to refuse automation. Point a normal HTTP client or a headless browser at it and you get either a blank page or a challenge.

That is why a lot of people give up on Temu after an afternoon of requests, Playwright, and rotating proxies that still return nothing useful. The data is there on the screen, but it is not in the document, and the API call that fills it in does not want to talk to your script.

The Temu plugin solves this specific problem. You send a product URL, you get back clean JSON: name, price and currency, availability, rating, review count, images, and more. This post explains why Temu is so awkward to scrape, the approach the plugin uses, the two endpoints it exposes, and how to build something useful on top of them.

Why Temu Is Hard to Scrape

Most scraping guides assume the classic model: request a URL, get HTML back, parse the fields out with CSS selectors or XPath. That model breaks on Temu in three ways at once.

• The HTML is a shell. Product data is not server-rendered into the page. It hydrates on the client after load, so the raw document you download does not contain the fields you want.
• The hydration call refuses automation. The internal request that populates the page checks that it is being made by a real, interactive browser session. A bare HTTP client fails it, and even a headless browser trips fingerprinting unless it is carefully disguised.
• Access is metered. Temu is aggressive about rate limiting anything that looks like a crawler. You can burn through IPs quickly and still hit walls.

Put together, this means the two obvious approaches both stall. Plain requests gets an empty shell. A full headless browser can sometimes render the page, but it is slow, heavy, and still gets fingerprinted and blocked at scale.

The Approach: Read the Crawler Document

There is a detail about large e-commerce sites that is easy to miss: they want to be in Google. To rank, they have to serve something a search-engine crawler can read, because Googlebot does not run the same interactive client flow a shopper does. So the page includes a structured ld+json block - a JSON-LD document following the schema.org Product vocabulary - aimed at crawlers.

That SEO document carries the real fields: name, description, price and currency, availability, item condition, rating, review count, the variant group, the image list, per-review ratings, and a product video when one exists. It is the same data the page shows a human, formatted for machines, and it does not depend on the client-side hydration that blocks automation.

The Temu plugin reads that crawler document rather than trying to render the page. The upshot for you is simple: no headless browser, no proxy rotation, no fingerprint tuning. You call one endpoint and get structured JSON.

This is also a technique worth understanding on its own. On many sites that look impossible to scrape, checking the page source for a <script type="application/ld+json"> block, or for structured data aimed at crawlers, will hand you clean fields that the rendered DOM buries. It is the first thing worth trying before you reach for a browser.

Two Endpoints: Product and Search

The plugin has two parts:

• Product - one product URL in, full JSON out.
• Search - a keyword in, a list of Temu product URLs out, taken straight from Temu’s own search page.

They are meant to be used together: search to discover product URLs, then resolve each URL to its full data with the product endpoint.

Every request authenticates with a header, x-scrapeunblocker-key, carrying your API key.

Fetching a Single Product

The product endpoint is a POST to /goods/temu-product with the product url. The URL must be a real product page - its path ends in -g-<id>.html. Search or category URLs are rejected with a 400.

curl -X POST "https://api.scrapeunblocker.com/goods/temu-product?url=https%3A%2F%2Fwww.temu.com%2Fexample-g-601099512345678.html" \
  -H "x-scrapeunblocker-key: YOUR_API_KEY"

The response is a flat JSON object:

{
  "url": "https://www.temu.com/example-g-601099512345678.html",
  "name": "822pcs Spaceship Building Blocks Set",
  "description": "Shop the 822pcs Spaceship Building Blocks Set on Temu ...",
  "sku": null,
  "brand": "Temu",
  "price": "49.04",
  "priceCurrency": "USD",
  "availability": "https://schema.org/InStock",
  "rating": 4.6,
  "reviewCount": 871,
  "itemCondition": "https://schema.org/NewCondition",
  "variantGroupId": "601099512345678",
  "images": ["https://img.kwcdn.com/product/fancy/xxxx.jpg"],
  "reviews": [
    { "rating": 5.0, "date": "2026-07-08", "author": "****", "body": "****" }
  ],
  "video": null
}

A few fields deserve a note, because they reflect the reality of what Temu puts in the crawler document rather than a wishlist:

• price is a string, served exactly as Temu formats it, and priceCurrency is the ISO code. The currency follows the region of the exit IP, so the same product can come back as USD, EUR, or AED. If you are storing prices, keep the currency next to the number and normalize later.
• availability and itemCondition are schema.org URLs, like https://schema.org/InStock and https://schema.org/NewCondition. Match on the last path segment rather than the full string.
• images carries only one or two URLs, not the full gallery. The crawler document does not include every image the shopper carousel shows.
• reviews gives you a real rating and date per review, but Temu masks the author and body - they come back as ****. You get the distribution and recency of reviews, not the text.
• variantGroupId ties variants of the same item together, which is useful if you are de-duplicating a catalog.

Searching by Keyword

The search endpoint takes a keyword and returns about 40 product URLs per call, pulled from Temu’s own search results.

curl -X POST "https://api.scrapeunblocker.com/goods/temu-search?keyword=kids%20toys&limit=40&sort=price_asc" \
  -H "x-scrapeunblocker-key: YOUR_API_KEY"

{
  "keyword": "kids toys",
  "sort": "price_asc",
  "resultsCollected": 40,
  "urls": [
    "https://www.temu.com/lt-en/kids-educational-building-blocks-set-g-601099613072998.html",
    "https://www.temu.com/lt-en/water-elf-set-g-601104298893637.html"
  ]
}

Search is discovery only - it hands you clean product URLs, each ending in -g-<id>.html, ready to pass to the product endpoint. You control it with three parameters:

• keyword - the search phrase, like kids toys or phone case.
• limit - how many URLs to return, default 40, max 100. One search page carries roughly 40 results.
• sort - the result order, using Temu’s own sort: relevance (default), best_selling, recent, price_asc, or price_desc. This is server-side, so the entire result set is sorted, not just the page you get reshuffled.

Putting It Together in Python

The natural pattern is search, then resolve. Search for a keyword, take the URLs, and fetch each product. Here is a small script that pulls the cheapest listings for a keyword and prints price, rating, and name:

import requests
from urllib.parse import quote

BASE = "https://api.scrapeunblocker.com"
HEADERS = {"x-scrapeunblocker-key": "YOUR_API_KEY"}

def temu_search(keyword, limit=40, sort="relevance"):
    url = f"{BASE}/goods/temu-search?keyword={quote(keyword)}&limit={limit}&sort={sort}"
    r = requests.post(url, headers=HEADERS, timeout=60)
    r.raise_for_status()
    return r.json()["urls"]

def temu_product(product_url):
    url = f"{BASE}/goods/temu-product?url={quote(product_url, safe='')}"
    r = requests.post(url, headers=HEADERS, timeout=60)
    r.raise_for_status()
    return r.json()

urls = temu_search("kids toys", limit=20, sort="price_asc")
for u in urls[:10]:
    p = temu_product(u)
    print(f"{p['price']} {p['priceCurrency']}  {p['rating']}*  {p['name'][:60]}")

Because the fields come back normalized, the interesting logic is yours to write - not selector maintenance.

Handle the Rate Limit and Errors

The Temu crawler view is metered, so this plugin is built for targeted use - price checks, monitoring, and comparison - not bulk crawling. Design around that from the start.

• 429 means the plugin’s shared Temu rate budget is spent. Back off and retry shortly rather than hammering. Add a short sleep and a few retries with exponential backoff in your loop.
• 400 means the URL was not a product page. Make sure the path ends in -g-<id>.html.
• 502 means the document could not be fetched - a block or empty result. Retry once; if it persists, the product may be gone.
• 504 is a timeout. Retry.

A simple rule: keep your request volume modest, cache what you already fetched, and only re-fetch products whose price or availability you actually need to track.

What You Can Build

Once Temu data is clean JSON, several tools become quick to build:

• Price monitoring - fetch a product on a schedule, store price and availability, and alert when either changes.
• Competitive research - search a keyword for around 40 URLs, resolve each, and compare prices, ratings, and review counts across the set.
• Catalog enrichment - if you already have Temu product URLs, resolve them to clean fields (name, price, rating, images) to enrich your own catalog.

Each of these is the plugin plus a little of your own logic, with no scraping infrastructure to maintain.

FAQ

Do I need a browser or proxies to scrape Temu? No. The plugin reads Temu’s structured crawler document rather than rendering the page, so there is no headless browser and no proxy rotation on your side. You call one HTTP endpoint with your API key.

Why is the currency sometimes different for the same product? Temu prices follow the region of the exit IP, so the same item can return USD, EUR, or AED. Always store priceCurrency alongside price and convert later if you need a single currency.

Why are review authors and text hidden? Temu masks the review author and body in the crawler document, so they come back as ****. The per-review rating and date are real, which is enough for rating trends and recency but not sentiment on the text.

Can I crawl Temu in bulk with this? No. The endpoint is metered and returns 429 when the shared budget is spent. It is designed for targeted lookups - monitoring, comparison, and enrichment - not full-catalog crawling.

How do I get product data from a search? Search returns URLs only. Take each URL and pass it to the product endpoint to get name, price, rating, images, and the rest.

Wrapping Up

Temu earns its reputation as a hard target: the data is on the screen but not in the document, and the call that fills the page in is built to reject automation. The Temu plugin sidesteps that by reading the structured data Temu already serves to crawlers, so you get name, price, rating, reviews, and images as clean JSON from a single request.

If you want to try it, run a lookup in the dashboard first to see the JSON, then wire it into your code using the developer docs. It is one of a growing set of ready-made plugins on ScrapeUnblocker that turn sites which would otherwise take real scraping work into a single structured call.