# Shein Product Scraper — Prices, Variants & Reviews (`khadinakbar/shein-product-scraper`) Actor

Scrape Shein products by keyword search, category URL, product URL, or goods ID. Returns price, variants, sizes, colors, images, rating, description, and optional reviews. Browser-based via Apify Residential proxy. MCP-ready.

- **URL**: https://apify.com/khadinakbar/shein-product-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Automation
- **Stats:** 11 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $40.00 / 1,000 product scrapeds

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/platform/actors/running/actors-in-store#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

## Shein Product Scraper — Prices, Variants & Reviews

Scrape Shein products from keyword searches, category URLs, product URLs, or goods IDs. This Apify Actor returns one record per product or listing card, with fields such as goods ID, title, brand, sale and retail price, discount percent, currency, rating, review count, stock status, colors, sizes, SKUs, images, category context, description, attributes, optional reviews, and the scraped timestamp. It is browser-based via Apify Residential proxy and usable through Apify MCP.

### Best fit and connected workflows

Use this Actor when you need structured Shein product data for one of these workflows:

- Keyword discovery from plain text search terms, such as a style, category, or product type.
- Category or search page collection when you already have a Shein listing URL.
- Single-product enrichment from a product URL or goods ID.
- Catalog snapshots for pricing, variant, and attribute analysis.
- Review capture when you want embedded review data in each product detail record.
- AI-agent retrieval through Apify MCP for downstream analysis, comparison, or extraction workflows.

### Focused standalone workflow

This Actor is designed as a focused standalone workflow.

#### Practical scenario

Maya, a merchandiser, starts with a Shein category URL for women's tops. She sets `scrapeProductDetails` to true and leaves `scrapeReviews` off. The run returns records with `goodsId`, `title`, `salePrice`, `discountPercent`, `rating`, `colors`, `sizes`, `mainImage`, and `productUrl`. Maya uses those fields to identify which items to compare in her pricing sheet, then opens the product URLs that match her target price range.

### Input fields

| Field | Type | Purpose |
|---|---|---|
| `searchQueries` | array of strings | Plain-text Shein searches such as `summer dress` or `men cargo pants`. |
| `startUrls` | array of URLs | Shein product, search, or category URLs. The input type is auto-detected. |
| `goodsIds` | array of strings | Shein numeric goods IDs resolved to product detail pages. |
| `country` | string | Storefront and matching residential proxy country: `us`, `uk`, `au`, `de`, `fr`, `es`, `it`, or `global`. |
| `maxItems` | integer | Maximum items collected per query or listing URL. Range 1 to 500. |
| `scrapeProductDetails` | boolean | When true, listing results are enriched into full product detail records. |
| `scrapeReviews` | boolean | When true, embedded customer reviews are included in product detail records. |
| `maxReviews` | integer | Maximum reviews embedded per product when review scraping is enabled. |
| `proxyConfiguration` | object | Proxy settings for the run. |

#### Valid focused JSON input example

```json
{
  "searchQueries": ["summer dress"],
  "country": "us",
  "maxItems": 5,
  "scrapeProductDetails": true,
  "scrapeReviews": false
}
```

### Output fields

| Field | Description |
|---|---|
| `_type` | Record type such as `product`, `search_result`, or `diagnostic`. |
| `goodsId` | Shein internal numeric goods ID. |
| `goodsSn` | Shein product SKU code. |
| `productUrl` | Canonical Shein product page URL. |
| `title` | Product name. |
| `brand` | Brand or store name. |
| `salePrice` | Current selling price as a number. |
| `salePriceText` | Current price as shown on Shein. |
| `retailPrice` | Original or list price as a number. |
| `retailPriceText` | Original price as shown on Shein. |
| `discountPercent` | Discount percentage off retail price. |
| `currency` | ISO currency code for the selected storefront. |
| `rating` | Average customer rating from 0 to 5. |
| `reviewCount` | Number of reviews. |
| `inStock` | Stock status. |
| `color` | Selected or primary color name. |
| `colors` | Available color names. |
| `sizes` | Available size names. |
| `skus` | SKU variants with size, code, price, and stock. |
| `mainImage` | Primary product image URL. |
| `images` | All product image URLs. |
| `category` | Leaf category name. |
| `categoryId` | Shein category ID. |
| `breadcrumbs` | Category breadcrumb trail. |
| `description` | Product description text. |
| `attributes` | Key-value product attributes. |
| `mallCode` | Shein mall code for the product. |
| `reviews` | Embedded reviews when enabled. |
| `country` | Storefront country code used for the run. |
| `scrapeSource` | Source of the extracted record, such as `listing` or `bff`. |
| `scrapedAt` | ISO 8601 scrape timestamp. |

