# Shopee Scraper - Product Data, Prices & Discounts, 11 Markets (`lergassy/shopee-scraper`) Actor

Shopee scraper and API alternative for all 11 marketplaces: price, discount, rating, full product pages with description, specs and variants, shop product lists, seller profiles and customer reviews with photos. Indonesia, Vietnam, Thailand, Brazil and more. No browser or login.

- **URL**: https://apify.com/lergassy/shopee-scraper.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** E-commerce, Automation, AI
- **Features:** Limited permissions
- **Stats:** 1,186 total users, 375 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.28 / 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

**Shopee Scraper** is an unofficial **Shopee API** for **Shopee product data**: it scrapes public listings from all **11 Shopee marketplaces** — Indonesia, Singapore, Malaysia, Philippines, Thailand, Vietnam, Taiwan, Brazil, Mexico, Colombia and Chile — without the official API and **without running a browser**. Get product cards with **price, original price, discount, rating, shop name and rating, seller city and promo labels** from any keyword search, category or shop, the **full product page: description, brand, specifications, variants, gallery and video**, a shop's **product list and seller profile (followers, chat response rate, join date, rating split)**, and **customer reviews with text, photos and seller replies**. Costs **$0.40 per 1,000 products or reviews** ($0.70 per 1,000 full product pages) until 21 November 2026, then from $1.00 per 1,000 products and $3.20 per 1,000 full pages (see Pricing). No charge for error rows. No login, no API key, no Shopee developer account.

Use it as a **Shopee product scraper** for price monitoring and price comparison across countries, or as a **Shopee data** feed for market research. Export to JSON, CSV or Excel, call it from the API, schedule runs, or plug it into n8n, Make, Zapier, Google Sheets or an AI agent through MCP.

### Who this is not for

Said up front so you do not pay to find out:

- **Stock levels and units sold.** Shopee serves neither to a visitor who is not logged in — not on search cards, not on shop pages, not on product pages, and its product API refuses the request (re-checked on Singapore and Indonesia, 22 October 2026). So there is no `minSold` filter and no stock field.
- **Prices converted to your currency.** Every price stays in the marketplace's own currency. Comparing `price` across countries without converting it yourself will give you nonsense.
- **Anything behind a login.** Vouchers, member prices, chat with the seller, order history. This Actor never logs in with anyone's account.
- **Buying or ordering.** It reads the catalogue; it does not place orders.

If what you need is products, prices, ratings and seller reputation across Shopee's Southeast Asian marketplaces — that is exactly what this is.

### Tested head-to-head — 24 September 2026

![Shopee Scraper tested against the 6 most-used Shopee scrapers: lowest price per 1,000 products, no start fee, lowest failure rate](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/benchmarks/shopee-tested-2026-09-24.png)

Same search for every Actor — 20 products for "iphone 15" on Shopee Indonesia — run against the six
most-used Shopee scrapers on the Apify Store, from an ordinary paying account. All seven returned 20 products. Prices below are as measured on that day; our price has since dropped to $0.40 per 1,000 products (from 19 October 2026).

| | This Actor | The six others |
|---|---|---|
| Price per 1,000 products | **$4** (now **$0.40**) | $5–20 |
| Start fee per run | **None** | 5 of 6 charge one (up to $0.05) |
| Cost of this 20-product run | **$0.08** (now **$0.008**) | $0.10–0.42 |
| Failed runs, last 30 days (Store stats) | **0.1%** | 0.2–9.0% |

### What is Shopee Scraper?

Shopee is the largest e-commerce marketplace in Southeast Asia and one of the fastest growing in Latin America. It has no public product API, and in mid-2026 Shopee moved every product page to a client-rendered app whose internal API is guarded by a JavaScript-signed token. Because of that, most Shopee scrapers today return only what a product card shows and report description, brand and gallery as "browser only".

This Actor takes the other route: it reads the **server-rendered version of the page** that Shopee returns to crawlers. Listing pages carry the full product card — title, price, original price, discount, rating, shipping location and badges — over plain HTTP, with no browser and no token, so a run of 40 products costs a fraction of a cent and finishes in under a minute.

