# TikTok Shop Products Scraper (`automation-lab/tiktok-shop-scraper`) Actor

Scrape TikTok Shop product listings — prices, discounts, seller info, ratings, and images. Browse any category or keyword. Export to CSV/Excel/JSON.

- **URL**: https://apify.com/automation-lab/tiktok-shop-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 14 total users, 5 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## TikTok Shop Products Scraper

Extract product listings from TikTok Shop — get product names, prices, discounts, seller info, ratings, sold counts, and images for any category. Perfect for competitive pricing research, trend analysis, and market intelligence.

### What does it do?

TikTok Shop Products Scraper loads TikTok Shop category pages and the main shop homepage, then extracts all visible product listings from the DOM. For each product, it captures:

- Product name and unique ID
- Current price and original price (before discount)
- Discount percentage
- Product thumbnail image URL
- Seller name
- Customer rating (1-5 stars)
- Sold count
- Free shipping indicator
- Direct product page URL

The scraper navigates TikTok Shop with a real Chromium browser to bypass basic bot detection, using residential proxies for reliable access.

### Who is it for?

👗 **E-commerce sellers** monitoring competitor pricing on TikTok Shop across categories like fashion, electronics, and beauty.

📊 **Market researchers** tracking trending products, pricing trends, and top-selling items in specific TikTok Shop categories.

🏪 **Brands and agencies** auditing TikTok Shop presence — checking which products in a category have highest ratings and sales volume.

💡 **Product scouts** finding new products to sell or promote on TikTok Shop by browsing top categories.

🔬 **Data analysts** building datasets of TikTok Shop pricing, discount patterns, and seller performance.

### Why use it?

- ✅ **No API key needed** — scrapes the public TikTok Shop website
- ✅ **Real browser rendering** — handles JavaScript-heavy pages that simple HTTP scrapers miss
- ✅ **Category-level browsing** — browse any of TikTok Shop's 30+ product categories
- ✅ **Rich output** — price, discount, rating, sold count, images all in one pass
- ✅ **Pagination via scrolling** — loads more products as it scrolls down category pages
- ✅ **Apify Cloud integration** — schedule runs, export to CSV/Excel/JSON, connect to Make/Zapier

### What data do you get?

| Field | Type | Description |
|-------|------|-------------|
| `productId` | String | Unique TikTok Shop product ID |
| `productName` | String | Full product title |
| `productUrl` | String | Direct URL to the product page |
| `price` | Number | Current sale price (USD) |
| `originalPrice` | Number | Original price before discount |
| `currency` | String | Always `USD` for TikTok Shop US |
| `discountPercent` | Number | Discount percentage (0 if no discount) |
| `thumbnailUrl` | String | Product image URL |
| `images` | Array | List of product image URLs |
| `sellerName` | String | Seller/shop name |
| `reviewRating` | Number | Average customer rating (1-5) |
| `soldCount` | Number | Number of units sold |
| `freeShipping` | Boolean | Whether product offers free shipping |
| `searchKeyword` | String | Keyword used (for keyword mode) |
| `scrapedAt` | String | ISO timestamp when scraped |

### How much does it cost to scrape TikTok Shop products?

This actor uses **Pay-Per-Event (PPE)** pricing — you only pay for what you extract:

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
|-------|------|--------|--------|------|----------|---------|
| Run started | $0.02 | $0.02 | $0.02 | $0.02 | $0.02 | $0.02 |
| Product scraped | $0.005 | $0.0045 | $0.0039 | $0.003 | $0.002 | $0.0014 |

**Example costs (FREE tier):**
- Scrape 50 products from Beauty & Personal Care: $0.02 + 50 × $0.005 = **$0.27**
- Scrape 100 products from Phones & Electronics: $0.02 + 100 × $0.005 = **$0.52**
- Scrape 200 products across 4 categories: $0.02 + 200 × $0.005 = **$1.02**

**Tip:** For best cost efficiency, scrape at least 20+ products per run. Very small runs (under 10 products) have higher per-product costs due to fixed proxy startup overhead.

Higher Apify subscription tiers (BRONZE through DIAMOND) receive progressive discounts on the per-product rate.

### How to use it

#### Step 1: Choose your mode

