# TikTok Shop Scraper (`silentflow/tiktok-shop-scraper`) Actor

Extract TikTok Shop product data at scale: prices, variants, ratings, reviews, sold counts, seller details, shipping and images. Search the catalog by keyword or scrape products by URL across US, UK and other markets. Ideal for dropshipping research, price monitoring and competitor analysis.

- **URL**: https://apify.com/silentflow/tiktok-shop-scraper.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (community)
- **Categories:** E-commerce, Social media, Marketing
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 1,000 results

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 Scraper

**Every TikTok Shop product, structured and ready for analysis: prices, variants, ratings, reviews, sellers, and shipping.** Search the catalog by keyword or scrape by product URL, and get clean JSON in minutes instead of copying tabs for hours.

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/srn94AYA0Wp7hUmeZ/records/how-it-works-v2.png)

Paste TikTok Shop product URLs or type keywords to search the catalog, pick a market, and run the Actor. You get structured records back with over 40 fields per product: price, variants, ratings, reviews, seller stats, and shipping. No login, no API key, no setup. Export to JSON, CSV, or Excel, or pull straight from the API.

### ✨ Why teams choose this over other TikTok Shop scrapers

Spending hours copying product data from TikTok Shop tabs? Running scrapers that fail on half the products you feed them? Paying for a product scraper, then a second one for search, then a third for reviews?

- 🎯 **Search and detail in one Actor.** Find products by keyword and scrape them in full depth without stitching two tools together. Most competitors sell search and detail as separate Actors. This one does both in a single run.
- 📦 **Over 40 fields per product.** Price, discounted price, discount percentage, price range, currency, rating, rating count, sales count, stock, every variant with its own price and stock, specifications, shipping, delivery windows, seller, shop stats, images, and videos. The fields other scrapers skip are often the ones you need most.
- ⭐ **Reviews and rating distribution included.** Pull real reviews with reviewer name, star rating, verified-purchase and incentivized flags, review images, and country, plus the full 1-to-5 star distribution. Most scrapers stop at the average rating.
- ✅ **Reliable on hard products, not just easy ones.** Feed it a list and get results back for the whole list, including products that other scrapers silently drop. Consistent output whether you run one product or hundreds.
- 🏪 **Full seller and shop context.** Every record carries the shop name, shop URL, shop rating, follower count, catalog size, and seller location, so you can rank sellers, not just products.
- 🔓 **No account, no cookies, no headaches.** The Actor reads publicly visible product and search data. Nothing to log in to, nothing to configure, nothing to maintain.
- 🌍 **Built for TikTok Shop's biggest markets.** Scrape the United States and United Kingdom catalogs out of the box, with more regions available in a single dropdown.

### 🎯 What you can do with TikTok Shop data

| Team | What they build |
|------|-----------------|
| Ecommerce & Dropshipping | Find winning products by sold count, rating, and review volume, and spot demand before a category saturates |
| Brand & Retail | Track your own listings and competitors' prices, variants, discounts, and stock across TikTok Shop |
| Market Research | Compare pricing, demand, and assortment across categories and regions with structured product datasets |
| Data & Analytics | Feed 40+ fields per product into BI dashboards, pricing models, and trend forecasts |
| Affiliate & Creator | Discover high-converting products with strong ratings and reviews that are worth promoting |
| Sourcing & Wholesale | Rank shops by catalog size, follower count, and rating to shortlist reliable suppliers |
| Reputation & CX | Pull reviews with verified-purchase flags and star distribution to read what buyers actually say |

### 📥 Input parameters

Give the Actor product URLs, keywords, or both. Everything else is optional.

| Field | Type | Description |
|-------|------|-------------|
| `productUrls` | array of strings | TikTok Shop product URLs to scrape in full detail (price, variants, reviews, shipping, seller). |
| `searchKeywords` | array of strings | Keywords to search the TikTok Shop catalog. Returns matching products with title, price, rating, and sold count that you can then scrape in detail. |
| `region` | string | TikTok Shop market. Options: United States, United Kingdom, Singapore, Indonesia, Malaysia, Thailand, Vietnam, Philippines. Auto-detected from the URL when present. |
| `debugMode` | boolean | Log extra diagnostics for troubleshooting. Leave off for normal runs. |