| Mode | What you get | Input |
|---|---|---|
| 🔍 **Products from search** | Product cards: title, price, original price, discount %, rating, shipping location, badges, image, position | keywords, search URLs, category URLs |
| 📦 **Product details** | Category path, gallery size and, when Shopee serves its structured record, description, brand, price, availability, rating count and the seller with rating and response rate | product URLs or `shopId/itemId` |
| 🏪 **Shop** | Shop profile (name, username, rating, rating count, product count, logo) and the products on its page | shop URL or username |

Every row carries `country`, `marketplace`, `currency`, `shopId` and `itemId`, so a single dataset can hold several countries at once.

### Supported Shopee marketplaces

| Country | Code | Domain | Currency |
|---|---|---|---|
| 🇮🇩 Indonesia | `ID` | shopee.co.id | IDR |
| 🇸🇬 Singapore | `SG` | shopee.sg | SGD |
| 🇲🇾 Malaysia | `MY` | shopee.com.my | MYR |
| 🇵🇭 Philippines | `PH` | shopee.ph | PHP |
| 🇹🇭 Thailand | `TH` | shopee.co.th | THB |
| 🇻🇳 Vietnam | `VN` | shopee.vn | VND |
| 🇹🇼 Taiwan | `TW` | shopee.tw | TWD |
| 🇧🇷 Brazil | `BR` | shopee.com.br | BRL |
| 🇲🇽 Mexico | `MX` | shopee.com.mx | MXN |
| 🇨🇴 Colombia | `CO` | shopee.com.co | COP |
| 🇨🇱 Chile | `CL` | shopee.cl | CLP |

Prices are returned in the marketplace's own currency and are never converted.

### What data can Shopee Scraper extract?

#### 🔍 Product cards

| Field | Example |
|---|---|
| `title` | `Apple iPhone 15 128GB, Pink` |
| `price` / `originalPrice` / `discountPercent` | `12499000` / `14499000` / `14` |
| `currency` | `IDR` |
| `rating` / `ratingCount` | `5` / `23673` (review count: when the product page publishes it, about half of products) |
| `shopName` / `shopUsername` / `shopUrl` | `Digimap Official Shop` / `digimapofficial` / shop link |
| `shopRating` / `shopRatingCount` | `4.94` / `159597` |
| `brand` / `priceMin` / `priceMax` | `Apple` / `15499000` / `16999000` (variant price range, when published) |
| `location` | `Jakarta Barat` |
| `labels` | `["Murah Mantap", "Garansi Harga Terbaik"]` |
| `shopId` / `itemId` | `241308147` / `22982495280` |
| `url` / `imageUrl` | product link, main picture |
| `position` / `page` / `searchTerm` | `1` / `0` / `iphone 15` |
| `country` / `marketplace` | `ID` / `Indonesia` |

Shop name and shop rating come from each shop's own page, review count, brand and price range from the product page — one extra request per card, **no extra charge**, on by default (`includeShopAndReviews`; turn it off for the fastest runs).

#### 📦 Product details

When Shopee serves the structured product record for a page, the row carries `description` (the full seller description, thousands of characters), `brand`, `price`, `originalPrice`, `availability`, `condition`, `rating`, `ratingCount`, `images`, `imageCount`, `breadcrumb`, `categoryPath` and a `seller` object with `name`, `username`, `url`, `logo`, `rating`, `ratingCount`, `productCount`, `chatResponse` and `location`.

A full product row carries `description`, `brand`, `attributes` (the specification table), `variations` and `variants` (every sellable combination with its image), `images`, `videos`, `categories`, `createdAt` and the `seller` profile. Shopee hides the price on the product page from visitors who are not logged in, so `price`, `originalPrice`, `discountPercent` and `rating` come from the product's search card (`priceSource: "search-card"`). If the product cannot be found in search under its own title, the row has everything except the price, carries a `note`, and is billed as a search card, not as a full product page. On the Apify Free plan a run reads up to 10 full product pages; further rows carry the search card's fields and are billed as cards. If the product page itself does not come, the row is rebuilt from the card, also billed as a card; if even that fails it comes back free with `partial: true`.

#### 🏪 Shops

`name`, `username`, `url`, `rating`, `ratingCount`, `productCount`, `logo`, `country`, plus the products listed on the shop page as normal product rows.

### How much does it cost to scrape Shopee?

The Actor uses Apify's **pay-per-event** pricing, so you pay for results and nothing per page or per proxy gigabyte. Error rows are never charged.

