# TikTok Shop Winning Products Finder & Sales Tracker (`crashlattice57/tiktok-shop-winning-products`) Actor

Find TikTok Shop winning products by keyword, score each 0-100, and track sold count, sales velocity, movers, and price changes between runs. A pay-per-use Kalodata alternative for product research.

- **URL**: https://apify.com/crashlattice57/tiktok-shop-winning-products.md
- **Developed by:** [MooreIQ](https://apify.com/crashlattice57) (community)
- **Categories:** E-commerce, Social media, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 product scanneds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## TikTok Shop Winning Products Finder & Sales Tracker

Type a niche, get the top-selling TikTok Shop products ranked by a transparent 0-100 opportunity score; schedule weekly runs to track real sales velocity.

![TikTok Shop winning products ranked by a 0-100 opportunity score](https://api.apify.com/v2/key-value-stores/lWqW7ECIEEBVzg9SA/records/tiktok-hero.png)

Use it for TikTok Shop product research, winning products, best sellers, dropshipping product research, and repeatable TikTok Shop sales tracker reports. Results include public sold count data and direct product links.

### Type a niche and run

Add one or more product searches such as `kitchen gadgets`, `pet accessories`, or `skincare tools`. The actor searches the US TikTok Shop storefront, combines duplicate products, applies your filters, scores each result, and ranks the products.

The default collects up to 50 products per keyword. Detail enrichment and repeat-run tracking are optional.

### What you get

Each product record contains the fields needed to compare demand, velocity, price, quality, and seller competition.

| Field | What it tells you |
| --- | --- |
| Rank | Position after sorting by opportunity score. |
| Score | Transparent opportunity score from 0 to 100. |
| Sold count | TikTok's public cumulative sales figure. |
| Sold per day | Estimated daily sales since the previous run. |
| Price | Current listed product price. |
| Rating | Public product rating. |
| Reviews | Public review count. |
| Seller | Seller name and identifier. |
| Mover flag | Whether sales velocity qualifies the product as a mover. |
| New entry flag | Whether the product is new since the previous snapshot. |
| Product url | Direct TikTok Shop product page. |

Records also include title, product ID, original price, currency, sold delta, price change, brand, image, matched keywords, and the complete score breakdown. Optional enrichment can add description, breadcrumbs, gallery images, and seller statistics.

### How the score works

Every product receives a 0-100 opportunity score built from 6 components:

| Component | Weight |
| --- | ---: |
| Demand | 30 |
| Momentum | 20 |
| Quality | 15 |
| Impulse price band | 15 |
| Competition | 10 |
| Discount depth | 10 |

Demand rewards established sold count. Momentum uses tracked sold per day when history is available. Quality uses rating and review evidence. The impulse price band measures fit with a purchase-friendly price range. Competition accounts for seller concentration. Discount depth measures the gap between original and current price.

Every record includes the component breakdown, so the final score can be audited instead of treated as a hidden ranking.

### Sales velocity tracking

The first run creates a baseline snapshot. Every later run with the same `trackingName` computes sold per day, price changes, new entries, dropouts, and movers.

![TikTok Shop sales velocity, movers, and sold-count deltas tracked between runs](https://api.apify.com/v2/key-value-stores/lWqW7ECIEEBVzg9SA/records/tiktok-velocity.png)

This works with Apify Schedules. Schedule the actor weekly, keep the same input, and you are done.

The summary record identifies first runs, reports changes, and lists products that dropped out. This turns a one-time winning products search into a repeatable TikTok Shop sales tracker.

### Input

Only `keywords` is required. The fields below match the actor input schema.

| Field | Required | What it is |
| --- | --- | --- |
| `keywords` | Yes | Array of niches or product searches. Enter at least 1 non-empty keyword. Prefill: `kitchen gadgets`. |
| `maxProductsPerKeyword` | No | Maximum products collected per keyword. Minimum 1, maximum 200, default 50, prefill 20. |
| `enrichDetails` | No | Fetch each product's full detail page. Default and prefill: false. |
| `trackingName` | No | Name of the sales-velocity tracking store. Leave empty to derive it from the keywords. Reuse the same value for tracked comparisons. |
| `minRating` | No | Include only products at or above this rating. |
| `priceMin` | No | Include only products priced at or above this amount. |
| `priceMax` | No | Include only products priced at or below this amount. |
| `region` | No | Storefront region. The only supported and default value in v1 is `US`. |

#### Example input

```json
{
  "keywords": ["kitchen gadgets", "meal prep tools", "drinkware"],
  "maxProductsPerKeyword": 50,
  "enrichDetails": false,
  "trackingName": "weekly-kitchen-products",
  "minRating": 4.2,
  "priceMin": 10,
  "priceMax": 60,
  "region": "US"
}
````

### Pricing example

At $0.004 per product scanned, 3 keywords times 50 products costs $0.60 per run before optional events. Detail enrichment costs $0.002 per enriched product. Tracked deltas cost $0.005 per product when a previous snapshot makes a delta available.

Kalodata plans are listed at about $46 to $110 per month. This actor is not a Kalodata clone. It covers keyword-level winner discovery and sales velocity, not creator analytics. It can serve as a focused Kalodata alternative when the task is finding products by keyword and tracking their public sales changes without a monthly research suite.

Actual product counts can be lower because TikTok search depth varies and duplicate products across keywords are combined.

### Who uses it

- Ecommerce operators researching TikTok Shop best sellers by niche
- Dropshipping teams doing product research with sold count and price filters
- Analysts comparing transparent opportunity scores across product searches
- Sellers tracking weekly sales velocity, movers, new entries, and dropouts
- Agencies exporting ranked product data to JSON, CSV, or Excel

### FAQ

**Which storefront is supported?**

The US storefront only is supported in v1.

**Where do sold counts come from?**

Sold counts are TikTok's public figures shown in its storefront data. They are not private merchant sales records.

**How many products can one keyword return?**

Keyword search usually caps around 30 to 60 products per keyword because of TikTok SERP depth. Setting `maxProductsPerKeyword` above that limit cannot create additional search results.

**Does this actor use a TikTok login or cookies?**

No. It uses no login or user-provided cookies.

**What happens on the first tracked run?**

The first run stores a baseline snapshot. Sold per day and change fields become available on later runs that use the same `trackingName`.

**Can I schedule tracking?**

Yes. Create an Apify Schedule, run weekly with the same input and `trackingName`, and review each dataset for deltas and movers.

**Is this a full Kalodata replacement?**

No. It handles keyword-level TikTok Shop product research, opportunity scoring, and public sales velocity. It does not provide creator analytics or the full feature set of a subscription analytics platform.

### Also by this developer

See more actors by this developer at [crashlattice57 on Apify](https://apify.com/crashlattice57), including the geo-grid rank tracker.

# Actor input Schema

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

Enter one search per keyword to find winning products in each niche.

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

Maximum number of products to collect for each keyword; keeps the TOP N products by sold count, with the prefill kept small for quick test runs.

## `enrichDetails` (type: `boolean`):

Fetch each product's full detail page (adds the Detail enrichment event per product)

## `trackingName` (type: `string`):

Name for the sales-velocity tracking store. Leave empty to auto-derive from your keywords. Runs with the same trackingName compute sold/day velocity, price changes, new entries and movers.

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

Only include products with at least this rating.

## `priceMin` (type: `number`):

Only include products priced at or above this amount.

## `priceMax` (type: `number`):

Only include products priced at or below this amount.

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

v1 supports the US storefront (keyword search only works on US)

## Actor input object example

```json
{
  "keywords": [
    "kitchen gadgets"
  ],
  "maxProductsPerKeyword": 20,
  "enrichDetails": false,
  "region": "US"
}
```

# Actor output Schema

## `results` (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": [
        "kitchen gadgets"
    ],
    "maxProductsPerKeyword": 20,
    "enrichDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("crashlattice57/tiktok-shop-winning-products").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": ["kitchen gadgets"],
    "maxProductsPerKeyword": 20,
    "enrichDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("crashlattice57/tiktok-shop-winning-products").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": [
    "kitchen gadgets"
  ],
  "maxProductsPerKeyword": 20,
  "enrichDetails": false
}' |
apify call crashlattice57/tiktok-shop-winning-products --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Shop Winning Products Finder & Sales Tracker",
        "description": "Find TikTok Shop winning products by keyword, score each 0-100, and track sold count, sales velocity, movers, and price changes between runs. A pay-per-use Kalodata alternative for product research.",
        "version": "0.0",
        "x-build-id": "8jkdHQA2iz0KFSyLg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crashlattice57~tiktok-shop-winning-products/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crashlattice57-tiktok-shop-winning-products",
                "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/crashlattice57~tiktok-shop-winning-products/runs": {
            "post": {
                "operationId": "runs-sync-crashlattice57-tiktok-shop-winning-products",
                "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/crashlattice57~tiktok-shop-winning-products/run-sync": {
            "post": {
                "operationId": "run-sync-crashlattice57-tiktok-shop-winning-products",
                "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": "Niches or product searches",
                        "type": "array",
                        "description": "Enter one search per keyword to find winning products in each niche.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProductsPerKeyword": {
                        "title": "Maximum products per keyword",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of products to collect for each keyword; keeps the TOP N products by sold count, with the prefill kept small for quick test runs.",
                        "default": 50
                    },
                    "enrichDetails": {
                        "title": "Enrich product details",
                        "type": "boolean",
                        "description": "Fetch each product's full detail page (adds the Detail enrichment event per product)",
                        "default": false
                    },
                    "trackingName": {
                        "title": "Tracking name",
                        "type": "string",
                        "description": "Name for the sales-velocity tracking store. Leave empty to auto-derive from your keywords. Runs with the same trackingName compute sold/day velocity, price changes, new entries and movers."
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "type": "number",
                        "description": "Only include products with at least this rating."
                    },
                    "priceMin": {
                        "title": "Minimum price",
                        "type": "number",
                        "description": "Only include products priced at or above this amount."
                    },
                    "priceMax": {
                        "title": "Maximum price",
                        "type": "number",
                        "description": "Only include products priced at or below this amount."
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "US"
                        ],
                        "type": "string",
                        "description": "v1 supports the US storefront (keyword search only works on US)",
                        "default": "US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
