# Shopee Official Shop Directory Scraper (`herus13/shopee-shop-scraper`) Actor

List Shopee's official shops per category across 9 storefronts (Vietnam, Indonesia, Singapore, Malaysia, Thailand, Philippines, Taiwan, Brazil, Mexico) — shop name, username, brand, logo, storefront URL. Optional per-shop analytics (followers, rating, item count). No proxy setup needed (bundled).

- **URL**: https://apify.com/herus13/shopee-shop-scraper.md
- **Developed by:** [bootforge](https://apify.com/herus13) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 91.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 shop analytics

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Shopee Official Shop Directory Scraper

The Shopee Official Shop Directory Scraper is an Apify actor that lists **official Shopee shops** for any category — shop name, username, brand, and logo — across **9 Shopee storefronts** — Vietnam, Indonesia, Singapore, Malaysia, Thailand, Philippines, Taiwan, Brazil, and Mexico. Proxy is bundled; no setup required.

Use it to build a directory of official brand stores on Shopee, monitor which brands have an official presence in a category, or feed a competitor-tracking pipeline — exported to JSON, CSV, or Excel.

### Table of contents

- [What the Shopee Shop Scraper does](#what-the-shopee-shop-scraper-does)
- [How to scrape Shopee's official shop directory](#how-to-scrape-shopees-official-shop-directory)
- [Shopee Shop Scraper input](#shopee-shop-scraper-input)
- [Shopee shop data output](#shopee-shop-data-output)
- [How much it costs](#how-much-it-costs)
- [Recommended proxies for Shopee](#recommended-proxies-for-shopee)
- [Why this Shopee Shop Scraper](#why-this-shopee-shop-scraper)
- [FAQ](#faq)
- [Rate this actor](#rate-this-actor-)
- [Related actors](#related-actors)

### What the Shopee Shop Scraper does

- 🏷️ **Official-shop directory per category** — pass one or more Shopee `category_id`s and get every official (brand-verified) shop listed there.
- 🌐 **Whole-country mode** — no category IDs? Set `discover_all: true` and the actor auto-discovers every official-shop category in the country and scrapes them all in one run.
- 📄 **Direct pagination control** — `offset`/`limit`/`max_results` are exposed on the input, so you can resume a run from an exact page.
- 🔒 **Bundled proxy** — no proxy configuration needed; the actor runs on its own residential proxy, geo-pinned to your selected country.
- ⚡ **Lightweight fetch** — one short browser session harvests a signed request/cookie set, then every page of results is a plain HTTP call — fast and cheap.
- 📊 **Optional shop analytics** — turn on `scrape_analytics` to add follower count, rating, item count, response rate/time, location, verification badges, and more per shop, for a small extra per-shop charge.

### How to scrape Shopee's official shop directory

1. Click **Try for free** and open the actor.
2. Enter one or more `category_ids` — find a category's ID in its URL, e.g. `https://shopee.vn/Men-Clothes-cat.11035567` has category ID `11035567`. Don't know the IDs? Use the [Shopee Category Lister](https://apify.com/herus13/shopee-category-lister), **or** leave `category_ids` empty and set `discover_all: true` to scrape every category automatically.
3. Optional: set `offset`, `limit`, or `max_results` to control pagination.
4. Click **Start** and watch results stream into the dataset.
5. Export as **JSON, CSV, or Excel**, or pull from the [Apify API](https://docs.apify.com/api/v2).

```json
{
  "category_ids": ["11035567"],
  "max_results": 100
}
````

Or scrape every category in a country automatically — no IDs to look up:

```json
{
  "discover_all": true,
  "country": "vn",
  "max_results": 100
}
```

### Shopee Shop Scraper input

| Field | Type | Default | Description |
|---|---|---|---|
| `category_ids` | string\[] | — | Shopee category IDs to list official shops for. Required **unless** `discover_all` is on. |
| `discover_all` | boolean | `false` | Leave `category_ids` empty and set this `true` to auto-discover **every** official-shop category in the country and scrape all of them. Can be large/expensive — pair with `max_results`. Ignored when `category_ids` is set. |
| `country` | enum | `vn` | Shopee storefront — one of `vn`, `id`, `sg`, `my`, `th`, `ph`, `tw`, `br`, `mx` (Vietnam, Indonesia, Singapore, Malaysia, Thailand, Philippines, Taiwan, Brazil, Mexico). |
| `offset` | int | `0` | Starting position per category. |
| `limit` | int | `50` | Shops requested per API call (1-100). |
| `max_results` | int | — | Cap on total shops returned per category. Unset paginates until Shopee's own total is exhausted. |
| `scrape_analytics` | boolean | `false` | Adds a per-shop analytics charge — enriches every shop with follower count, rating, item count, response rate/time, location, and more via one extra request per shop. Leave off for a fast, cheap directory listing. |

### Shopee shop data output

Each shop is one dataset row. Sample from a live run with `scrape_analytics: true`:

```json
{
  "category_id": "11035567",
  "user_id": "24711470",
  "username": "coolmate.vn",
  "shop_id": "24710134",
  "shop_name": "Coolmate - Official Store",
  "brand_name": "Coolmate",
  "logo": "vn-11134258-81ztc-mlg620bdy58if7",
  "shop_type": 1,
  "shop_url": "https://shopee.vn/coolmate.vn",
  "logo_url": "https://cf.shopee.vn/file/vn-11134258-81ztc-mlg620bdy58if7",
  "shop_created_at": "2021-06-21T07:07:26+00:00",
  "entity_id": 10601,
  "brand_label": 0,
  "follower_count": 1980773,
  "rating_star": 4.922796,
  "rating_good": 1283535,
  "rating_normal": 15566,
  "rating_bad": 5991,
  "item_count": 586,
  "response_rate": 100,
  "response_time": 5190,
  "shop_location": "Thành phố Hà Nội",
  "is_shopee_verified": false,
  "is_preferred_plus_seller": false,
  "description": "Được hình thành trong thời đại 4.0, Coolmate áp dụng sức mạnh của công nghệ vào thời trang để đưa ra Giải pháp mua sắm đồ cơ bản cho nam giới với mô hình tiện lợi hơn, tiết kiệm hơn - khách hàng có thể mua cả tủ đồ đảm bảo chất lượng, made in Vietnam ,giá tốt, giao hàng nhanh chóng, và dịch vụ chăm sóc vượt trội.\n \n * MIỄN PHÍ GIAO HÀNG TOÀN QUỐC\n * ĐỔI TRẢ MIỄN PHÍ BẤT KÌ LÍ DO GÌ TRONG 60 NGÀY (ĐỔI TRẢ TẬN NƠI)\n * Hotline dịch vụ CSKH: 1900272737 (8H30 - 22H)\n * Email CSKH: Cool@coolmate.me\n",
  "shop_last_active_at": "2026-07-14T06:53:28+00:00",
  "following_count": 275,
  "scraped_at": "2026-07-14T06:57:22+00:00"
}
```

> All 14 analytics fields (`follower_count` through `following_count`) are `null` unless you set `scrape_analytics: true`. With the flag off you still get the base directory fields (`category_id` through `brand_label` plus `scraped_at`).

| Field | Description |
|---|---|
| `category_id` | The category this shop was listed under. |
| `user_id`, `shop_id`, `username`, `shop_name` | Shopee's own identifiers and display name. |
| `brand_name`, `logo` | Brand name and raw logo image ID, when present. |
| `shop_type` | Shopee's internal shop-type code. |
| `shop_url` | Direct storefront link, built from `username` + the country's Shopee domain (e.g. `https://shopee.vn/coolmate.vn`). |
| `logo_url` | Ready-to-use CDN image URL for `logo`, built from the country's CDN domain (e.g. `https://cf.shopee.vn/file/...`). |
| `shop_created_at` | Shop creation date, converted from Shopee's raw Unix timestamp (`ctime`) to ISO 8601 UTC. |
| `entity_id` | Shopee's internal brand/entity identifier tying the shop to a registered brand entity. |
| `brand_label` | Shopee's internal brand-label code (e.g. distinguishing official-brand tiers). |
| `follower_count` | Number of Shopee followers of the shop. *Only when `scrape_analytics=true`.* |
| `rating_star` | Average shop rating, 1-5. *Only when `scrape_analytics=true`.* |
| `rating_good` | Count of positive (good) ratings. *Only when `scrape_analytics=true`.* |
| `rating_normal` | Count of neutral (normal) ratings. *Only when `scrape_analytics=true`.* |
| `rating_bad` | Count of negative (bad) ratings. *Only when `scrape_analytics=true`.* |
| `item_count` | Number of items currently listed in the shop. *Only when `scrape_analytics=true`.* |
| `response_rate` | Chat response rate, percent (0-100). *Only when `scrape_analytics=true`.* |
| `response_time` | Typical chat response time, in seconds. *Only when `scrape_analytics=true`.* |
| `shop_location` | Shop's registered location/city. *Only when `scrape_analytics=true`.* |
| `is_shopee_verified` | Whether Shopee has verified the shop. *Only when `scrape_analytics=true`.* |
| `is_preferred_plus_seller` | Whether the shop holds Shopee's Preferred+ seller badge. *Only when `scrape_analytics=true`.* |
| `description` | Shop's own storefront description text. *Only when `scrape_analytics=true`.* |
| `shop_last_active_at` | Shop's last-active timestamp, ISO 8601 UTC. *Only when `scrape_analytics=true`.* |
| `following_count` | Number of other Shopee shops/users this shop follows. *Only when `scrape_analytics=true`.* |
| `scraped_at` | Capture timestamp. |

### How much it costs

This actor uses **pay-per-event** pricing — you pay for what you scrape, not for time. See the Monetization tab for current pricing (introductory pricing may change as we validate cost-per-run against real traffic).

| Event | USD |
|---|---|
| Actor start (per run) | $0.005 |
| Official shop scraped | $0.005 |
| Shop analytics detail (per shop, only when `scrape_analytics=true`) | $0.003 |

With analytics on, each shop bills $0.005 + $0.003 = **$0.008 all-in**. Directory-only runs pay just $0.005/shop.

*Prices are provisional (market-researched) until set in the Console Monetization tab.*

### Recommended proxies for Shopee

**No proxy setup is required — the actor ships with its own residential proxy**, geo-pinned to your selected country so Shopee's geo-gated storefront resolves cleanly.

That bundled proxy runs on Apify's own residential network by default, with **[DataImpulse](https://dataimpulse.com/?aff=404588\&utm_source=apify) residential IPs** as an automatic fallback — pay-as-you-go, per-country targeting, no monthly minimum. If you run your own scrapers (inside or outside Apify) and need reliable residential proxies for Shopee, e-commerce, or other geo-gated sites, you can get DataImpulse here:

👉 **[Get DataImpulse residential proxies](https://dataimpulse.com/?aff=404588\&utm_source=apify)** (referral link)

### Why this Shopee Shop Scraper

- **No proxy setup** — Shopee's storefront is geo-gated; this actor bundles its own country-pinned proxy so you don't have to source or configure one.
- **Cheap by design** — only one short browser session per run; every paginated result after that is a plain HTTP call.
- **Validated output** — every row is Pydantic-validated before it's pushed; malformed entries are dropped, not shipped with garbage fields.
- **Open source** — the underlying `shopee-scraper` Python package ships a Typer CLI and a FastAPI server; the Apify wrapper is a thin layer.

### FAQ

**Do I need a proxy?** No. This actor bundles its own country-geo-pinned proxy — the `proxy` field is hidden because it's managed for you.

**Can I scrape other Shopee countries?** Nine storefronts today: Vietnam (`vn`), Indonesia (`id`), Singapore (`sg`), Malaysia (`my`), Thailand (`th`), Philippines (`ph`), Taiwan (`tw`), Brazil (`br`), and Mexico (`mx`). Category IDs are per-country — use the [Shopee Category Lister](https://apify.com/herus13/shopee-category-lister) to find real IDs for your chosen country. Other storefronts are added incrementally, each after we verify Shopee's anti-bot behavior on that domain.

**What's an "official shop"?** Shopee's own brand-verified store designation, distinct from ordinary third-party seller shops — this actor lists only shops in that official directory.

**What analytics do I get, and how much does it cost?** Set `scrape_analytics: true` to enrich every shop with 14 extra fields — follower count, rating (star/good/normal/bad), item count, response rate/time, location, verification/Preferred+ badges, description, last-active date, and following count — via one extra request per shop. It's off by default (fast, cheap directory listing) and adds a small per-shop charge (see pricing table) when enabled.

**Is scraping Shopee legal?** This actor collects only publicly available shop listing data. You are responsible for complying with Shopee's terms and applicable laws. Do not collect personal data without a lawful basis.

### Rate this actor ⭐

If the Shopee Official Shop Directory Scraper saved you time, please **leave a review on its Apify Store page** — ratings help other people find it and tell us what to build next. Hit a bug or missing field? Open an issue or contact us through the actor's **Issues** tab and we'll fix it fast.

### Related actors

- **[TikTok Shop Scraper](https://apify.com/herus13/tiktok-shop-scraper)** — the same "official shop directory" idea, on a different storefront.
- **[Shopee Category Lister](https://apify.com/herus13/shopee-category-lister)** — find real category IDs for your country before running this actor (or just use `discover_all`).

# Actor input Schema

## `category_ids` (type: `array`):

<p>Shopee category IDs to list official shops for — per-country, not shared across storefronts. Find a category's ID in its URL, e.g. <code>https://shopee.vn/Men-Clothes-cat.11035567</code> has category ID <code>11035567</code> (Vietnam), <code>https://shopee.co.id/Pakaian-Pria-cat.11042849</code> has category ID <code>11042849</code> (Indonesia).</p><p><b>Don't know the IDs?</b> Run our companion actor <a href="https://apify.com/herus13/shopee-category-lister" target="_blank">Shopee Category Lister</a> to pull the live list of category IDs for your country, then paste them here — or leave this empty and turn on <b>Scrape all categories</b> below to grab everything automatically.</p>
## `discover_all` (type: `boolean`):

<p>Leave <b>Category IDs</b> empty and turn this on to auto-discover <b>every</b> official-shop category in the selected country and scrape shops from all of them — no category IDs to look up.</p><p>⚠️ This can be a large, expensive run (all categories × all shops). Set <b>Max Results Per Category</b> to cap it. Ignored when Category IDs are provided.</p>
## `country` (type: `string`):

<p>Shopee storefront to scrape. More countries are added incrementally, each after a live anti-bot verification pass.</p>
## `offset` (type: `integer`):

Starting position per category — set this to resume/target a specific page directly.

## `limit` (type: `integer`):

Shops requested per API call.

## `max_results` (type: `integer`):

Cap on total shops returned per category. Leave empty to paginate until Shopee's own total is exhausted.

## `scrape_analytics` (type: `boolean`):

<p>When enabled, each shop is enriched with analytics — follower count, rating, item count, response rate, location, and more — via one extra request per shop. <b>This adds a per-shop charge</b> (see pricing). Leave off for a fast, cheap directory listing.</p>
## `proxy` (type: `object`):

<p>Managed by the actor. Proxy is bundled — the scraper runs on its own residential proxy (Apify, with DataImpulse fallback), geo-pinned to the selected country. No proxy configuration is needed.</p>

## Actor input object example

```json
{
  "category_ids": [
    "11035567"
  ],
  "discover_all": false,
  "country": "vn",
  "offset": 0,
  "limit": 50,
  "scrape_analytics": false
}
```

# Actor output Schema

## `results` (type: `string`):

Official shops discovered for each requested category, including derived fields (shop\_url, logo\_url, shop\_created\_at, entity\_id, brand\_label) computed from the raw API response. When scrape\_analytics is enabled, each shop also includes analytics fields (follower\_count, rating, item\_count, response\_rate, location).

# 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 = {
    "category_ids": [
        "11035567"
    ],
    "country": "vn"
};

// Run the Actor and wait for it to finish
const run = await client.actor("herus13/shopee-shop-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 = {
    "category_ids": ["11035567"],
    "country": "vn",
}

# Run the Actor and wait for it to finish
run = client.actor("herus13/shopee-shop-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 '{
  "category_ids": [
    "11035567"
  ],
  "country": "vn"
}' |
apify call herus13/shopee-shop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopee Official Shop Directory Scraper",
        "description": "List Shopee's official shops per category across 9 storefronts (Vietnam, Indonesia, Singapore, Malaysia, Thailand, Philippines, Taiwan, Brazil, Mexico) — shop name, username, brand, logo, storefront URL. Optional per-shop analytics (followers, rating, item count). No proxy setup needed (bundled).",
        "version": "0.1",
        "x-build-id": "7d9A1FA3PWSwiuNbZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/herus13~shopee-shop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-herus13-shopee-shop-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/herus13~shopee-shop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-herus13-shopee-shop-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/herus13~shopee-shop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-herus13-shopee-shop-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "category_ids": {
                        "title": "Category IDs",
                        "type": "array",
                        "description": "<p>Shopee category IDs to list official shops for — per-country, not shared across storefronts. Find a category's ID in its URL, e.g. <code>https://shopee.vn/Men-Clothes-cat.11035567</code> has category ID <code>11035567</code> (Vietnam), <code>https://shopee.co.id/Pakaian-Pria-cat.11042849</code> has category ID <code>11042849</code> (Indonesia).</p><p><b>Don't know the IDs?</b> Run our companion actor <a href=\"https://apify.com/herus13/shopee-category-lister\" target=\"_blank\">Shopee Category Lister</a> to pull the live list of category IDs for your country, then paste them here — or leave this empty and turn on <b>Scrape all categories</b> below to grab everything automatically.</p>",
                        "items": {
                            "type": "string"
                        }
                    },
                    "discover_all": {
                        "title": "Scrape all categories",
                        "type": "boolean",
                        "description": "<p>Leave <b>Category IDs</b> empty and turn this on to auto-discover <b>every</b> official-shop category in the selected country and scrape shops from all of them — no category IDs to look up.</p><p>⚠️ This can be a large, expensive run (all categories × all shops). Set <b>Max Results Per Category</b> to cap it. Ignored when Category IDs are provided.</p>",
                        "default": false
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "vn",
                            "id",
                            "sg",
                            "my",
                            "th",
                            "ph",
                            "tw",
                            "br",
                            "mx"
                        ],
                        "type": "string",
                        "description": "<p>Shopee storefront to scrape. More countries are added incrementally, each after a live anti-bot verification pass.</p>",
                        "default": "vn"
                    },
                    "offset": {
                        "title": "Start Offset",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Starting position per category — set this to resume/target a specific page directly.",
                        "default": 0
                    },
                    "limit": {
                        "title": "Page Size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Shops requested per API call.",
                        "default": 50
                    },
                    "max_results": {
                        "title": "Max Results Per Category",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on total shops returned per category. Leave empty to paginate until Shopee's own total is exhausted."
                    },
                    "scrape_analytics": {
                        "title": "Scrape Shop Analytics",
                        "type": "boolean",
                        "description": "<p>When enabled, each shop is enriched with analytics — follower count, rating, item count, response rate, location, and more — via one extra request per shop. <b>This adds a per-shop charge</b> (see pricing). Leave off for a fast, cheap directory listing.</p>",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "<p>Managed by the actor. Proxy is bundled — the scraper runs on its own residential proxy (Apify, with DataImpulse fallback), geo-pinned to the selected country. No proxy configuration is needed.</p>"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
