# TikTok Shop Product Scraper & Viral Radar (`nexascout/tiktok-shop-product-radar`) Actor

Scrape live TikTok Shop products by keyword or URL. Extract prices, sales, ratings, reviews, sellers, discounts, and images, then rank opportunities with a transparent viral score. Export verified results to JSON, CSV, Excel, or API—no external data provider required.

- **URL**: https://apify.com/nexascout/tiktok-shop-product-radar.md
- **Developed by:** [Scout](https://apify.com/nexascout) (community)
- **Categories:** Social media, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 product results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Product Scraper & Viral Radar

Discover public TikTok Shop products by keyword or scrape current product-detail URLs, normalize the commerce data, and rank opportunities with a transparent viral score. By default, every billable dataset row is a live verified product.

This Actor owns its extraction pipeline. It does **not** call another Apify Actor, a third-party scraping API, or a publisher-owned data account. It requests public TikTok Shop pages directly through the proxy configuration selected by the Actor user.

The current release supports the US TikTok Shop. TikTok changes its public website and anti-bot checks frequently, so every row includes source and quality diagnostics instead of silently returning fabricated or stale values.

### For AI agents and MCP clients

Use this Actor when the user asks to **find or scrape current TikTok Shop products** by keyword or product URL and needs prices, sold counts, ratings, reviews, sellers, discounts, images, or a snapshot `viralScore`.

- **Actor tool ID:** `nexascout/tiktok-shop-product-radar`
- **Minimum keyword input:** `{"searchQueries":["car accessories"],"maxProductsPerQuery":3}`
- **Minimum URL input:** `{"productUrls":[{"url":"https://shop.tiktok.com/us/pdp/..."}]}`
- **Dataset contract:** one billable row per current product
- **Run summary:** `OUTPUT` in the default key-value store
- **Do not use for:** changes over time, estimated daily sales, creator discovery, private contacts, or private affiliate commission data

For deterministic tool availability, connect an MCP client to the [NexaScout three-Actor endpoint](https://mcp.apify.com?tools=nexascout/tiktok-shop-product-radar,nexascout/tiktok-shop-trending-products,nexascout/tiktok-shop-affiliate-creator-finder). The client can inspect this Actor's input and output schemas before calling it.

### Choose the right NexaScout Actor

| User intent | Actor |
| --- | --- |
| Current product discovery, commerce fields, and snapshot viral ranking | **This Actor — Product Scraper & Viral Radar** |
| Recurring observations, sold-count growth, price/review changes, and sales velocity | [Trend Tracker & Sales Velocity](https://apify.com/nexascout/tiktok-shop-trending-products) |
| Public creators, product videos, engagement metrics, and association evidence | [Affiliate Creator & Video Finder](https://apify.com/nexascout/tiktok-shop-affiliate-creator-finder) |

### Why use this Actor

- **Keyword discovery and direct product URLs** in one Actor
- **Owned extraction pipeline** with no nested paid Actors or third-party TikTok data APIs
- **Verified-only output by default**; optional search-index leads are clearly labeled when explicitly enabled
- **Transparent opportunity scoring** with both a 0–100 score and human-readable signals
- **Automation-ready datasets** for Apify API, schedules, webhooks, Make, Zapier, and n8n

### What you get

- Product name, ID, canonical PDP URL, image, description, and category
- Current and original price, currency, and discount
- Public total and 30-day sales signals when TikTok exposes them
- Estimated 30-day GMV (`price × public 30-day sales`), clearly labeled as an estimate
- Rating, review count, seller name, and seller ID
- A deterministic 0–100 `viralScore` and readable reasons behind it
- Source provenance and a data-quality label on every row

| Quality state | Meaning |
| --- | --- |
| `verified_success` | Structured TikTok data and at least one live commerce field were captured. |
| `partial_verified` | The product was confirmed, but only part of its commerce data was available. |
| `serp_enriched` | The URL was discovered from a public search page. It is returned only when `includeSearchFallbacks` is enabled. |

### How the owned pipeline works

1. Canonicalize both current and legacy links to the regional storefront at `https://shop.tiktok.com/{region}/pdp/{productId}`.
2. Make a lightweight direct HTTP request through a sticky proxy session.
3. Parse JSON-LD and TikTok state scripts such as `__UNIVERSAL_DATA_FOR_REHYDRATION__`.
4. If HTTP data is incomplete, open the same public page in Playwright.
5. Capture product/search JSON returned to the page by TikTok and combine it with visible metadata.
6. Preserve cookies per proxy session; retire a session on 403, 429, or a security challenge.
7. For keyword runs, scrape TikTok's public `/k/{keyword}` shopping catalog first and try common first-party `-products` / `-solutions` slug variants when the exact page does not exist. Only if TikTok's catalog cannot fill the request, use bounded search/browser discovery as a fallback.
8. Reject structured catalog items with no meaningful keyword overlap before ranking or writing the dataset.

The browser blocks video and fonts while allowing normal storefront images. It does not solve CAPTCHAs, log into TikTok, or access private data.

### Input examples

Direct product:

```json
{
  "productUrls": [
    {
      "url": "https://shop.tiktok.com/us/pdp/goli-ashwagandha-gummies-with-vitamin-d-ksm-66-vegan-non-gmo/1729587769570529799"
    }
  ],
  "region": "US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

Keyword discovery:

```json
{
  "searchQueries": ["car accessories", "kitchen gadgets"],
  "region": "US",
  "maxProductsPerQuery": 10,
  "sortBy": "VIRAL_SCORE",
  "includeSearchFallbacks": false,
  "maxConcurrency": 2
}
```

You can combine direct URLs and search queries. Product IDs are deduplicated automatically.
By default, keyword datasets contain only products whose live TikTok PDP was validated. Turn on `includeSearchFallbacks` only when you also want unverified search-index leads.

### Example output

```json
{
  "productId": "1729587769570529799",
  "productName": "Example TikTok Shop product",
  "productUrl": "https://shop.tiktok.com/us/pdp/1729587769570529799",
  "imageUrl": "https://example.com/product.jpg",
  "price": 33.99,
  "originalPrice": 49.99,
  "currency": "USD",
  "discountPercent": 32,
  "salesTotal": 205900,
  "sales30d": 12400,
  "estimatedGmv30d": 421476,
  "rating": 4.6,
  "reviewCount": 8100,
  "sellerName": "Example Shop",
  "viralScore": 91.2,
  "viralSignals": [
    "Strong 30-day sales velocity",
    "High review volume",
    "Strong customer rating",
    "Meaningful active discount"
  ],
  "qualityState": "verified_success",
  "dataSource": "tiktok_network_json",
  "searchQuery": null,
  "scrapedAt": "2026-08-24T00:00:00.000Z"
}
```

The values above illustrate the schema. The Actor returns only fields that its public sources expose.

### Viral score

The score uses observed fields only:

- Sales signal: up to 48 points
- Review volume: up to 17 points
- Rating: up to 15 points
- Discount: up to 10 points
- Core-field completeness: up to 5 points
- Verified structured data: up to 5 points

Sales and reviews use logarithmic scaling so a very large incumbent does not flatten every smaller opportunity. The score is a research-ranking signal, not a promise of future sales.

### Pricing and cost notes

The launch price is **$0.0075 per dataset result** ($7.50 per 1,000 results), plus Apify's recommended **$0.00005 Actor-start event per allocated GB**. The normal pricing configuration includes platform usage in these event prices, so users are not presented with a separate compute/proxy bill for this Actor. The default configuration writes only live verified products; if `includeSearchFallbacks` is enabled, its clearly labeled search-only leads are dataset results and are billed as such.

US residential proxy is the recommended default because TikTok Shop is geo-sensitive and often blocks data-center traffic. Product data comes directly from public TikTok pages. The publisher does not maintain a third-party data subscription, and the Actor does not call paid data providers or other Apify Actors.

Keep `maxConcurrency` at 1–2. The launch release defaults to and caps memory at 1 GB to control platform cost while preserving enough headroom for the browser fallback.

Keyword discovery is adaptive: TikTok's own public keyword catalog is preferred, easy queries stop immediately when filled, and difficult queries can inspect up to 50 indexed candidates. Search-only leads remain excluded unless explicitly requested.

### Output and diagnostics

Products are written to the default Apify dataset and can be exported as JSON, CSV, Excel, XML, or RSS. The `OUTPUT` record in the default key-value store contains:

- result and failure counts
- requested, live, search-fallback, and shortfall counts
- data-quality breakdown
- HTTP status/block diagnostics
- confirmation that zero external data APIs and zero external Actors were used
- failed URLs and stages

### Responsible use

This Actor extracts publicly visible product and seller information. Do not use it to collect private data, defeat access controls, or violate applicable laws, contracts, or platform rules. Public metrics can be delayed, rounded, region-specific, or changed by TikTok without notice.

### Current limitations

- US TikTok Shop only
- Availability and fields depend on what TikTok exposes publicly for the selected region
- `sales30d`, GMV, category, and description can be `null` when the public page does not expose them
- Keyword pages may return fewer than requested products for narrow or newly indexed niches

### Support

When reporting an issue, include the run ID, region, input type, failed stage, and `qualityState`. Never post private proxy credentials, cookies, or tokens.

# Actor input Schema

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

Optional direct TikTok Shop PDP URLs for current product data. Current tiktok.com/shop/pdp links and legacy shop.tiktok.com links are accepted. Combine with searchQueries or leave empty for keyword-only discovery.

## `searchQueries` (type: `array`):

Optional product keywords or niches to discover, for example car accessories, skincare serum, or kitchen gadgets. Use at least one search query or product URL; the default query keeps Store and MCP test runs non-empty.

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

TikTok Shop market code. The MVP currently supports the United States.

## `maxProductsPerQuery` (type: `integer`):

Maximum billable dataset rows returned per keyword. The Actor may inspect extra candidates to fill the requested number with live verified products.

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

US residential proxy is the recommended default because TikTok Shop is geo-sensitive and actively rate-limits data-center traffic.

## `maxConcurrency` (type: `integer`):

Keep this at 1–2 to reduce TikTok security challenges and residential proxy traffic.

## `navigationTimeoutSecs` (type: `integer`):

Maximum time allowed for each HTTP or browser navigation.

## `sortBy` (type: `string`):

Controls the final dataset order. VIRAL\_SCORE is recommended for opportunity discovery; this is snapshot ranking, not historical growth.

## `includeRawData` (type: `boolean`):

Include the best raw product object captured from TikTok. Useful for debugging, but makes exports larger.

## `includeSearchFallbacks` (type: `boolean`):

Return indexed product URLs even when the live TikTok page could not be validated. Disabled by default so normal datasets contain only live verified products. When enabled, search-only leads are also billable dataset results.

## Actor input object example

```json
{
  "productUrls": [],
  "searchQueries": [
    "car accessories"
  ],
  "region": "US",
  "maxProductsPerQuery": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "maxConcurrency": 2,
  "navigationTimeoutSecs": 45,
  "sortBy": "VIRAL_SCORE",
  "includeRawData": false,
  "includeSearchFallbacks": false
}
```

# Actor output Schema

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

Default dataset items. Each billable row is one current TikTok Shop product with commerce fields, source quality, and a transparent viral score.

## `runSummary` (type: `string`):

OUTPUT key-value record with requested, verified, fallback, shortfall, failure, and extraction-diagnostic counts.

# 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": [],
    "searchQueries": [
        "car accessories"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexascout/tiktok-shop-product-radar").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": [],
    "searchQueries": ["car accessories"],
}

# Run the Actor and wait for it to finish
run = client.actor("nexascout/tiktok-shop-product-radar").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [],
  "searchQueries": [
    "car accessories"
  ]
}' |
apify call nexascout/tiktok-shop-product-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexascout/tiktok-shop-product-radar"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Wfgc0UKb2QTYyuFht/builds/XCSXQ9LupweLk0lml/openapi.json