| Event | Price | Per 1,000 |
|---|---|---|
| Product (search card, category, shop) | $0.0004 | **$0.40** |
| Product detail (product page) | $0.0007 | **$0.70** |

**From 21 November 2026** (Free plan price; paid Apify plans pay less, down to the last figure):

| What | Per 1,000 | On the highest paid plan |
|---|---|---|
| Product card | **$1.00** | $0.28 |
| Full product page | **$3.20** | $2.50 |
| Customer review | **$2.80** | $2.50 |
| Run start | $0.005 per run | $0.005 |

Because no browser is involved, a run of 40 products finishes in well under a minute and costs a fraction of a cent in platform usage. The **Apify Free plan** ($5 monthly credit) is enough for roughly 12,500 product cards or 7,100 full product records every month. Bronze, Silver and Gold Store tiers get a discount on top.

#### Bulk export: what 50,000 products actually cost

This Actor is built for bulk jobs — put hundreds of inputs into one run, or call it from the API on
a schedule. There is **no fee per run, no fee per page and no proxy charge**: you pay for the rows
you keep, and error rows are free. That is what decides the bill once you pull a whole market
rather than a single store.

| Job | This Actor | Most-used Actor in this category |
|---|---|---|
| 50,000 products across 100 runs | **$20** | $425.01 |

Our price is the current one (from 19 October 2026); the competitor's was checked on the Apify Store on 24 September 2026 against the Actor with the most monthly users in
this category; its per-run fee is counted in, as ours would be if we charged one. Some Actors here
ask less per row — this table compares against the one buyers actually use most.

### How to scrape Shopee

1. Open **Shopee Scraper** on Apify and click **Try for free**.
2. Choose **What to scrape** — for example *Products from search*.
3. Pick the **Country** (Indonesia by default).
4. Enter **Search keywords**, or paste **Shopee URLs**: product links, search results, category pages or shops. Links from different countries can be mixed in one run.
5. Set **Max products**, optionally turn on **Fetch full product details**, and click **Start**.
6. Open the **Output** tab and download the dataset as JSON, CSV, Excel or XML, or read it through the API.

### ⬇️ Input

![Shopee Scraper input form: mode, country, search keywords, Shopee URLs, max products, sorting](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/shopee/shopee-scraper-input-form.png)

Search Indonesia for two keywords, best selling first:

```json
{
  "mode": "search",
  "country": "ID",
  "searchTerms": ["iphone 15", "samsung s24"],
  "sortBy": "sales",
  "maxItems": 200
}
```

Full detail for specific products (any country, product URL or `/product/shopId/itemId`):

```json
{
  "mode": "product",
  "startUrls": [
    "https://shopee.co.id/Apple-iPhone-15-256GB-Pink-i.241308147.23982497018",
    "https://shopee.com.br/product/1163374404/24096063243"
  ]
}
```

A category page in Vietnam and a shop in Singapore in one run:

```json
{
  "startUrls": [
    "https://shopee.vn/Điện-Thoại-cat.84",
    "https://shopee.sg/shopeeofficial"
  ],
  "maxItems": 100
}
```

Search plus enrichment, where every card is opened for its full record:

```json
{
  "country": "MY",
  "searchTerms": ["air fryer"],
  "maxItems": 50,
  "enrichProducts": true
}
```

#### Filters