You can run product URLs and search keywords together in a single run. The output is one clean dataset combining both.

### 📊 Output data

**Product detail record** (scraped from a product URL):

```json
{
  "product_name": "Hydrating Vitamin C Face Serum 30ml",
  "product_id": "1729382355331745106",
  "product_url": "https://shop.tiktok.com/view/product/1729382355331745106",
  "price": 12.99,
  "discounted_price": 9.74,
  "discount_percentage": 25,
  "price_min": 9.74,
  "price_max": 18.50,
  "currency": "USD",
  "rating": 4.82,
  "rating_count": 2431,
  "sales_count": 15600,
  "in_stock": true,
  "total_stock": 842,
  "variant_count": 3,
  "variants": [
    { "sku_id": "17293...", "name": "30ml Single", "price": 9.74, "stock": 300, "in_stock": true },
    { "sku_id": "17294...", "name": "30ml Twin Pack", "price": 17.50, "stock": 220, "in_stock": true }
  ],
  "specifications": { "Volume": "30ml", "Skin Type": "All" },
  "category": "Beauty & Personal Care",
  "shipping_fee": 0,
  "free_shipping": true,
  "delivery_min_days": 3,
  "delivery_max_days": 7,
  "reviews_total": 2431,
  "rating_distribution": { "5": 2010, "4": 300, "3": 80, "2": 25, "1": 16 },
  "reviews": [
    {
      "review_id": "74920...",
      "rating": 5,
      "text": "Skin feels amazing after two weeks.",
      "reviewer_name": "a***a",
      "verified_purchase": true,
      "incentivized": false,
      "images": ["https://..."],
      "country": "US"
    }
  ],
  "shop_name": "GlowLab Official",
  "shop_url": "https://shop.tiktok.com/...",
  "shop_id": "7495...",
  "average_rating": 4.79,
  "shop_rating_count": 51230,
  "follower_count": 128400,
  "total_products": 96,
  "seller_location": "US",
  "images": ["https://...", "https://..."],
  "videos": [{ "id": "73...", "cover_url": "https://...", "duration": 18.4 }],
  "region": "us",
  "timestamp": "2026-07-01T09:14:22Z"
}
````

**Search result record** (returned from a keyword):

```json
{
  "product_id": "1729382355331745106",
  "title": "Hydrating Vitamin C Face Serum 30ml",
  "product_url": "https://shop.tiktok.com/view/product/1729382355331745106",
  "price": 9.74,
  "original_price": 12.99,
  "discount": "25% off",
  "currency": "USD",
  "rating": 4.82,
  "review_count": 2431,
  "sold_count": 15600,
  "image": "https://...",
  "seller_id": "7495...",
  "seller_name": "GlowLab Official",
  "keyword": "face serum",
  "region": "us",
  "timestamp": "2026-07-01T09:14:22Z"
}
```

### 🗂️ Data fields

**Product identity**

| Field | Type | Description |
|-------|------|-------------|
| `product_name` | string | Product title |
| `product_id` | string | TikTok Shop product ID |
| `product_url` | string | Canonical product URL |
| `category` | string | Primary category |
| `categories` | array | Full category path |
| `description` | string | Product description |

**Pricing**

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | List price |
| `discounted_price` | number | Current price after discount |
| `discount_percentage` | number | Discount as a percentage |
| `price_min` / `price_max` | number | Price range across variants |
| `currency` | string | Currency code |

**Ratings & reviews**

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | Average star rating |
| `rating_count` | number | Number of ratings |
| `reviews_total` | number | Total reviews |
| `rating_distribution` | object | Count of 1 to 5 star ratings |
| `reviews` | array | Review objects: rating, text, reviewer, verified-purchase flag, incentivized flag, images, country, time |

**Variants & stock**

| Field | Type | Description |
|-------|------|-------------|
| `in_stock` | boolean | Whether the product is buyable |
| `total_stock` | number | Total units across variants |
| `variant_count` | number | Number of variants |
| `variants` | array | Each SKU: name, price, stock, in-stock flag |
| `specifications` | object | Attribute name and value pairs |

**Shipping**

| Field | Type | Description |
|-------|------|-------------|
| `shipping_fee` | number | Shipping cost |
| `free_shipping` | boolean | Free shipping flag |
| `delivery_min_days` / `delivery_max_days` | number | Delivery window |

**Seller & shop**

| Field | Type | Description |
|-------|------|-------------|
| `shop_name` | string | Shop name |
| `shop_url` | string | Shop page URL |
| `shop_id` | string | Shop ID |
| `average_rating` | number | Shop average rating |
| `shop_rating_count` | number | Number of shop ratings |
| `follower_count` | number | Shop followers |
| `total_products` | number | Products in the shop |
| `seller_location` | string | Seller country |

**Media & meta**

| Field | Type | Description |
|-------|------|-------------|
| `images` | array | Product image URLs |
| `videos` | array | Product videos: cover, duration |
| `image_url` | string | Primary image |
| `sales_count` | number | Units sold |
| `region` | string | Market code |
| `timestamp` | string | When the record was scraped |

**Search results** carry `product_id`, `title`, `product_url`, `price`, `original_price`, `discount`, `currency`, `rating`, `review_count`, `sold_count`, `image`, `seller_id`, `seller_name`, `keyword`, and `region`.

### 🚀 Examples

**Scrape a single product in full detail**

```json
{
  "productUrls": ["https://shop.tiktok.com/view/product/1729382355331745106"]
}
```

**Find products by keyword**

```json
{
  "searchKeywords": ["face serum"],
  "region": "us"
}
```

**Scrape a batch of products at once**

```json
{
  "productUrls": [
    "https://shop.tiktok.com/view/product/1729382355331745106",
    "https://shop.tiktok.com/view/product/1729382355331745107",
    "https://shop.tiktok.com/view/product/1729382355331745108"
  ]
}
```

**Search the UK catalog**

```json
{
  "searchKeywords": ["wireless earbuds", "phone case"],
  "region": "gb"
}
```

**Combine search and detail in one run**

```json
{
  "searchKeywords": ["led strip lights"],
  "productUrls": ["https://shop.tiktok.com/view/product/1729382355331745106"],
  "region": "us"
}
```

**Compare a product across two markets**

```json
{
  "productUrls": [
    "https://shop.tiktok.com/us/pdp/1729382355331745106",
    "https://shop.tiktok.com/gb/pdp/1729382355331745106"
  ]
}
```

### 🤖 Copy to your AI assistant

Paste this block into Claude, ChatGPT, or Cursor to give it full context about this scraper:

```
You have access to the TikTok Shop Scraper on Apify: SilentFlow/tiktok-shop-scraper