#### Illustrative output record

```json
{
  "_type": "product",
  "goodsId": "100123456",
  "productUrl": "https://us.shein.com/sample-product-p-100123456.html",
  "title": "Sample Dress",
  "brand": "SHEIN",
  "salePrice": 18.99,
  "salePriceText": "$18.99",
  "retailPrice": 29.99,
  "retailPriceText": "$29.99",
  "discountPercent": 36.7,
  "currency": "USD",
  "rating": 4.6,
  "reviewCount": 128,
  "inStock": true,
  "color": "Black",
  "colors": ["Black", "White"],
  "sizes": ["S", "M", "L"],
  "mainImage": "https://img.shein.com/sample.jpg",
  "category": "Dresses",
  "country": "us",
  "scrapeSource": "bff",
  "scrapedAt": "2026-07-27T12:00:00.000Z"
}
```

### How it works

This Actor runs in a real browser and uses Apify Residential proxy matched to the selected storefront country. The input is auto-detected from keyword searches, Shein URLs, or goods IDs. For search and category inputs, it can return either lightweight listing cards or full product detail records, depending on `scrapeProductDetails`. When `scrapeReviews` is enabled, it embeds up to `maxReviews` customer reviews in each product detail record. Product URLs and goods IDs always resolve to full product detail records.

### Pricing

This Actor uses Pay per event pricing plus standard Apify platform usage. The live Pricing tab in Apify shows the current event prices and any platform usage that applies to your run.

Event billing is based on the records produced:

- Actor start
- Product scraped
- Search result

For example, a run that returns twenty full product detail records is billed as twenty Product scraped events, plus one Actor start event. A run that returns twenty listing cards with `scrapeProductDetails=false` is billed as twenty Search result events, plus one Actor start event.

Please check the live Pricing tab for the current pricing details before running.

### Use with AI agents (MCP)

This Actor is available through Apify MCP as a tool for retrieving Shein product data in structured form.

Tool description: use this Actor to search Shein by keyword, listing URL, product URL, or goods ID and receive product or listing-card records with prices, variants, images, ratings, and optional reviews.

Exact Actor identity: `khadinakbar/shein-product-scraper`

> Find Shein products for the keyword "summer dress" in the US storefront. Return the product title, price, rating, sizes, colors, and canonical product URL.

When used through MCP, the output should be interpreted as dataset records. Product detail records include rich catalog fields, while search-result records include a lighter listing-card subset when `scrapeProductDetails=false`. Each record is provenance-tagged with `scrapeSource`, `country`, and `scrapedAt`. If the input targets a search or category page, pagination is handled by the Actor up to `maxItems`. Costs still follow the same event-based pricing, so agent workflows should keep `maxItems` and `maxReviews` aligned with the amount of detail needed.

### Apify API example

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
    token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/shein-product-scraper').call({
    searchQueries: ['summer dress'],
    country: 'us',
    maxItems: 3,
    scrapeProductDetails: true,
    scrapeReviews: false,
});

