How to Scrape Temu Data with an API

Direct answer: use Temu’s official Partner Platform API if you are a seller, an ISV working for a seller, or another authorized partner. Temu documents HTTPS POST requests to separate US, EU and global production routers. Requests require an API type, app key, access token, signature and Unix timestamp. The API exposes only the data covered by the permissions granted to the authorized account.

Do not build a production integration by crawling Temu consumer pages. Temu’s Terms of Use prohibit manual or automated access to “crawl,” “scrape,” or “spider” pages or data, and restrict commercial use of service information unless Temu explicitly permits it.

What “Temu data” can mean

The Partner Platform Terms describe transaction information broadly. Depending on your account, app and permission package, this can include:

• Product and SKU information
• Inventory and availability
• Orders and order status
• Shipping and logistics information
• Other resources exposed by a specific API reference

Permissions are not implied by the platform. Each API and authorization package determines what your token can retrieve. A product-data integration and an order-management integration may require different permissions.

Official API versus consumer-page scraping

Area	Partner Platform API	Consumer-page scraping
Authorization	Requires platform or seller authorization.	Consumer terms prohibit automated crawling and scraping, apart from a narrow EU systemic-risk research exception.
Requests	Documented HTTPS POST requests to regional routers.	No supported consumer scraping interface is documented in the official sources.
Credentials	App key, access token, signature and timestamp.	Replaying browser calls can depend on undocumented controls and is not an approved substitute.
Data governance	Access is limited by account and API permissions.	Commercial reuse and significant copying can violate the consumer terms.
Maintenance	Follow current versions, permissions and regional documentation.	Page changes, anti-bot behavior and compliance risk are your responsibility.

Step 1: identify your integration role

Temu’s documentation is written for developers who have joined the open platform. Decide which of these describes your project:

1. Seller-owned application: your own Temu store needs product, inventory, order or logistics data.
2. ISV: you provide software for one or more sellers and each seller authorizes your app.
3. Another authorized partner: your organization has a documented platform relationship and permitted use.

If none applies, stop before writing a scraper. The public product pages are not a documented integration surface.

Step 2: obtain seller and platform authorization

Temu’s Seller Authorization Guide says authorization must be obtained in advance before open-platform API capabilities can be used normally. US and EU sellers use different authorization routes, and local and cross-border sellers have separate flows.

Manual authorization

With manual authorization, the seller signs in to Seller Center, selects your app and chooses the permissions to grant. Temu then displays an access token for the seller to copy into your secure configuration.

Callback authorization

For an app-store installation flow, configure a redirect URL. After the seller grants permissions, Temu redirects to your callback with an authorization code. Your backend exchanges that code for an access token. Keep the exchange on the server; never expose app secrets in browser JavaScript.

Step 3: choose the regional endpoint

Temu’s endpoint guide currently documents POST requests and these production routers:

Store region	Production router
United States	https://openapi-b-us.temu.com/openapi/router
European Union	https://openapi-b-eu.temu.com/openapi/router
Global locations such as Mexico and Japan	https://openapi-b-global.temu.com/openapi/router

Select the router based on the store being accessed, not the physical location of your server. Verify the current documentation before deployment because endpoint coverage can change.

Step 4: build the signed request

Common parameters listed in Temu API references are:

• type: the API name, such as temu.research.mall.goods.query or another endpoint you are permitted to call.
• app_key: your application identifier.
• access_token: the seller-granted token.
• sign: the signature generated according to Temu’s current signing guide.
• timestamp: a ten-digit Unix timestamp in seconds.
• data_type and version: optional fields when required by the endpoint.

The product-attributes reference requires the timestamp to be within 300 seconds before or after current time. Synchronize your server clock with a time service and generate a fresh timestamp for every request.

cURL request template

curl --request POST \
  --url 'https://openapi-b-us.temu.com/openapi/router' \
  --header 'Content-Type: application/json' \
  --data '{
    "type": "YOUR_API_TYPE",
    "app_key": "YOUR_APP_KEY",
    "access_token": "YOUR_ACCESS_TOKEN",
    "sign": "SIGN_GENERATED_BY_TEMU_RULES",
    "timestamp": "UNIX_TIMESTAMP",
    "data_type": "JSON",
    "version": "API_VERSION",
    "YOUR_ENDPOINT_FIELD": "YOUR_VALUE"
  }'

Replace the router, API type, endpoint fields and signature with values from the API reference for your permission package. Do not guess the signing algorithm or include a placeholder signature in production.

Python request template

import time
import requests

ROUTER = "https://openapi-b-us.temu.com/openapi/router"
payload = {
    "type": "YOUR_API_TYPE",
    "app_key": "YOUR_APP_KEY",
    "access_token": "YOUR_ACCESS_TOKEN",
    "sign": "SIGN_GENERATED_BY_TEMU_RULES",
    "timestamp": str(int(time.time())),
    "data_type": "JSON",
    "version": "API_VERSION",
    "YOUR_ENDPOINT_FIELD": "YOUR_VALUE",
}

