# Tiktok Shop Scraper (`clockworks/tiktok-shop-scraper`) Actor

- **URL**: https://apify.com/clockworks/tiktok-shop-scraper.md
- **Developed by:** [Clockworks](https://apify.com/clockworks) (Apify)
- **Categories:** E-commerce, Social media, Videos
- **Stats:** 3 total users, 0 monthly users, 97.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $13.00 / 1,000 products

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.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

### 🛒 What is TikTok Shop Scraper?

TikTok Shop Scraper lets you **extract product listings from TikTok Shop by keyword**. Point it at any search term and it returns structured product data directly from `shop.tiktok.com`, including pricing, seller details, sales volume, and images.

For each product you get:

🛍️ **Product details:** product ID, listing title, product page URL

💰 **Pricing:** min/max price and currency from the API

🏪 **Seller info:** seller ID, name, and logo

📦 **Sales metrics:** units sold count and display text (e.g. "1.2K+ sold")

🖼️ **Images:** primary product image URL list

🔖 **SKU variants:** raw SKU info as returned by the TikTok Shop API

### 🛒 How can I use TikTok Shop data?

Product data from TikTok Shop is valuable for a wide range of use cases:

🔍 **Product research** — discover what is selling well on TikTok Shop for a given niche or category

📊 **Competitor analysis** — monitor competitor listings, pricing, and sales volume over time

💹 **Price monitoring** — track price changes across sellers for the same or similar products

🧪 **Market research** — identify trending products, top sellers, and popular categories

📣 **Influencer & affiliate research** — find products that are gaining traction to inform content or affiliate strategies

### 🛒 How do I export TikTok Shop product data?

1. [Create](https://console.apify.com/sign-up) a free Apify account using your email.
2. Open [TikTok Shop Scraper](https://apify.com/clockworks/tiktok-Shop-scraper).
3. Enter a search keyword and configure the number of pages to scrape.
4. Click "Start" and wait for the scraper to finish.
5. Download your results in JSON, CSV, Excel, XML, or HTML.

> **Note:** TikTok Shop is geofenced to the United States and is protected by a captcha. A US residential proxy is required and is pre-configured in the default settings.

### ⬇ Input

The only required input is a **search keyword**. Optionally adjust the number of pages and proxy settings.

Click on the [input tab](https://apify.com/clockworks/tiktok-Shop-scraper/input-schema) for a full explanation of every field.

```json
{
    "keywords": ["phone case"],
    "productsPerSearch": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US"
    }
}
````

| Field                | Type    | Required | Description                                                                                           |
| -------------------- | ------- | -------- | ----------------------------------------------------------------------------------------------------- |
| `keywords`           | array   | ✅       | One or more search queries. Each runs its own captcha→scrape→paginate flow in parallel.               |
| `productsPerSearch`  | integer | —        | Maximum unique products to collect per keyword (after global deduplication). Default: 100, max: 10000 |
| `proxyConfiguration` | object  | ✅       | Apify Proxy config. US residential proxy strongly recommended                                         |

### ⬆ Output sample

Results are saved to the dataset and can be previewed in the **Output** tab. Below is an example item in JSON:

```json
{
    "product_id": "1729623986432218",
    "title": "Phone Case for iPhone 15 Pro Max - Shockproof Clear Cover",
    "seo_url": "https://shop.tiktok.com/us/pdp/phone-case-iphone-15/1729623986432218",
    "product_price_info": {
        "min_price": "599",
        "max_price": "999",
        "currency": "USD"
    },
    "seller_info": {
        "seller_id": "7123456789012345678",
        "seller_name": "TechShop US",
        "seller_logo": "https://p16-oec-va.ibyteimg.com/..."
    },
    "sold_info": {
        "sold_count": 1234,
        "sold_text": "1.2K+ sold"
    },
    "image": {
        "url_list": ["https://p16-oec-va.ibyteimg.com/..."]
    },
    "sku_info": {}
}
```

### 🎵 Want to scrape TikTok content beyond the Shop?

<table>
<tr>
<td><a href="https://apify.com/clockworks/tiktok-scraper">🎶 TikTok Scraper</a></td>
<td><a href="https://apify.com/clockworks/tiktok-video-scraper">📹 TikTok Video Scraper</a></td>
<td><a href="https://apify.com/clockworks/tiktok-profile-scraper">🧛 TikTok Profile Scraper</a></td>
</tr>
<tr>
<td><a href="https://apify.com/clockworks/tiktok-comments-scraper">🎙 TikTok Comments Scraper</a></td>
<td><a href="https://apify.com/clockworks/tiktok-hashtag-scraper">#️⃣ TikTok Hashtag Scraper</a></td>
<td><a href="https://apify.com/clockworks/tiktok-ads-scraper">📢 TikTok Hashtag Analytics</a></td>
</tr>
</table>

### ❓ FAQ

#### Why is a US residential proxy required?

TikTok Shop (`shop.tiktok.com`) is available in the United States and we currently don't support non-US countries. Session establishment is protected by a slider captcha that is IP-pinned — the same IP must be used for the captcha solve and the subsequent API calls. A US residential proxy satisfies both requirements and is pre-configured in the default input.

#### How many products can I scrape per run?

Set `productsPerSearch` to control how many unique products are collected per keyword. The scraper paginates automatically until the limit is reached or TikTok has no more results. With the default of 100 you get up to 100 products per keyword. If a product appears in multiple keyword searches it is only scraped once (global deduplication), so the first keyword to find it gets the credit toward its limit.

#### Is there an official TikTok Shop API?

TikTok offers a [TikTok Shop Partner API](https://partner.tiktokshop.com/) for registered sellers and partners, but it requires approval and is scoped to your own shop data. This scraper accesses the public-facing search results that any visitor in the US can see in a browser — no account or approval is needed.

#### Can I integrate TikTok Shop Scraper with other apps?

Yes. **TikTok Shop Scraper can be connected with almost any cloud service or web app** thanks to <a href="https://apify.com/integrations" target="_blank">integrations on the Apify platform</a>. You can integrate with Make, Zapier, Google Sheets, Google Drive, Slack, Airbyte, and <a href="https://docs.apify.com/integrations" target="_blank">more</a>. You can also use <a href="https://docs.apify.com/integrations/webhooks" target="_blank">webhooks</a> to trigger actions whenever a run completes.

#### Can I use this scraper via the API?

Yes. The Apify API gives you programmatic access to run the actor, retrieve results, and schedule runs. Use the `apify-client` npm package for Node.js or the `apify-client` PyPI package for Python.

Check out the [Apify API reference](https://docs.apify.com/api/v2) or the [API tab](https://apify.com/clockworks/tiktok-Shop-scraper/api) for ready-to-use code examples.

#### Is it legal to scrape TikTok Shop?

This scraper only extracts publicly visible product listings — the same data any visitor in the US sees when browsing `shop.tiktok.com`. It does not extract private user data such as emails, addresses, or payment information. You should be aware that your results may contain business names and seller identifiers.

You can read more about the legality of web scraping on our [blog](https://blog.apify.com/is-web-scraping-legal/) and about [ethical scraping](https://blog.apify.com/what-is-ethical-web-scraping-and-how-do-you-do-it/).

#### Found a bug or have feedback?

Please create an issue on the Actor's [Issue tab](https://console.apify.com/actors/clockworks~tiktok-Shop-scraper/issues) in Apify Console. We're always working to improve reliability and output quality.

# Actor input Schema

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

One or more product search queries to run on shop.tiktok.com.

## `productsPerSearch` (type: `integer`):

Maximum number of unique products to collect per keyword.

## Actor input object example

```json
{
  "keywords": [
    "phone case",
    "wireless earbuds"
  ],
  "productsPerSearch": 10
}
```

# 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": [
        "phone case"
    ],
    "productsPerSearch": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("clockworks/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": ["phone case"],
    "productsPerSearch": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("clockworks/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": [
    "phone case"
  ],
  "productsPerSearch": 10
}' |
apify call clockworks/tiktok-shop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Shop Scraper",
        "description": null,
        "version": "0.0",
        "x-build-id": "7YhdmLfph0PwxKOcZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/clockworks~tiktok-shop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-clockworks-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/clockworks~tiktok-shop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-clockworks-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/clockworks~tiktok-shop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-clockworks-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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "One or more product search queries to run on shop.tiktok.com.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productsPerSearch": {
                        "title": "Products per search keyword",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique products to collect per keyword.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