Input schema:
- productUrls (array of strings): TikTok Shop product URLs to scrape in full detail.
- searchKeywords (array of strings): keywords to search the TikTok Shop catalog.
- region (string, default "us"): one of us, gb, sg, id, my, th, vn, ph.
- debugMode (boolean, default false): extra diagnostics.

Provide productUrls, searchKeywords, or both.

Output per product (40+ fields): product_name, product_id, product_url, price,
discounted_price, discount_percentage, price_min, price_max, currency, rating,
rating_count, sales_count, in_stock, total_stock, variant_count, variants[],
specifications{}, category, categories[], shipping_fee, free_shipping,
delivery_min_days, delivery_max_days, reviews_total, rating_distribution{},
reviews[] (rating, text, reviewer_name, verified_purchase, incentivized, images, country),
shop_name, shop_url, shop_id, average_rating, shop_rating_count, follower_count,
total_products, seller_location, images[], videos[], region, timestamp.

Output per search result (17 fields): product_id, title, product_url, price,
original_price, discount, currency, rating, review_count, sold_count, image,
seller_id, seller_name, keyword, region, timestamp.

Pay per result. Proxies included. Use apify-client for Python or JavaScript.
```

### 💻 Integrations

#### Find winning products with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("SilentFlow/tiktok-shop-scraper").call(run_input={
    "searchKeywords": ["face serum", "led strip lights", "phone case"],
    "region": "us",
})

winners = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("sold_count", 0) > 5000 and item.get("rating", 0) >= 4.5:
        winners.append(item)

winners.sort(key=lambda p: p["sold_count"], reverse=True)
for p in winners[:20]:
    print(p["sold_count"], p["rating"], p["title"], p["product_url"])
```