**Category URL mode (recommended):** Browse a specific TikTok Shop category:
1. Go to [TikTok Shop](https://www.tiktok.com/shop)
2. Click on any category (e.g., "Beauty & Personal Care")
3. Copy the URL — it looks like `https://www.tiktok.com/shop/c/beauty-personal-care/601450`
4. Paste it into the **TikTok Shop category URLs** field

**Keyword mode:** Search TikTok Shop's trending/featured products:
1. Enter keywords like `wireless earbuds`, `skincare`, `phone case`
2. The scraper returns featured products from TikTok Shop's main page and deals sections
3. Note: TikTok Shop search requires authentication — keyword results come from featured/trending products, not filtered search results

#### Step 2: Set limits

Set **Max products per keyword/category** to control how many products to extract. Default is 50. Set to 0 for unlimited (scrapes until no more products load).

#### Step 3: Run and export

Click **Save & Run**. Results appear in the **Dataset** tab as they're scraped. Export to CSV, Excel, JSON, or connect to downstream tools.

### Input

```json
{
    "keywords": ["wireless earbuds", "phone case"],
    "categoryUrls": [
        "https://www.tiktok.com/shop/c/beauty-personal-care/601450",
        "https://www.tiktok.com/shop/c/phones-electronics/601739"
    ],
    "maxProductsPerKeyword": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
````

You can use keywords, category URLs, or both. At least one is required.

#### Available TikTok Shop categories

| Category | URL |
|----------|-----|
| Beauty & Personal Care | `https://www.tiktok.com/shop/c/beauty-personal-care/601450` |
| Women's Fashion | `https://www.tiktok.com/shop/c/womenswear-underwear/601152` |
| Men's Fashion | `https://www.tiktok.com/shop/c/menswear-underwear/824328` |
| Phones & Electronics | `https://www.tiktok.com/shop/c/phones-electronics/601739` |
| Fashion Accessories | `https://www.tiktok.com/shop/c/fashion-accessories/605248` |
| Home Supplies | `https://www.tiktok.com/shop/c/home-supplies/600001` |
| Kitchenware | `https://www.tiktok.com/shop/c/kitchenware/600024` |
| Shoes | `https://www.tiktok.com/shop/c/shoes/601352` |
| Sports & Outdoor | `https://www.tiktok.com/shop/c/sports-outdoor/603014` |
| Toys & Hobbies | `https://www.tiktok.com/shop/c/toys-hobbies/604206` |
| Pet Supplies | `https://www.tiktok.com/shop/c/pet-supplies/602118` |
| Food & Beverages | `https://www.tiktok.com/shop/c/food-beverages/700437` |
| Health | `https://www.tiktok.com/shop/c/health/700645` |
| Furniture | `https://www.tiktok.com/shop/c/furniture/604453` |

### Output

Sample output item:

```json
{
    "productId": "1729390331098862467",
    "productName": "Comfrt | Cloud Tee",
    "productUrl": "https://www.tiktok.com/shop/pdp/cloud-tee-by-comfrt-oversized-unisex-sleep-shirt/1729390331098862467",
    "price": 25.00,
    "originalPrice": 45.00,
    "currency": "USD",
    "discountPercent": 44,
    "thumbnailUrl": "https://p16-oec-general-useast5.ttcdn-us.com/...",
    "images": ["https://p16-oec-general-useast5.ttcdn-us.com/..."],
    "categoryId": null,
    "categoryName": null,
    "sellerName": "Comfrt",
    "sellerRating": null,
    "reviewCount": null,
    "reviewRating": 4.4,
    "freeShipping": false,
    "shippingInfo": null,
    "soldCount": 197500,
    "searchKeyword": "wireless earbuds",
    "scrapedAt": "2026-04-01T04:30:00.000Z"
}
```

### Tips & best practices

💡 **Use category URLs for best results** — Category pages reliably load product listings. Keyword mode returns trending/featured products rather than filtered search results.

💡 **Scrape during off-peak hours** — Running between midnight and 6 AM US Eastern time reduces proxy contention and improves success rates.

💡 **Target sub-categories for niche research** — Instead of the top-level "Beauty & Personal Care" category, drill into sub-categories like `https://www.tiktok.com/shop/c/skin-care/601453` for more focused results.

💡 **Combine multiple category URLs** — Pass 3-5 category URLs in a single run to gather broad market data efficiently. Each category is scraped in sequence.

💡 **Schedule recurring runs** — Set up a daily or weekly schedule to track pricing trends over time. Use Apify's dataset comparison features to spot price changes.

⚠️ **TikTok Shop is US-only** — TikTok Shop is currently available primarily in the US. The scraper uses US residential proxies by default.

⚠️ **Dynamic product IDs** — Product IDs are stable (they're TikTok's internal IDs), so you can safely use them as keys for deduplication between runs.

### Troubleshooting

**Q: Getting 0 products / Security Check errors?**
A: TikTok's bot detection can block runs with bad proxy sessions. Try running again — the session pool will use a different residential proxy IP. Using Apify's RESIDENTIAL proxy group (default setting) gives the best success rate.

**Q: Keyword search returns products not related to my keyword?**
A: TikTok Shop blocks unauthenticated search queries (WAF protection). Keyword mode returns trending/featured products from TikTok Shop's main page. For category-specific products, use a category URL instead.

**Q: Prices show as null?**
A: Some products on TikTok Shop display price ranges (e.g., for products with variants) which may not parse correctly. The scraper extracts the first visible price. Check the product URL directly for accurate pricing.

### Integrations

#### 📊 Google Sheets via Apify Sync

Export TikTok Shop product data directly to Google Sheets for tracking price changes over time:

1. In the actor's run, click **Export** → **Google Sheets**
2. Schedule the actor to run daily
3. New products append to your sheet automatically

#### 🔁 Make (Integromat) automation

Build a price monitoring workflow:

1. Use the **Apify** Make module to trigger runs
2. Connect to **Google Sheets** to write new products
3. Add a **Filter** to only process items with discount > 30%
4. Send a **Slack** or **Email** notification for deals

#### 💼 Zapier integration

1. Trigger: **Apify — New Item in Dataset**
2. Action: **Google Sheets — Create Row** or **Airtable — Create Record**
3. Filter by `discountPercent > 40` to alert on flash sales

#### 🔗 Direct API usage

The actor can be triggered via the Apify API for real-time integration:

**Node.js:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/tiktok-shop-scraper').call({
    categoryUrls: ['https://www.tiktok.com/shop/c/beauty-personal-care/601450'],
    maxProductsPerKeyword: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} products`);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("automation-lab/tiktok-shop-scraper").call(run_input={
    "categoryUrls": ["https://www.tiktok.com/shop/c/beauty-personal-care/601450"],
    "maxProductsPerKeyword": 50,
})

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(f"Scraped {len(items)} products")
```