const datasetItems = await client.dataset(run.defaultDatasetId).listItems();
console.log(datasetItems.items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(token=os.environ["APIFY_TOKEN"])

run = client.actor("khadinakbar/shein-product-scraper").call(run_input={
    "goodsIds": ["100123456"],
    "country": "us",
    "scrapeReviews": True,
    "maxReviews": 10
})

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(items)
```

### Best results and outcome guidance

Use the narrowest input that matches your source:

- `goodsIds` for direct product lookup.
- `startUrls` with a product URL for one exact item.
- `startUrls` with a search or category URL for a product list.
- `searchQueries` for discovery from plain text.

Choose the storefront country that matches the market you want to inspect, because it drives localized pricing and currency. Use `scrapeProductDetails=true` when you need variants, SKUs, images, description, and attributes. Use `scrapeReviews=true` when review content is part of the workflow, and keep `maxReviews` aligned with the number of reviews you actually need.

### Design note

I found that the live dataset contract requires `scrapedAt` on every output record, which makes the timestamp a reliable anchor for downstream syncing and change tracking.

### FAQ

#### Which input should I use for a single product page?

Use `startUrls` with the product URL, or `goodsIds` if you already have the numeric Shein goods ID.

#### Which input should I use for search exploration?

Use `searchQueries` for plain-text discovery, or `startUrls` for an exact Shein search or category page.

#### What happens when I want only listing cards?

Set `scrapeProductDetails=false`. The Actor returns lighter search-result records with fields such as goods ID, title, price, image, and rating.

#### Can I include customer reviews?

Yes. Set `scrapeReviews=true` and choose a `maxReviews` value. Reviews are embedded inside each product detail record.

#### Which storefronts are available?

The input supports `us`, `uk`, `au`, `de`, `fr`, `es`, `it`, and `global`.

### Responsible use

Use this Actor only for lawful collection and analysis of publicly available Shein product data. Review your intended use against Shein's terms and any applicable data, privacy, and copyright obligations in your jurisdiction. Keep request volume, review depth, and pagination aligned with your actual business need.

# Actor input Schema

## `searchQueries` (type: `array`):

Free-text keywords searched on Shein, one product list per query (e.g. 'summer dress', 'men hoodie'). Each query opens Shein's pdsearch page and collects product cards up to maxItems. Leave empty if you are passing startUrls or goodsIds instead. NOT a URL — put Shein URLs in startUrls.

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

Shein URLs to scrape — product pages (…-p-1234567.html), search pages (/pdsearch/…), or category pages. The URL type is auto-detected: product URLs return one detail record each; search/category URLs return product lists up to maxItems. Use the exact domain you want (e.g. https://us.shein.com/…). NOT for keywords — use searchQueries for plain text.

## `goodsIds` (type: `array`):

Shein numeric goods IDs (the digits in a product URL after '-p-', e.g. '100123456'). Each ID is resolved to a product detail page in the selected country. Use this when you already have IDs and want the fastest detail path. NOT a SKU or barcode — it is Shein's internal goods\_id.

## `country` (type: `string`):

Shein storefront and matching residential proxy country, which drives currency and localized pricing (e.g. 'us' → us.shein.com in USD). Pick the market whose prices you want. Defaults to 'us'. Does NOT translate product text — Shein localizes server-side per storefront.

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

Maximum number of products collected per search query or listing URL (paginating as needed). Product-URL and goodsId inputs always return one record each and ignore this cap. Range 1–500, default 20. Keep it low for fast, cheap test runs.

## `scrapeProductDetails` (type: `boolean`):

When true, every product found via search/category is opened and enriched with full detail (variants, SKUs, all images, description, attributes) and billed as a product. When false, only the lightweight listing card (title, price, image, rating) is returned and billed as a cheaper search-result. Product-URL and goodsId inputs are always full detail. Default true.

## `scrapeReviews` (type: `boolean`):

When true, up to maxReviews customer reviews (rating, text, size/color bought, fit) are embedded in each product detail record. Adds extra page work and time but no separate charge. Ignored for listing-only items (scrapeProductDetails=false). Default false.

## `maxReviews` (type: `integer`):

Maximum number of reviews embedded per product when scrapeReviews is true. Reviews are the most recent first. Range 1–100, default 10. Has no effect when scrapeReviews is false.

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

Proxy settings. Shein blocks datacenter IPs, so the actor uses a residential proxy server-side (DataImpulse, matched to the storefront country) regardless of this setting. Only override if you want to force a specific Apify proxy and have residential access. Leave as default otherwise.

## Actor input object example

```json
{
  "searchQueries": [
    "summer dress",
    "men cargo pants"
  ],
  "startUrls": [
    {
      "url": "https://us.shein.com/x-p-100123456.html"
    }
  ],
  "goodsIds": [
    "100123456",
    "100654321"
  ],
  "country": "us",
  "maxItems": 1,
  "scrapeProductDetails": true,
  "scrapeReviews": false,
  "maxReviews": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped Shein products and search-result cards. Download as JSON, CSV, Excel, HTML, or RSS.

## `runSummary` (type: `string`):

End-of-run JSON with counts, charges, stop reason, and warning samples.

# 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 = {
    "searchQueries": [
        "summer dress"
    ],
    "startUrls": [],
    "goodsIds": [],
    "country": "us",
    "maxItems": 1,
    "scrapeProductDetails": false,
    "scrapeReviews": false,
    "maxReviews": 1,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/shein-product-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 = {
    "searchQueries": ["summer dress"],
    "startUrls": [],
    "goodsIds": [],
    "country": "us",
    "maxItems": 1,
    "scrapeProductDetails": False,
    "scrapeReviews": False,
    "maxReviews": 1,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/shein-product-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "summer dress"
  ],
  "startUrls": [],
  "goodsIds": [],
  "country": "us",
  "maxItems": 1,
  "scrapeProductDetails": false,
  "scrapeReviews": false,
  "maxReviews": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/shein-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=khadinakbar/shein-product-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/KmpXXf8m3zIO0WM3v/builds/hfQJdCMqEbdge7plF/openapi.json