Filters apply to keyword searches, pasted search URLs and category pages (a category page is read through Shopee's search for that category, because the category page itself ignores filters). Product and shop links are returned as they are.

Most filters are **Shopee's own search filters**: they go to Shopee with the search, Shopee returns only matching products, and nothing extra is read or charged. A few are **checked on each card after download**: products that fail are dropped and **not charged**, and the run reads further pages to fill `maxItems`. When the after-download checks leave few matches, a search stops once it has read 3 or more pages averaging fewer than 3 matching products per page, and says so in the log; if nothing matched at all you get one free `notice` row explaining which filters were applied.

| Input | What it keeps | How it is applied |
|---|---|---|
| `sortBy` | `relevancy`, `sales` (best selling), `latest`, `price_asc`, `price_desc` | Shopee |
| `minPrice` / `maxPrice` | price range in the marketplace currency | Shopee, then the price shown on each card is checked |
| `minRating` | rating at least this (0–5) | Shopee (whole stars), then exact value checked on each card |
| `officialShopOnly` | Shopee Mall stores | Shopee |
| `preferredSellerOnly` | Preferred / Preferred+ sellers (Star / Star+ in Indonesia) | Shopee |
| `freeShippingOnly` | free shipping | Shopee |
| `codAvailableOnly` | cash on delivery | Shopee |
| `discountedOnly` | discounted right now | Shopee, then the discount is checked on each card |
| `withVideoOnly` | products with a video | Shopee |
| `condition` | `new` or `used` | Shopee |
| `shippedFrom` | a location from Shopee's "Shipped From" list, e.g. `DKI Jakarta`, `Jabodetabek`, `Singapore`, `Mainland China` | Shopee; an unknown name skips that search with a free notice listing the valid ones |
| `brand` | one brand, e.g. `Spigen` | Shopee's brand filter when it lists the brand for your search; otherwise the brand name is matched in the title (after download) |

Filters combine the way they do on Shopee: Mall and Preferred together mean "Mall **or** Preferred" (they are one "shop type" group on Shopee), everything else must all match.

```json
{
  "country": "SG",
  "searchTerms": ["iphone 15 case"],
  "officialShopOnly": true,
  "discountedOnly": true,
  "brand": "Spigen",
  "maxItems": 40
}
```

**Stock and units sold.** Shopee blanks them on search cards and product pages for visitors who are not logged in, and its search API refuses requests without a signed app token (re-checked November 2026). The one exception is the product Shopee features on each shop page: for that product the row also carries `soldTotal`, `soldRecent`, `soldDisplay`, `favorites` and `reviewCount`. There is no `minSold` filter, and this Actor never logs in with anyone's account.

### ⬆️ Output

![Shopee Scraper output table: product, price, previous price, discount, rating, shipping location, country, item ID](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/shopee/shopee-scraper-output-table.png)

One product card:

```json
{
  "type": "product",
  "title": "Apple iPhone 15 128GB, Pink",
  "url": "https://shopee.co.id/Apple-iPhone-15-128GB-Pink-i.241308147.22982495280",
  "shopId": "241308147",
  "itemId": "22982495280",
  "country": "ID",
  "marketplace": "Indonesia",
  "currency": "IDR",
  "price": 12499000,
  "originalPrice": 14499000,
  "discountPercent": 14,
  "rating": 4.9,
  "location": "Jakarta Barat",
  "labels": ["Garansi Harga Terbaik"],
  "imageUrl": "https://down-id.img.susercontent.com/file/id-11134207-7ra0n-mdr868y1rkmn6a",
  "position": 1,
  "searchTerm": "iphone 15",
  "scrapedAt": "2026-09-03T06:28:11.026Z"
}
```

One product detail (description shortened here):

```json
{
  "type": "product_detail",
  "itemId": "23982497018",
  "shopId": "241308147",
  "title": "Apple iPhone 15 256GB, Pink",
  "brand": "Apple",
  "description": "iPhone 15 menghadirkan Dynamic Island, kamera Utama 48 MP, dan USB-C …",
  "currency": "IDR",
  "price": 14749000,
  "originalPrice": 17499000,
  "discountPercent": 16,
  "availability": "InStock",
  "condition": "NewCondition",
  "rating": 4.95,
  "ratingCount": 701,
  "imageCount": 11,
  "breadcrumb": ["Shopee", "Handphone & Aksesoris", "Handphone", "Apple", "Apple iPhone 15 256GB, Pink"],
  "seller": {
    "name": "iBox Official Shop",
    "username": "iboxofficial",
    "rating": 4.94,
    "ratingCount": 442537,
    "chatResponse": 100,
    "location": "KOTA JAKARTA BARAT"
  }
}
```

Rows carry a `type` (`product`, `product_detail`, `shop`, `error`), so one dataset can be filtered in a spreadsheet or in code. Pages that fail are written as `error` rows with the URL and the reason instead of disappearing silently.

### Use cases for Shopee data

#### Price monitoring and repricing

Track `price`, `originalPrice` and `discountPercent` for your own listings and your competitors' on a daily schedule, and feed the dataset into Sheets or your repricing tool.

#### Market research in Southeast Asia

Search a category across Indonesia, Vietnam, Thailand and the Philippines in one run and compare price levels, discount depth and ratings per market.

#### Product research and sourcing

Rating counts and discount depth show what actually moves. Full product detail adds the description and brand, so you can shortlist suppliers before contacting them.

#### Seller and shop intelligence

Shop mode returns the seller profile (rating and rating split, followers, chat response rate and time, join date, product count, description) and then the shop's products, up to `maxItems`. Shopee serves 40 products per request and does not page them, so the Actor goes deeper by asking in each sort order and then for the words in the titles it found: large shops usually return a few hundred products, not the whole catalog.

#### Catalog enrichment

Description, brand, breadcrumb and the image gallery are enough to build product pages or enrich an existing catalog.

#### AI agents and RAG

Flat rows, literal field names and only optional inputs make this Actor easy to call from an agent through the Apify MCP server.

### Integrations

- **API** — start a run and read the dataset with any HTTP client:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("lergassy/shopee-scraper").call(run_input={
    "country": "ID", "searchTerms": ["air fryer"], "maxItems": 100
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["currency"])
```

- **JavaScript** — `npm i apify-client`, then `client.actor('lergassy/shopee-scraper').call(input)`.
- **n8n, Make, Zapier, Google Sheets, Airtable, Slack, webhooks** — through the standard Apify integrations.
- **MCP** — add the Apify MCP server to Claude, ChatGPT or Cursor and let the agent call `lergassy/shopee-scraper` with a keyword and a country.

### Errors and troubleshooting

| What you see | What it means | Fix |
|---|---|---|
| `priceSource: "search-card"` on a product row | Shopee publishes no full record for that product; price, rating and seller came from its search card | Nothing to fix — `description` and `brand` are simply not published for it |
| `partial: true` on a product row | Neither the product record nor its search card could be read | Re-run the URL; the row was not charged |
| One `notice` row and nothing else | **Product details** or **Shop** mode was chosen with keywords but no Shopee links — those modes read links only | Paste product or shop links, or switch **What to scrape** to **Products from search**; the run was not charged |
| `error` rows for some URLs | The page stayed unavailable after retries | Re-run those URLs; the Actor rotates proxies and usually succeeds on a second attempt |
| `rating` is null on a category page | Category cards omit the star rating | Enable enrichment, or scrape the same product by URL |
| Fewer results than **Max products** | Shopee returns about 40 cards per search page and repeats items across pages | Use several narrower keywords, or a category URL |
| Empty result for a shop | The shop page shows only its featured products | Paste the shop's listing URL, or search with the shop name |

### 🤖 For AI Agents & LLM Apps

Compact reference for agents calling this Actor through the [Apify MCP server](https://mcp.apify.com) or the Apify API (`lergassy/shopee-scraper`).

**Purpose:** returns Shopee listings across eleven South-East Asian and Latin
American marketplaces — by search term, by shop or by product URL — with price,
discount, rating and seller location. Use it to answer "what does this
product cost in Indonesia right now", "who are the top sellers for this query" and
"how did this listing's price move".

**Minimal input:**

```json
{ "searchTerms": ["iphone 15"], "country": "ID", "maxItems": 40 }
```

**Output:** one row per listing — `type`, `partial`, `itemId`, `shopId`, `title`,
`url`, `country`, `marketplace`, `currency`, `price`, `originalPrice`,
`discountPercent`, `rating`, `location`, `imageUrl`,
`categoryPath`, `scrapedAt`. With `enrichProducts` on, rows also carry `brand`, `description`, `attributes`,
`variations`, `variants`, `images`, `videos`, `categories`, `createdAt` and a `seller` object.
Pages that could not be read arrive as `type: "error"` rows with `error` and `kind`
rather than being dropped silently.

**Behaviors an agent should know:**

- `mode` defaults to `auto`: search terms trigger search mode, URLs trigger product
  or shop mode. Set it explicitly only to override that.
- `country` selects the marketplace and therefore the currency. Prices are always in
  the marketplace's own currency — never compare `price` across countries without
  converting.
- `maxItems` (default 40) caps rows per search term. `enrichProducts` costs one extra
  page fetch per product, so leave it off when the listing fields are enough.
- Rows with `partial: true` carry only what search results expose. That is not an
  error; it is the cheap path.
- Anti-bot pressure is real on Shopee: a run may return `error` rows for some pages
  while succeeding on the rest. Check `type` before treating the dataset as complete.

### ❓ FAQ

#### Is it legal to scrape Shopee?

The Actor reads only pages that Shopee publishes to anyone, including the version it serves to search-engine and social-media crawlers. It does not log in, does not touch buyer accounts and collects no personal data. You remain responsible for using the data in line with local law and Shopee's terms; consult a lawyer for your specific case.

#### Do I need a Shopee API key or an account?

No. Shopee has no public product API, and this Actor never authenticates.

#### Does it use a browser?

No. That is why it is fast and cheap. Everything is plain HTTP against the server-rendered pages.

#### Why is product detail sometimes partial?

Shopee guards its internal API with a JavaScript-signed token and sometimes refuses a product page. The crawler version of the page leaves the structured product record out for some products — the same products every time. The Actor then finds the product's search card in its own shop and returns price, discount, rating and seller from there (`priceSource: "search-card"`). Only when that fails too does a row come back with `partial: true`, free of charge.

#### Can I scrape several countries in one run?

Yes. Keyword searches use the selected country, and every URL keeps its own marketplace. Each row records `country`, `marketplace` and `currency`.

#### How many products can one search return?

Shopee serves about 40 cards per search page and reshuffles results between pages, so a single keyword realistically yields a few hundred unique products. Category URLs and several narrower keywords go deeper.

#### Does it return customer reviews?

Yes. Choose **Customer reviews** in "What to scrape" and paste shop or product links. Each row has the review text, stars, sub-ratings for product, seller and delivery, the variant bought, photos, videos, the reviewer's masked name, date and the seller's reply. Reviews come per shop, newest first; a product link reads the shop's latest reviews and keeps that product's. Filter with `starRatings`, `reviewsSince`, `onlyWithText` and `onlyWithMedia`, cap with `maxReviews`. A review costs the same as a product card.

#### Can I get per-variant prices and stock?

Shopee does not expose per-variant data on the crawler page. You get the product price, the original price, the discount and availability.

#### Can I use it with the Apify API, MCP or n8n?

Yes, see Integrations. The input is plain JSON and `startUrls` accepts product, search, category and shop links.

### Run health

When a run ends with many error rows, the Actor sends its developer the counts (rows delivered, error types, run ID) so the cause gets fixed fast; your input and results are never sent.

### Your feedback

Missing a field, a country or a page type? Open an issue in the **Issues** tab or leave a review — user requests decide what ships next.

### You might also like

| Actor | What it does |
|---|---|
| [Tokopedia Reviews Scraper](https://apify.com/lergassy/tokopedia-reviews-scraper) | Shop reviews from Indonesia's Tokopedia |
| Mercado Libre Scraper | Products, prices, reviews and deals across 18 Latin American marketplaces |
| [Agoda Reviews Scraper](https://apify.com/lergassy/agoda-reviews-scraper) | Hotel reviews from Agoda and Booking.com |
| [Google Flights Scraper](https://apify.com/lergassy/google-flights-scraper) | Flight prices, airlines and price insights |
| [Email Verifier & Phone Number Validator](https://apify.com/lergassy/email-phone-verifier) | Checks e-mails and phone numbers in bulk: deliverability, throwaway and role flags, numbering plan, US state and time zone |

# Changelog

This Actor's version history is a separate document: https://apify.com/lergassy/shopee-scraper/changelog.md

# Actor input Schema

## `mode` (type: `string`):

Choose the data type. <b>Products from search</b> – product cards from keyword search, category or listing URLs. <b>Product details</b> – full product pages with description, brand, gallery and seller. <b>Shop</b> – shop profile and its products. <b>Auto</b> decides by the URL you paste. <b>Customer reviews</b> – review text, stars, photos and seller replies for shop or product links.

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

Shopee marketplace for keyword searches. URLs keep their own country.

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

Products to search for, one per line, e.g. <code>iphone 15</code>. Each keyword is searched in the selected marketplace.

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

Any Shopee links: product pages (<code>.../Name-i.123.456</code>), search results, category pages (<code>...-cat.11044458</code>) or shops (<code>shopee.co.id/shopname</code>).

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

Stop after this many products per keyword or URL.

## `enrichProducts` (type: `boolean`):

Open each product page for description, brand, image gallery, category path and seller reputation. Slower and billed per product detail.

## `includeShopAndReviews` (type: `boolean`):

Search results: add the seller's shop name and rating, the product's review count, brand and price range to every card. Read from each product's page — one extra request per card, no extra charge. Turn off for the fastest possible runs.

## `sortBy` (type: `string`):

Order of search results.

## `minPrice` (type: `integer`):

Minimum price in the marketplace's own currency. Sent to Shopee and checked against the price on each card.

## `maxPrice` (type: `integer`):

Maximum price in the marketplace's own currency. Sent to Shopee and checked against the price on each card.

## `minRating` (type: `number`):

Keep only products rated at least this (0–5 stars). Shopee's rating filter narrows the search first; the exact value is then checked on each card, and products without a rating are dropped. Dropped products are not charged.

## `officialShopOnly` (type: `boolean`):

Only products from Shopee Mall (official brand stores). Shopee's own filter.

## `preferredSellerOnly` (type: `boolean`):

Only products from Shopee Preferred and Preferred+ sellers (called Star and Star+ in Indonesia). Shopee's own filter.

## `freeShippingOnly` (type: `boolean`):

Only products Shopee marks as free shipping. Shopee's own filter.

## `codAvailableOnly` (type: `boolean`):

Only products that can be paid on delivery (COD). Shopee's own filter.

## `discountedOnly` (type: `boolean`):

Only products with a discount right now. Shopee's own filter, then checked on each card (the card must show an original price or a discount).

## `withVideoOnly` (type: `boolean`):

Only products that have a product video. Shopee's own filter.

## `condition` (type: `string`):

New or used items. Shopee's own filter.

## `shippedFrom` (type: `string`):

A location from Shopee's "Shipped From" filter, as Shopee writes it: e.g. <code>DKI Jakarta</code>, <code>Jawa Barat</code>, <code>Jabodetabek</code> (Indonesia), <code>Singapore</code> or <code>Mainland China</code> (Singapore). If the name is not in Shopee's list for your search, that search is skipped with a free notice listing the valid names.

## `brand` (type: `string`):

A brand name, e.g. <code>Spigen</code>. When Shopee's brand filter lists it for your search, Shopee filters by it; otherwise only products with the brand in their title are kept (checked after download, dropped products not charged).

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

Reviews mode only. How many reviews to keep for each shop or product link, newest first.

## `starRatings` (type: `array`):

Reviews mode only. Keep only these star ratings. Leave empty for all.

## `reviewsSince` (type: `string`):

Reviews mode only. Stop at reviews older than this date.

## `onlyWithText` (type: `boolean`):

Reviews mode only. Skip reviews with stars but no text.

## `onlyWithMedia` (type: `boolean`):

Reviews mode only.

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

Shopee serves pages per region. Residential proxies in the marketplace country give the most stable results.

## `maxConcurrency` (type: `integer`):

Parallel requests.

## Actor input object example

```json
{
  "mode": "auto",
  "country": "ID",
  "searchTerms": [
    "iphone 15"
  ],
  "startUrls": [],
  "maxItems": 40,
  "enrichProducts": false,
  "includeShopAndReviews": true,
  "sortBy": "relevancy",
  "officialShopOnly": false,
  "preferredSellerOnly": false,
  "freeShippingOnly": false,
  "codAvailableOnly": false,
  "discountedOnly": false,
  "withVideoOnly": false,
  "condition": "any",
  "maxReviews": 100,
  "onlyWithText": false,
  "onlyWithMedia": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 3
}
```

# Actor output Schema

## `products` (type: `string`):

One row per Shopee listing: title, price, original price and discount, currency, rating, units sold, seller location, category path and image. Enriched rows add brand, description, stock and the seller block; shop rows summarise a store.

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

JSON counters for the run: rows delivered, filtered out, errors and request statistics.

## `notAttempted` (type: `string`):

JSON list of inputs the run did not reach (time limit or "Max cost per run"). Not charged — pass them as input to a new run to continue. Present only when the run stopped early.

# 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": [
        "iphone 15"
    ],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/shopee-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": ["iphone 15"],
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("lergassy/shopee-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": [
    "iphone 15"
  ],
  "startUrls": []
}' |
apify call lergassy/shopee-scraper --silent --output-dataset

```

## MCP server setup

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