#### Monitor competitor prices with JavaScript

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

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

const run = await client.actor('SilentFlow/tiktok-shop-scraper').call({
  productUrls: [
    'https://shop.tiktok.com/view/product/1729382355331745106',
    'https://shop.tiktok.com/view/product/1729382355331745107',
  ],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const p of items) {
  console.log(`${p.product_name}: ${p.discounted_price} ${p.currency} (${p.discount_percentage}% off, stock ${p.total_stock})`);
}
```

#### Export straight to CSV

```python
import csv
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("SilentFlow/tiktok-shop-scraper").call(run_input={
    "searchKeywords": ["wireless earbuds"], "region": "gb",
})

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
with open("tiktok_shop.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["title", "price", "rating", "sold_count", "product_url"])
    writer.writeheader()
    for r in rows:
        writer.writerow({k: r.get(k) for k in writer.fieldnames})
```

### 📈 Performance

| Metric | Detail |
|--------|--------|
| Setup | None. Paste URLs or keywords and run. |
| Products per run | No fixed limit. Scrape one product or hundreds in a single run. |
| Fields per product | Over 40, plus every variant, review, and video as its own object. |
| Search results | Dozens of products per keyword with price, rating, and sold count. |
| Reliability | Consistent output across the full input list, including hard products. |
| Freshness | Live data, read at the moment of the run. |

### 💾 Data export

Every run writes to a dataset you can export in one click as **JSON, CSV, Excel, XML, HTML table, or RSS**. You can also pull results programmatically from the dataset API:

```
https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=csv&token=YOUR_TOKEN
```

Swap `format=csv` for `json`, `xlsx`, or `xml` to fit your pipeline. Results are ready for Google Sheets, Airtable, a database, or a BI tool.

### 💡 Tips for best results

- **Start with search, then scrape in detail.** Run a keyword search to surface product IDs and sold counts, then feed the URLs of the best performers back in for full detail with reviews.
- **Rank by sold count, not just rating.** A 5-star product with 20 sales tells you less than a 4.6-star product with 15,000 sales. `sold_count` is the strongest demand signal.
- **Match the region to the URL.** A United States product URL returns United States pricing and reviews. Set `region` to the market you actually care about.
- **Use rating distribution to read sentiment fast.** A product with 90 percent 5-star reviews behaves very differently from one averaging 4.5 with a long 1-star tail. The `rating_distribution` field shows this at a glance.
- **Batch your URLs.** Send many product URLs in one run instead of one run per product. It is faster and keeps your data in a single dataset.

### ❓ FAQ

**What exactly does this scraper extract?**
Full product detail (price, discount, variants, stock, specifications, shipping, delivery, seller, and shop stats), product reviews with star distribution, and keyword search results with price, rating, and sold count.

**How do I choose between search and product URLs?**
Use `searchKeywords` to discover products when you do not have URLs yet. Use `productUrls` when you already know the products and want full detail with reviews. You can use both in one run.

**Do I need a TikTok or TikTok Shop account?**
No. The scraper reads publicly visible product and search data. No login, no API key, no cookies to manage.

**How fresh is the data?**
It is read live at the moment of the run. Each record includes a `timestamp` so you know exactly when it was captured.

**Can I scrape more than one keyword or product at a time?**
Yes. Both `searchKeywords` and `productUrls` accept lists, and you can combine them. There is no fixed limit on how many you pass.

**Which markets are supported?**
United States and United Kingdom out of the box, plus Singapore, Indonesia, Malaysia, Thailand, Vietnam, and the Philippines from the region dropdown.

**Do reviews come with every product?**
Product detail runs include reviews and the full rating distribution when the product page exposes them. Search results carry the review count and rating, not the individual reviews.

**Why are some optional fields missing on a given product?**
TikTok Shop does not fill every field for every listing. Fields like `videos`, `specifications`, or `seller_location` appear only when the product page provides them, so they are omitted rather than returned empty.

**What format is the output?**
Structured JSON, exportable to CSV, Excel, XML, HTML, or RSS, and available through the dataset API.

### ⚖️ Legal

This Actor extracts publicly available data from TikTok Shop. It does not bypass any login, paywall, or CAPTCHA. Users are responsible for complying with TikTok Shop's terms of service and applicable laws in their jurisdiction. The data returned is informational; verify accuracy for regulated use cases.

### 📬 Support

Need something this scraper doesn't do yet? We ship features fast.

- Feature requests go straight to our backlog
- Enterprise needs? We do custom integrations and high-volume plans
- Pricing questions? Check the Monetization tab on the actor page

Response time: usually under 24 hours.

Check out our other scrapers: [silentflow on Apify](https://apify.com/silentflow)

# Actor input Schema

## `productUrls` (type: `array`):

TikTok Shop product URLs to scrape in full detail (price, variants, reviews, shipping).

## `searchKeywords` (type: `array`):

Keywords to search the TikTok Shop catalog. Returns matching products (title, price, rating, sold count, URL) you can then scrape in detail via Product URLs.

## `region` (type: `string`):

TikTok Shop market. Auto-detected from the URL when present.

## `clearanceCookie` (type: `string`):

Optional anti-bot clearance cookie if the actor is challenged.

## `debugMode` (type: `boolean`):

Log extra diagnostics for troubleshooting. Leave off for normal runs.

## Actor input object example

```json
{
  "productUrls": [
    "https://shop.tiktok.com/view/product/1729382355331745106"
  ],
  "searchKeywords": [
    "face cream"
  ],
  "region": "us",
  "debugMode": false
}
```

# Actor output Schema

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

All scraped products and search results with full data.

## `resultsCSV` (type: `string`):

CSV format for spreadsheet analysis.

# 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 = {
    "productUrls": [
        "https://shop.tiktok.com/view/product/1729382355331745106"
    ],
    "searchKeywords": [
        "face cream"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/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 = {
    "productUrls": ["https://shop.tiktok.com/view/product/1729382355331745106"],
    "searchKeywords": ["face cream"],
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/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 '{
  "productUrls": [
    "https://shop.tiktok.com/view/product/1729382355331745106"
  ],
  "searchKeywords": [
    "face cream"
  ]
}' |
apify call silentflow/tiktok-shop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Shop Scraper",
        "description": "Extract TikTok Shop product data at scale: prices, variants, ratings, reviews, sold counts, seller details, shipping and images. Search the catalog by keyword or scrape products by URL across US, UK and other markets. Ideal for dropshipping research, price monitoring and competitor analysis.",
        "version": "1.0",
        "x-build-id": "668gJcbcHvUPLW47B"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~tiktok-shop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-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/silentflow~tiktok-shop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-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/silentflow~tiktok-shop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-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": {
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "TikTok Shop product URLs to scrape in full detail (price, variants, reviews, shipping).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchKeywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search the TikTok Shop catalog. Returns matching products (title, price, rating, sold count, URL) you can then scrape in detail via Product URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "us",
                            "gb",
                            "sg",
                            "id",
                            "my",
                            "th",
                            "vn",
                            "ph"
                        ],
                        "type": "string",
                        "description": "TikTok Shop market. Auto-detected from the URL when present.",
                        "default": "us"
                    },
                    "clearanceCookie": {
                        "title": "Clearance cookie",
                        "type": "string",
                        "description": "Optional anti-bot clearance cookie if the actor is challenged."
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Log extra diagnostics for troubleshooting. Leave off for normal runs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