**cURL:**

```bash
curl -X POST https://api.apify.com/v2/acts/automation-lab~tiktok-shop-scraper/runs \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "categoryUrls": ["https://www.tiktok.com/shop/c/beauty-personal-care/601450"],
    "maxProductsPerKeyword": 50
  }'
```

### Using with AI and MCP

#### Setup for Claude Code

```bash
claude mcp add apify --transport http https://mcp.apify.com?tools=automation-lab/tiktok-shop-scraper
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- *"Scrape 50 products from TikTok Shop's Beauty category and find items with over 40% discount"*
- *"Get electronics products from TikTok Shop and create a pricing comparison table"*
- *"What are the top-rated products in TikTok Shop's Home Supplies category right now?"*
- *"Find the best deals (highest discount %) in the Shoes category on TikTok Shop"*

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Legality and legal considerations for scraping TikTok Shop

This actor scrapes publicly accessible product listings from TikTok Shop — the same information visible to any website visitor without logging in. No authentication is used.

Web scraping of public product data is generally lawful under US law (hiQ Labs v. LinkedIn, 2022). However:

- **Review TikTok's Terms of Service** before commercial use
- **Respect rate limits** — this actor uses session management and reasonable delays
- **Do not resell scraped data** in ways that compete with TikTok's own data products
- **Use scraped data responsibly** — pricing research, market analysis, and academic study are generally considered legitimate use cases

For legal questions specific to your use case, consult your legal counsel.

### FAQ

**Q: How many products can I scrape per run?**
A: There's no hard limit — set `maxProductsPerKeyword` to 0 for unlimited. Realistically, a single category page loads 20-50 products on initial load, with more loading as you scroll. Expect 50-200 products per category per run.

**Q: Can I scrape TikTok Shop in countries other than the US?**
A: TikTok Shop currently operates in the US, UK, Southeast Asia (Indonesia, Thailand, Vietnam, Philippines, Malaysia), and a few other markets. This actor is optimized for the US market with US residential proxies. Contact us for region-specific scraping.

**Q: Does this scrape product detail pages (seller ratings, full descriptions)?**
A: The current version scrapes listing pages (category/search results). Product detail page scraping (full descriptions, all images, seller profile, buyer reviews) is planned for v0.2.

**Q: How fresh is the data?**
A: Products are scraped live from TikTok Shop at the time of the run. Prices and discounts reflect the current state of the website.

**Q: Can I get flash sale prices?**
A: Yes — the actor also scrapes TikTok Shop's flash sales page (`/shop/deals/flash-sales`), which lists deeply discounted products with time-limited prices.

**Q: The run succeeded but I got fewer products than expected. Why?**
A: TikTok Shop uses lazy-loading — products only appear as you scroll. The scraper scrolls the page to trigger more loads. If you need more products, increase `maxProductsPerKeyword` and the scraper will scroll further. Also note that some product cards may not have prices set (unlisted products), which are excluded from output.

### Related scrapers

Other automation-lab scrapers for social commerce and e-commerce data:

- [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper) — scrape TikTok videos, profiles, and trending content
- [TikTok Hashtag Scraper](https://apify.com/automation-lab/tiktok-hashtag-scraper) — scrape videos by hashtag
- [TikTok Search Scraper](https://apify.com/automation-lab/tiktok-search-scraper) — scrape TikTok video search results
- [TikTok Profile Scraper](https://apify.com/automation-lab/tiktok-profile-scraper) — scrape TikTok user profiles and videos

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for products on TikTok Shop. Example: 'wireless earbuds', 'phone case', 'skincare'. Results are scraped from TikTok Shop search.

## `categoryUrls` (type: `array`):

TikTok Shop category URLs to browse (e.g. https://www.tiktok.com/shop/category/...). Leave empty to use keyword search only.

## `maxProductsPerKeyword` (type: `integer`):

Maximum number of products to extract per keyword or category URL. Set to 0 for unlimited.

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

Proxy settings. Defaults to US residential (required — TikTok Shop is geo-restricted and blocks datacenter IPs). The scraper blocks images/fonts/media to minimize residential bandwidth usage.

## Actor input object example

```json
{
  "keywords": [
    "wireless earbuds"
  ],
  "categoryUrls": [],
  "maxProductsPerKeyword": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "keywords": [
        "wireless earbuds"
    ],
    "categoryUrls": [],
    "maxProductsPerKeyword": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tiktok-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 = {
    "keywords": ["wireless earbuds"],
    "categoryUrls": [],
    "maxProductsPerKeyword": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tiktok-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 '{
  "keywords": [
    "wireless earbuds"
  ],
  "categoryUrls": [],
  "maxProductsPerKeyword": 10
}' |
apify call automation-lab/tiktok-shop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Shop Products Scraper",
        "description": "Scrape TikTok Shop product listings — prices, discounts, seller info, ratings, and images. Browse any category or keyword. Export to CSV/Excel/JSON.",
        "version": "0.1",
        "x-build-id": "anRqYHDODOjta7CVt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tiktok-shop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tiktok-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/automation-lab~tiktok-shop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tiktok-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/automation-lab~tiktok-shop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tiktok-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": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "List of keywords to search for products on TikTok Shop. Example: 'wireless earbuds', 'phone case', 'skincare'. Results are scraped from TikTok Shop search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryUrls": {
                        "title": "TikTok Shop category URLs",
                        "type": "array",
                        "description": "TikTok Shop category URLs to browse (e.g. https://www.tiktok.com/shop/category/...). Leave empty to use keyword search only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProductsPerKeyword": {
                        "title": "Max products per keyword / category",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to extract per keyword or category URL. Set to 0 for unlimited.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Defaults to US residential (required — TikTok Shop is geo-restricted and blocks datacenter IPs). The scraper blocks images/fonts/media to minimize residential bandwidth usage."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