response = requests.post(ROUTER, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

Generate sign immediately before requests.post using the exact current Temu signature specification. Log the API type, region and request ID, but redact tokens and signatures.

Node.js request template

const router = 'https://openapi-b-us.temu.com/openapi/router';

const payload = {
  type: 'YOUR_API_TYPE',
  app_key: process.env.TEMU_APP_KEY,
  access_token: process.env.TEMU_ACCESS_TOKEN,
  sign: 'SIGN_GENERATED_BY_TEMU_RULES',
  timestamp: String(Math.floor(Date.now() / 1000)),
  data_type: 'JSON',
  version: 'API_VERSION',
  YOUR_ENDPOINT_FIELD: 'YOUR_VALUE'
};

const res = await fetch(router, {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify(payload)
});

if (!res.ok) throw new Error(`Temu HTTP ${res.status}: ${await res.text()}`);
console.log(await res.json());

Step 5: request only the data you are allowed to use

Start with the API reference for your exact region and permission package. For example, Temu documents temu.research.mall.goods.query on the EU Partner Platform and maps it to the EU router. Other references cover product attributes, orders or logistics. Read the endpoint’s required body fields, pagination rules, version and permission package before coding.

Store only the fields your application needs. Define retention and deletion rules for order and customer-related information, restrict access to production tokens, and separate seller data by account ID in your database.

Pagination, retries and production reliability

• Pagination: follow the endpoint’s documented cursor or page fields. Persist the last successful cursor so a worker can resume after a process restart.
• Retries: retry network failures and temporary server errors with exponential backoff and jitter. Do not blindly retry validation, authorization or signature errors.
• Idempotency: for read operations, a retry is normally safe; for write endpoints, follow the endpoint’s idempotency guidance before adding automatic retries.
• Clock health: alert when timestamp errors appear. A five-minute tolerance leaves little room for a badly skewed host.
• Rate control: queue requests per seller and region. Respect limits published for your account and avoid unbounded parallel workers.
• Observability: record region, API type, latency, HTTP status, Temu error code and pagination progress without logging secrets.

Common errors and fixes

Symptom	Likely cause	Fix
Timestamp or signature rejected	Clock skew, wrong canonicalization or stale signature.	Synchronize time, generate a new timestamp and implement the current signature guide exactly.
Unauthorized or permission denied	The seller did not grant the endpoint’s permission package.	Review authorization in Seller Center and request only APIs included in the granted scope.
Works in US but fails in EU	Wrong regional router or app configuration.	Use the store’s regional host and verify the app is configured for that region.
HTTP method error	A GET request was sent to the router.	Use POST; Temu’s endpoint guide currently states that API interaction supports POST.
Empty result	Filters, version or account scope do not match available data.	Check required fields and test with a known seller-authorized resource.
Invalid parameter	Field names or types differ from the selected API version.	Copy the request schema from the exact regional API reference and include its version field when required.
Intermittent network failures	Transient connectivity or upstream service issue.	Use bounded retries with backoff, timeouts and a dead-letter queue for exhausted requests.

Performance and cost planning

Temu’s cited documentation does not provide a universal latency benchmark or a single public price for API calls. Size your system from the seller count, endpoint limits, page size and sync frequency in your account terms. Incremental synchronization is usually cheaper operationally than repeatedly loading full catalogs: store a checkpoint, request only changed records when the endpoint supports it, and back off when no changes are found.

Cache immutable product metadata carefully, but treat price, inventory and order status as time-sensitive. Use a queue to smooth bursts and cap concurrency per region. If a request fails before a response is received, retry according to the endpoint’s rules and reconcile results rather than assuming the operation completed.

Why browser scraping is a poor fallback

Consumer pages can change markup, require interactive consent, trigger bot controls and expose data that your account is not authorized to reuse. More importantly, the consumer terms explicitly prohibit automated crawling and scraping and restrict commercial use of service information. A narrow systemic-risk research exception in one EU terms variant is not a general commercial scraping license. For a seller integration, obtain authorization and use the documented API.

Or skip the browser setup

If your actual task is to capture a visual record of a Temu page for QA, documentation or an internal workflow, ScreenshotNeo provides a one-call website screenshot API. It is separate from Temu’s Partner Platform API and does not grant permission to collect or commercially reuse Temu data.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

See the ScreenshotNeo API documentation for options. Cookie banners, newsletter popups and chat widgets are removed before capture. Bot checks, blank pages and failed loads are not billed, and response headers identify the page verdict and billing status. An MCP server provides take_screenshot, get_page_info and capture_pdf tools for Claude, Cursor and other MCP clients. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.

FAQ

Does Temu have a public product API?

Temu has an official Partner Platform API for authorized users. Access is permissioned and is not the same as an unrestricted public catalog API.

Can I call the Temu API with GET?

The current endpoint guide says API interaction supports POST. Send the documented parameters in a POST request.

Which endpoint should a European seller use?

Use https://openapi-b-eu.temu.com/openapi/router, subject to the endpoint’s documented regional availability and your app permissions.

How close must my server clock be?

The cited product-attributes reference requires the ten-digit Unix timestamp to be within 300 seconds before or after current time.

Can an ISV access every seller’s data with one token?

No. Sellers authorize apps and select permission scopes. Keep each seller’s token and data scope isolated.

Is a screenshot of a Temu page the same as API access?

No. A screenshot captures rendered pixels; it does not provide structured product, inventory, order or logistics records and does not override Temu’s terms.