# TikTok Shop Seller Catalog (`sentry/tiktok-shop-seller-catalog`) Actor

TikTok Shop seller catalog scraper for extracting store products, prices, ratings, and structured catalog intelligence. Analyze seller assortments, export product-level data, and optionally emit snapshot change rows for added, removed, and price-changed items.

- **URL**: https://apify.com/sentry/tiktok-shop-seller-catalog.md
- **Developed by:** [Sentry](https://apify.com/sentry) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 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.

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 Seller Catalog

**TikTok Shop Seller Catalog** is a high-coverage **TikTok Shop scraper** for extracting **seller catalogs**, **store product lists**, **price ranges**, **ratings**, and **catalog change signals** (added / removed / price changed).

If you are searching for a:
- **TikTok Shop seller scraper**
- **TikTok Shop store catalog scraper**
- **TikTok Shop product list extractor**
- **TikTok Shop price tracker by store**
- **TikTok Shop competitor product scraper**
- **TikTok Shop catalog monitoring tool**

this actor is designed for that exact workflow.

### TikTok Shop Data You Can Extract

This actor collects structured TikTok Shop seller/store data with export-ready rows for analytics, lead generation, market research, and competitive intelligence.

Main fields include:
- product ID and product title
- product URL and source URL
- seller/store and brand
- min price, max price, avg price, real price
- rating score and review count
- rank on page and rank global
- query context and crawl metadata
- optional raw product payload

It can also persist snapshot state and emit catalog diffs:
- `added`
- `removed`
- `price_changed`

### Best Use Cases (Buyer Intent)

1. **TikTok Shop competitor analysis**
- Monitor competitor seller assortments, pricing movement, and listing churn.

2. **TikTok Shop product research**
- Export seller catalogs for niche validation, sourcing ideas, and SKU benchmarking.

3. **TikTok Shop catalog monitoring**
- Track new listings, removed listings, and price changes across recurring runs.

4. **TikTok Shop agency reporting**
- Deliver weekly/monthly seller snapshots for clients with structured CSV/JSON outputs.

5. **TikTok Shop ecommerce intelligence**
- Build dashboards for pricing bands, rating distributions, and catalog depth by seller.

6. **TikTok Shop store scraping at scale**
- Run one or many sellers/stores with region-aware search and retry controls.

### Output Row Types

- `store_product`
- `store_change`
- `store_summary`

#### `store_product`
Current-run product rows for the matched seller/store catalog.

#### `store_change`
Snapshot diff rows with:
- `added`
- `removed`
- `price_changed`

#### `store_summary`
Per-store summary including pages visited, matched products, and change counts.

### Input Parameters

### Required

- `stores`
  - Seller names and/or TikTok Shop store URLs.

### Collection Controls

- `queries`
- `searchRegion`
- `maxPagesPerStore`
- `maxProductsPerStore`
- `maxQueriesPerStore`

### Output Controls

- `includeRawProduct`
- `compactNullFields`

### Snapshot / Change Tracking Controls

- `enableSnapshotDiff`
- `emitStoreSummary`
- `emitStoreSummaryOnBlockedZero`
- `emitChangeRows`
- `emitRemovedChanges`
- `maxChangeRowsPerStore`
- `minConsecutiveMissesForRemoved`
- `minPresenceRunsForRemoved`
- `snapshotKeyPrefix`
- `stateStoreName`

### Reliability / Retry Controls

- `requestTimeoutSec`
- `maxFetchRetries`
- `queryRetryAttempts`
- `allowDirectRescueOnSoftBlock`
- `enableBrowserFallback`
- `browserFallbackWaitMs`
- `failOnZeroAfterRetries`

### Proxy Controls

- `proxyConfiguration`

### Example Input

```json
{
  "stores": [
    "Sweet Furniture",
    "https://www.tiktok.com/shop/store/dowinx"
  ],
  "queries": ["office chair", "ergonomic chair"],
  "searchRegion": "US",
  "maxPagesPerStore": 3,
  "maxProductsPerStore": 200,
  "maxQueriesPerStore": 2,
  "includeRawProduct": true,
  "compactNullFields": true,
  "enableSnapshotDiff": true,
  "emitStoreSummary": true,
  "emitChangeRows": true,
  "emitRemovedChanges": true,
  "maxFetchRetries": 3,
  "queryRetryAttempts": 3,
  "stateStoreName": "tiktok-shop-seller-catalog-state"
}
````

### Recommended Defaults for Most Users

- `maxPagesPerStore`: `3`
- `maxProductsPerStore`: `200`
- `maxQueriesPerStore`: `2`
- `maxFetchRetries`: `3`
- `queryRetryAttempts`: `3`
- `compactNullFields`: `true`

Enable snapshot diff when you need recurring store monitoring and historical change detection.

### Practical Workflow

1. Add one or multiple TikTok Shop stores.
2. Set market/region and page/product caps.
3. Run baseline extraction.
4. Enable snapshot diff for ongoing catalog monitoring.
5. Export dataset to CSV/JSON and plug into BI or sheets.

### Why This TikTok Shop Scraper

- Built specifically for **seller catalog extraction**, not generic social crawl noise.
- Supports both **store URLs** and **seller name inputs**.
- Provides **current rows + change rows + summary rows**.
- Works for both one-off data pulls and recurring monitoring runs.
- Structured output designed for downstream analysis and automation.

### Common Questions

#### Does this scrape TikTok Shop seller products?

Yes. It extracts structured catalog rows from TikTok Shop seller/store surfaces.

#### Can I monitor added and removed products over time?

Yes. Use snapshot diff controls (`enableSnapshotDiff`, `emitChangeRows`, `emitRemovedChanges`).

#### Can I track price changes for a store catalog?

Yes. Price deltas are emitted with `change_type: price_changed` when snapshot diff is enabled.

#### Can I use multiple stores in one run?

Yes. Pass multiple values in `stores`.

#### Is this useful for competitor research?

Yes. This actor is designed for TikTok Shop competitor catalog and pricing analysis.

### SEO Long-Tail Coverage (High Intent)

- TikTok Shop seller catalog scraper
- TikTok Shop store catalog scraper
- TikTok Shop product list extractor
- TikTok Shop seller product scraper
- TikTok Shop seller data export
- TikTok Shop competitor product monitoring
- TikTok Shop competitor pricing tracker
- TikTok Shop catalog change tracker
- TikTok Shop added removed product monitor
- TikTok Shop product price change scraper
- TikTok Shop seller intelligence tool
- TikTok Shop market research scraper
- TikTok Shop ecommerce analytics data
- TikTok Shop product research dataset
- TikTok Shop store assortment analysis
- TikTok Shop seller catalog API alternative
- TikTok Shop store product CSV export
- TikTok Shop product rating review export
- TikTok Shop seller scraping tool for agencies
- TikTok Shop seller monitoring for brands
- TikTok Shop catalog surveillance tool
- TikTok Shop listing churn tracker
- TikTok Shop seller benchmarking scraper
- TikTok Shop category pricing intelligence
- TikTok Shop structured data extractor

### Who Uses This

- ecommerce operators
- growth teams
- marketplace analysts
- competitor intelligence teams
- agency reporting teams
- brand research teams
- sourcing and product scouting teams

### Notes

- Output volume can vary by market conditions, availability, and anti-bot surface responses.
- For recurring monitoring, keep input settings consistent run-to-run.
- If you need longitudinal tracking, keep `stateStoreName` stable.

### Positioning

This actor is focused on **TikTok Shop seller/store catalog intelligence** and **export-ready structured data** for teams that need actionable outputs, not noisy raw crawl logs.

If your goal is to scrape TikTok Shop seller catalogs, monitor product changes, and track pricing movement with practical controls, this is built for that use case.

# Actor input Schema

## `stores` (type: `array`):

TikTok Shop seller names or store URLs. The actor extracts matching catalog products and returns structured product rows per seller.

## `queries` (type: `array`):

Optional search terms used for discovery. If empty, each store name is used as its own query hint.

## `searchRegion` (type: `string`):

Region parameter sent to TikTok Shop search pages (for example: US, GB).

## `maxPagesPerStore` (type: `integer`):

Maximum number of search-result pages scanned per store query path.

## `maxProductsPerStore` (type: `integer`):

Maximum number of unique matched products emitted per store in one run.

## `maxQueriesPerStore` (type: `integer`):

How many query hints are used per store during a run.

## `includeRawProduct` (type: `boolean`):

Include the full raw product object in each product row.

## `compactNullFields` (type: `boolean`):

If true, null/undefined fields are omitted from output rows.

## `enableSnapshotDiff` (type: `boolean`):

Store per-seller snapshots in key-value storage and detect additions/removals/price changes against the previous run.

## `emitStoreSummary` (type: `boolean`):

Push one store\_summary row per monitored store.

## `emitChangeRows` (type: `boolean`):

Push store\_change rows for added/removed/price\_changed products.

## `emitRemovedChanges` (type: `boolean`):

Emit removed change rows after confirmation thresholds are met.

## `maxChangeRowsPerStore` (type: `integer`):

Safety cap for emitted change rows per change type per store.

## `minConsecutiveMissesForRemoved` (type: `integer`):

Emit a removed change only after a product is missing for this many consecutive runs (reduces false removals).

## `minPresenceRunsForRemoved` (type: `integer`):

Product must be seen in at least this many runs before it can emit a removed change.

## `snapshotKeyPrefix` (type: `string`):

KVS key prefix used to store per-store snapshots.

## `stateStoreName` (type: `string`):

Named key-value store used to persist snapshots across runs for change detection.

## `requestTimeoutSec` (type: `integer`):

HTTP request timeout for each page request.

## `maxFetchRetries` (type: `integer`):

How many HTTP fetch attempts to try per page before giving up.

## `queryRetryAttempts` (type: `integer`):

How many full retries to run per store query when blocked/failure signals produce zero matched products.

## `allowDirectRescueOnSoftBlock` (type: `boolean`):

When proxy pages are soft-blocked, try one direct (no-proxy) fetch rescue before giving up that page.

## `enableBrowserFallback` (type: `boolean`):

If blocked/challenged and extraction is empty, try a lightweight Playwright fallback.

## `browserFallbackWaitMs` (type: `integer`):

How long browser fallback waits after page load before reading HTML.

## `failOnZeroAfterRetries` (type: `boolean`):

If true, fail run when all monitored stores return zero matched products after retries under blocked conditions.

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

Choose proxy type and settings (Apify Proxy residential/datacenter or custom proxies).

## Actor input object example

```json
{
  "stores": [
    "Sweet Furniture",
    "https://www.tiktok.com/shop/store/dowinx"
  ],
  "searchRegion": "US",
  "maxPagesPerStore": 3,
  "maxProductsPerStore": 200,
  "maxQueriesPerStore": 2,
  "includeRawProduct": true,
  "compactNullFields": true,
  "enableSnapshotDiff": true,
  "emitStoreSummary": true,
  "emitChangeRows": true,
  "emitRemovedChanges": true,
  "maxChangeRowsPerStore": 250,
  "minConsecutiveMissesForRemoved": 2,
  "minPresenceRunsForRemoved": 2,
  "snapshotKeyPrefix": "SELLER_CATALOG_SNAPSHOT",
  "stateStoreName": "tiktok-shop-seller-catalog-state",
  "requestTimeoutSec": 30,
  "maxFetchRetries": 3,
  "queryRetryAttempts": 3,
  "allowDirectRescueOnSoftBlock": true,
  "enableBrowserFallback": false,
  "browserFallbackWaitMs": 8000,
  "failOnZeroAfterRetries": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "countryCode": "US",
    "apifyProxyCountry": "US",
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "groups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "stores": [
        "Sweet Furniture",
        "https://www.tiktok.com/shop/store/dowinx"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sentry/tiktok-shop-seller-catalog").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 = { "stores": [
        "Sweet Furniture",
        "https://www.tiktok.com/shop/store/dowinx",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sentry/tiktok-shop-seller-catalog").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 '{
  "stores": [
    "Sweet Furniture",
    "https://www.tiktok.com/shop/store/dowinx"
  ]
}' |
apify call sentry/tiktok-shop-seller-catalog --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Shop Seller Catalog",
        "description": "TikTok Shop seller catalog scraper for extracting store products, prices, ratings, and structured catalog intelligence. Analyze seller assortments, export product-level data, and optionally emit snapshot change rows for added, removed, and price-changed items.",
        "version": "1.0",
        "x-build-id": "HplSfVe0AN218MrIl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sentry~tiktok-shop-seller-catalog/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sentry-tiktok-shop-seller-catalog",
                "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/sentry~tiktok-shop-seller-catalog/runs": {
            "post": {
                "operationId": "runs-sync-sentry-tiktok-shop-seller-catalog",
                "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/sentry~tiktok-shop-seller-catalog/run-sync": {
            "post": {
                "operationId": "run-sync-sentry-tiktok-shop-seller-catalog",
                "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": [
                    "stores"
                ],
                "properties": {
                    "stores": {
                        "title": "Sellers / Stores To Analyze",
                        "type": "array",
                        "description": "TikTok Shop seller names or store URLs. The actor extracts matching catalog products and returns structured product rows per seller.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "queries": {
                        "title": "Optional Search Queries",
                        "type": "array",
                        "description": "Optional search terms used for discovery. If empty, each store name is used as its own query hint.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchRegion": {
                        "title": "Search Region",
                        "type": "string",
                        "description": "Region parameter sent to TikTok Shop search pages (for example: US, GB).",
                        "default": "US"
                    },
                    "maxPagesPerStore": {
                        "title": "Max Pages Per Seller",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of search-result pages scanned per store query path.",
                        "default": 3
                    },
                    "maxProductsPerStore": {
                        "title": "Max Products Per Seller",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of unique matched products emitted per store in one run.",
                        "default": 200
                    },
                    "maxQueriesPerStore": {
                        "title": "Max Queries Per Seller",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many query hints are used per store during a run.",
                        "default": 2
                    },
                    "includeRawProduct": {
                        "title": "Include Raw Product Payload",
                        "type": "boolean",
                        "description": "Include the full raw product object in each product row.",
                        "default": true
                    },
                    "compactNullFields": {
                        "title": "Compact Null Fields",
                        "type": "boolean",
                        "description": "If true, null/undefined fields are omitted from output rows.",
                        "default": true
                    },
                    "enableSnapshotDiff": {
                        "title": "Enable Catalog Snapshot Diff (Optional)",
                        "type": "boolean",
                        "description": "Store per-seller snapshots in key-value storage and detect additions/removals/price changes against the previous run.",
                        "default": true
                    },
                    "emitStoreSummary": {
                        "title": "Emit Seller Summary Rows",
                        "type": "boolean",
                        "description": "Push one store_summary row per monitored store.",
                        "default": true
                    },
                    "emitChangeRows": {
                        "title": "Emit Catalog Change Rows",
                        "type": "boolean",
                        "description": "Push store_change rows for added/removed/price_changed products.",
                        "default": true
                    },
                    "emitRemovedChanges": {
                        "title": "Emit Removed Changes",
                        "type": "boolean",
                        "description": "Emit removed change rows after confirmation thresholds are met.",
                        "default": true
                    },
                    "maxChangeRowsPerStore": {
                        "title": "Max Change Rows Per Seller",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Safety cap for emitted change rows per change type per store.",
                        "default": 250
                    },
                    "minConsecutiveMissesForRemoved": {
                        "title": "Consecutive Misses For Removed",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Emit a removed change only after a product is missing for this many consecutive runs (reduces false removals).",
                        "default": 2
                    },
                    "minPresenceRunsForRemoved": {
                        "title": "Min Presence Runs For Removed",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Product must be seen in at least this many runs before it can emit a removed change.",
                        "default": 2
                    },
                    "snapshotKeyPrefix": {
                        "title": "Snapshot Key Prefix",
                        "type": "string",
                        "description": "KVS key prefix used to store per-store snapshots.",
                        "default": "SELLER_CATALOG_SNAPSHOT"
                    },
                    "stateStoreName": {
                        "title": "State Store Name",
                        "type": "string",
                        "description": "Named key-value store used to persist snapshots across runs for change detection.",
                        "default": "tiktok-shop-seller-catalog-state"
                    },
                    "requestTimeoutSec": {
                        "title": "Request Timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "HTTP request timeout for each page request.",
                        "default": 30
                    },
                    "maxFetchRetries": {
                        "title": "Max Fetch Retries",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many HTTP fetch attempts to try per page before giving up.",
                        "default": 3
                    },
                    "queryRetryAttempts": {
                        "title": "Full Query Retry Attempts",
                        "minimum": 2,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many full retries to run per store query when blocked/failure signals produce zero matched products.",
                        "default": 3
                    },
                    "allowDirectRescueOnSoftBlock": {
                        "title": "Allow Direct Rescue On Soft-Block",
                        "type": "boolean",
                        "description": "When proxy pages are soft-blocked, try one direct (no-proxy) fetch rescue before giving up that page.",
                        "default": true
                    },
                    "enableBrowserFallback": {
                        "title": "Enable Browser Fallback On Block",
                        "type": "boolean",
                        "description": "If blocked/challenged and extraction is empty, try a lightweight Playwright fallback.",
                        "default": false
                    },
                    "browserFallbackWaitMs": {
                        "title": "Browser Fallback Wait (ms)",
                        "minimum": 1000,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "How long browser fallback waits after page load before reading HTML.",
                        "default": 8000
                    },
                    "failOnZeroAfterRetries": {
                        "title": "Fail Run If Zero After Retries",
                        "type": "boolean",
                        "description": "If true, fail run when all monitored stores return zero matched products after retries under blocked conditions.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Choose proxy type and settings (Apify Proxy residential/datacenter or custom proxies).",
                        "default": {
                            "useApifyProxy": true,
                            "countryCode": "US",
                            "apifyProxyCountry": "US",
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "groups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
