# DHgate Product & Supplier Scraper (`automation-lab/dhgate-product-supplier-scraper`) Actor

Extract DHgate wholesale listings with prices, MOQ, sales, ratings, supplier IDs, storefronts, images, coupons, and sourcing context.

- **URL**: https://apify.com/automation-lab/dhgate-product-supplier-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/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

## DHgate Product & Supplier Scraper

Turn DHgate wholesale search pages into clean product and supplier records.

Use keywords or public DHgate category/search URLs to collect current listing prices, sales signals, supplier identities, store links, images, coupons, delivery estimates, and collection context.

The Actor is built for recurring sourcing research rather than one-off copy and paste.

- 🔎 Search DHgate by product keyword
- 🗂️ Extract complete category and search pages
- 💵 Normalize displayed USD price ranges
- 📈 Filter by price and sold count
- 🏪 Connect products to supplier storefronts
- 🔁 Follow pagination with a clear safety cap
- 📤 Export results as JSON, CSV, Excel, XML, or RSS

### What does the DHgate Product & Supplier Scraper do?

The Actor accepts one or more product searches or DHgate wholesale listing URLs.

For every matching card it saves one structured product record with its supplier attributes.

It handles the repetitive work needed to:

- compare wholesale offers;
- build a candidate product catalog;
- identify active suppliers;
- monitor price and assortment changes;
- find products with visible demand;
- prepare source data for ecommerce workflows.

Version 1 is intentionally listing-first.

It does not promise private account data, individual reviews, option-level inventory, or detail-only fields that are absent from public listing pages.

### Who is this DHgate scraper for?

#### Dropshippers

Discover candidate products, compare price ranges, and prioritize offers with visible sales activity.

#### Procurement and sourcing teams

Create repeatable supplier-discovery lists with product IDs, seller IDs, storefronts, and source URLs.

#### Ecommerce catalog builders

Feed product titles, images, pricing, and links into catalog review or enrichment pipelines.

#### Market analysts

Schedule category snapshots to track assortment, merchandising, and popularity signals over time.

#### Agencies and data teams

Deliver structured DHgate exports through Apify API, webhooks, datasets, and integrations.

### Why use this Actor?

DHgate listing pages contain useful sourcing data, but manual collection is slow and difficult to reproduce.

This Actor adds:

- structured records instead of copied text;
- consistent field names across searches and categories;
- global deduplication by DHgate item code;
- numeric price bounds for filtering and analysis;
- input and page caps for predictable runs;
- bounded anti-bot retries instead of infinite loops;
- source context for traceability;
- Apify scheduling and integrations.

### Supported DHgate inputs

You can combine both routes in one run.

#### Search queries

Enter terms such as:

- `wireless earbuds`
- `phone cases`
- `wedding dresses`
- `gaming accessories`

The Actor builds the corresponding public DHgate wholesale search URL.

#### Start URLs

Provide public `dhgate.com` URLs under `/wholesale/`, for example:

```text
https://www.dhgate.com/wholesale/fashion-bags/c107011.html
````

Product-detail URLs are rejected because version 1 has a listing/search contract.

Other domains are rejected to prevent accidental off-target crawling.

### Input options

| Field | Type | Purpose | Default |
|---|---|---|---|
| `searchQueries` | array | DHgate product keyword searches | `wireless earbuds` |
| `startUrls` | array | DHgate wholesale category/search URLs | empty |
| `maxItems` | integer | Global unique product cap | 25 |
| `maxPagesPerSource` | integer | Pagination cap per input | 2 |
| `minPrice` | number | Minimum displayed range price | none |
| `maxPrice` | number | Maximum displayed range price | none |
| `minSold` | integer | Minimum visible sales count | none |
| `proxyConfiguration` | object | Apify proxy settings | US residential |

At least one query or URL is required.

`minPrice` cannot exceed `maxPrice`.

When a filter is active and a listing lacks that value, the listing is excluded rather than guessed.

### Example input

```json
{
  "searchQueries": [
    "wireless chargers",
    "phone cases"
  ],
  "maxItems": 100,
  "maxPagesPerSource": 5,
  "maxPrice": 20,
  "minSold": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

For a cheap first run, keep `maxItems` at 10 and `maxPagesPerSource` at 1.

### Output data

Each dataset row represents one DHgate product listing.

| Field | Description |
|---|---|
| `itemCode` | Public numeric DHgate item code |
| `productId` | Internal product identifier exposed by the listing |
| `title` | Full product title |
| `productUrl` | Clean product-detail URL |
| `imageUrl` | Main listing image URL |
| `price` | Original displayed price text or range |
| `priceMin` | Numeric lower USD bound |
| `priceMax` | Numeric upper USD bound |
| `currency` | Price currency, normally USD |
| `unit` | Displayed selling unit, when present |
| `soldCount` | Normalized visible sales count |
| `sellerId` | Internal seller identifier |
| `sellerName` | Supplier storefront name |
| `sellerStoreUrl` | Supplier storefront URL |
| `sellerTier` | DHgate seller performance tier when displayed |
| `deliveryEstimate` | Listing delivery text when displayed |
| `coupons` | Current listing coupon labels |
| `categoryId` | Category ID parsed from category URLs |
| `collectionTitle` | Search/category page title |
| `collectionQuery` | Original keyword for keyword inputs |
| `collectionType` | `searchQuery` or `startUrl` |
| `page` | Result page number |
| `sourceUrl` | Exact page used for extraction |
| `scrapedAt` | ISO extraction timestamp |

Optional fields are omitted when DHgate does not display them.

The Actor does not invent missing values or write placeholder `null` values.

### Example output

```json
{
  "itemCode": "1113917241",
  "productId": "8aaa03f79f279832019f3b91f82b34f5",
  "title": "Solid Color Jelly Bag Fashionable Transparent Large Capacity Single Shoulder Handbag",
  "productUrl": "https://www.dhgate.com/product/solid-color-jelly-bag-fashionable-transparent/1113917241.html",
  "imageUrl": "https://img4.dhresource.com/webp/m/300x300/f3/albu/bw/o/07/902e9f44-d95a-4cf0-b488-1522bb911fcd.jpeg",
  "price": "US $12.52 - 17.90 / Piece",
  "priceMin": 12.52,
  "priceMax": 17.9,
  "currency": "USD",
  "unit": "Piece",
  "soldCount": 12,
  "sellerId": "8aaaa325835a19ba01835a66fb480e8a",
  "sellerName": "worldcup_official",
  "sellerStoreUrl": "https://www.dhgate.com/store/top-selling/21835891.html",
  "sellerTier": 3,
  "categoryId": "107011",
  "collectionTitle": "Wholesale Fashion Bags",
  "collectionType": "startUrl",
  "page": 1,
  "sourceUrl": "https://www.dhgate.com/wholesale/fashion-bags/c107011.html",
  "scrapedAt": "2026-07-23T00:00:00.000Z"
}
```

Live values change as DHgate updates its marketplace.

### Supplier sourcing workflow

A practical sourcing workflow is:

1. Search several terms that describe the same product niche.
2. Set a realistic `maxPrice` for the target unit economics.
3. Use `minSold` to focus on listings with visible demand.
4. Export the Supplier analysis dataset view.
5. Group records by `sellerId` or `sellerStoreUrl`.
6. Review the supplier storefront and product detail before ordering.
7. Schedule the same input to track changes.

Seller tier and sold count are marketplace signals, not guarantees.

Always complete your own supplier verification and sample-order process.

### How pagination and deduplication work

The Actor reads the next-page URL rendered by DHgate.

It stops when it reaches:

- `maxItems` across the whole run;
- `maxPagesPerSource` for the current input;
- the final available page;
- or the end of all inputs.

If the same item appears in multiple searches, it is saved only once per run.

The first observed copy retains the collection context that discovered it.

### Filters and boundary behavior

`minPrice` applies to the lower bound of the displayed range.

`maxPrice` applies to the upper bound.

This means a range of `$10 - $30` does not pass `maxPrice: 20`.

`minSold` supports labels such as `265 Sold` and `1.8K+ Sold`.

If DHgate omits a sold count, the row does not pass an active `minSold` filter.

These rules make automated sourcing filters conservative and reproducible.

### Reliability and anti-blocking

DHgate uses Akamai anti-bot protection.

The Actor therefore defaults to:

- US residential proxying;
- browser-like request headers;
- sticky sessions for each request attempt;
- sequential, low-concurrency collection;
- a maximum of three attempts per page;
- session rotation only after a blocked or malformed response.

A fully blocked page fails clearly instead of silently producing an empty success.

A successfully fetched search with no matching products remains a valid empty result.

### How much does it cost to scrape DHgate products?

The Actor uses pay-per-event pricing.

A small start fee covers run initialization, followed by a charge for each saved product listing.

The exact active prices appear in the Apify Console before you start a run and may include subscription-tier discounts.

Control total cost with:

- a low `maxItems` value;
- one page for exploratory runs;
- focused keywords;
- strict price and popularity filters;
- Apify's maximum total charge setting.

Proxy and compute usage are covered by the Actor's pricing model when run from Apify Store.

### Scheduling a DHgate price monitor

Apify schedules can run the same input hourly, daily, weekly, or monthly.

For a lightweight monitor:

1. Save the Actor input as a task.
2. Keep keywords and filter values stable.
3. Add a daily or weekly schedule.
4. Send completed datasets to a webhook or integration.
5. Compare records by `itemCode`.
6. Alert on changes to `priceMin`, `priceMax`, or `soldCount`.

Use `scrapedAt` and `sourceUrl` for auditability.

### Export formats

The default dataset supports:

- JSON
- JSONL
- CSV
- Excel
- XML
- RSS
- HTML table

Use the Overview view for product research.

Use the Supplier analysis view for supplier grouping and procurement review.

### Integrations

#### Google Sheets

Send each completed dataset to a sourcing workbook for review and assignment.

#### Airtable

Create a product-candidate base keyed by `itemCode`, with supplier records linked by `sellerId`.

#### Make and Zapier

Trigger enrichment, approval, or catalog workflows after each scheduled run.

#### Webhooks

Notify your application when a run succeeds or fails, then fetch the dataset through the API.

#### Amazon S3 or Google Drive

Archive periodic category snapshots for historical assortment analysis.

### Use with the Apify API

Replace `APIFY_TOKEN` with your token.

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~dhgate-product-supplier-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["wireless earbuds"],"maxItems":25,"maxPagesPerSource":2}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/dhgate-product-supplier-scraper').call({
    searchQueries: ['wireless earbuds'],
    maxItems: 25,
    maxPagesPerSource: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('automation-lab/dhgate-product-supplier-scraper').call(run_input={
    'searchQueries': ['wireless earbuds'],
    'maxItems': 25,
    'maxPagesPerSource': 2,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Apify MCP lets Claude Code, Claude Desktop, Cursor, VS Code, and other MCP clients call the Actor as a tool.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/dhgate-product-supplier-scraper"
```

#### Claude Desktop, Cursor, or VS Code

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/dhgate-product-supplier-scraper"
    }
  }
}
```

Example prompts:

- “Find 30 DHgate wireless charger listings under $20 and rank them by sold count.”
- “Extract the first two pages of this DHgate category and group products by supplier.”
- “Run my saved DHgate sourcing task and summarize suppliers with seller tier 4 or 5.”

### Tips for better results

- Begin with one focused query and 10 items.
- Prefer marketplace terminology used by DHgate sellers.
- Split unrelated product niches into separate tasks.
- Keep residential proxying enabled.
- Use category URLs when you need repeatable assortment snapshots.
- Use query input when you need broad discovery.
- Compare suppliers by stable seller IDs, not only display names.
- Treat coupons and delivery estimates as time-sensitive.
- Review product details before purchasing or republishing data.

### Troubleshooting

#### Why did my run return no products?

Your filters may be stricter than the current listings.

Remove `minSold`, widen the price range, and test one page.

A niche query may also have no matching public listings.

#### Why was my URL rejected?

Version 1 accepts only public DHgate listing URLs under `/wholesale/`.

Use a category or search URL rather than a product, cart, account, or external URL.

#### Why did a run fail after retries?

DHgate may have blocked all three bounded residential sessions or changed its listing markup.

Retry later with the default proxy settings and check the run log for the exact page and HTTP response shape.

#### Why is a supplier field missing?

DHgate does not display every supplier attribute on every listing card.

Optional fields are omitted rather than guessed.

### Data quality notes

Prices are the ranges displayed to an anonymous US visitor at extraction time.

They may vary by quantity, destination, currency, promotion, login state, or product option.

Sold counts may be rounded, for example `1.8K+`.

Seller tier is a DHgate performance indicator, not an independent audit.

Coupons and delivery estimates can expire quickly.

Use product and seller IDs as stable join keys wherever possible.

### Is scraping DHgate legal?

This Actor collects publicly visible marketplace listing data.

You are responsible for using it lawfully and in accordance with applicable contracts, privacy rules, intellectual-property rules, and local regulations.

Do not use the Actor to access accounts, evade authorization, collect private data, or overload DHgate.

Use reasonable limits and a legitimate sourcing, research, or interoperability purpose.

When in doubt, consult qualified legal counsel.

### Security and privacy

No DHgate login is required.

The Actor does not request passwords, cookies, private API credentials, or payment information.

Input and output are stored in your Apify account according to your platform retention settings.

Avoid placing confidential information inside search terms or URLs.

### FAQ

#### Does it scrape individual product reviews?

No. Version 1 focuses on search and category listings.

#### Does it collect MOQ?

It returns the listing's displayed selling unit. It does not claim option-level MOQ when the card does not expose it.

#### Can it scrape several keywords in one run?

Yes. Add multiple values to `searchQueries`; `maxItems` remains a global cap.

#### Can I use direct DHgate URLs?

Yes, for category or search pages under `/wholesale/`.

#### Does it remove duplicates?

Yes. Item codes are deduplicated across every query and URL in the run.

#### Can I monitor prices?

Yes. Save a task, schedule it, and compare numeric price fields by `itemCode`.

#### Is a proxy required?

Residential proxying is strongly recommended and enabled by default because plain HTTP is commonly blocked.

### Related scrapers

Build a broader sourcing workflow with other Automation Lab actors:

- [Made-in-China Scraper](https://apify.com/automation-lab/made-in-china-scraper)
- [1688.com Scraper](https://apify.com/automation-lab/1688-com-scraper)
- [Alibaba Product Scraper](https://apify.com/automation-lab/alibaba-product-scraper)
- [AliExpress Product Scraper](https://apify.com/automation-lab/aliexpress-product-scraper)

Check each Store page for its current scope and input contract.

### Support

If a valid DHgate wholesale URL fails consistently, open an Actor issue with:

- the exact input;
- the run ID;
- the expected result;
- and the observed behavior.

Do not include account credentials or private data.

We use reproducible examples to distinguish source changes, filter behavior, and transient blocking.

# Actor input Schema

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

Product keywords such as wireless earbuds, wedding dresses, or phone cases.

## `startUrls` (type: `array`):

Public URLs on www.dhgate.com under /wholesale/. Product-detail URLs are intentionally excluded from listing-first v1.

## `maxItems` (type: `integer`):

Stop after saving this many unique DHgate products across all inputs.

## `maxPagesPerSource` (type: `integer`):

Safety cap for pagination on each keyword or start URL.

## `minPrice` (type: `number`):

Keep listings whose minimum displayed price is at least this amount. Leave empty for no minimum.

## `maxPrice` (type: `number`):

Keep listings whose maximum displayed price is no more than this amount. Leave empty for no maximum.

## `minSold` (type: `integer`):

Keep only listings with at least this displayed sales count. Listings without a count fail this filter closed.

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

Apify Proxy settings. The default uses a sticky US residential session with bounded rotation on blocks.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless earbuds"
  ],
  "startUrls": [
    {
      "url": "https://www.dhgate.com/wholesale/fashion-bags/c107011.html"
    }
  ],
  "maxItems": 10,
  "maxPagesPerSource": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Product listing rows with IDs, titles, price ranges, MOQ, sales, ratings, supplier identities, storefronts, images, and collection context.

# 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 = {
    "searchQueries": [
        "wireless earbuds"
    ],
    "startUrls": [
        {
            "url": "https://www.dhgate.com/wholesale/fashion-bags/c107011.html"
        }
    ],
    "maxItems": 10,
    "maxPagesPerSource": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/dhgate-product-supplier-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 = {
    "searchQueries": ["wireless earbuds"],
    "startUrls": [{ "url": "https://www.dhgate.com/wholesale/fashion-bags/c107011.html" }],
    "maxItems": 10,
    "maxPagesPerSource": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/dhgate-product-supplier-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 '{
  "searchQueries": [
    "wireless earbuds"
  ],
  "startUrls": [
    {
      "url": "https://www.dhgate.com/wholesale/fashion-bags/c107011.html"
    }
  ],
  "maxItems": 10,
  "maxPagesPerSource": 1
}' |
apify call automation-lab/dhgate-product-supplier-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/dhgate-product-supplier-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DHgate Product & Supplier Scraper",
        "description": "Extract DHgate wholesale listings with prices, MOQ, sales, ratings, supplier IDs, storefronts, images, coupons, and sourcing context.",
        "version": "0.1",
        "x-build-id": "q9VS4ZzsEokcxTQLX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~dhgate-product-supplier-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-dhgate-product-supplier-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/automation-lab~dhgate-product-supplier-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-dhgate-product-supplier-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/automation-lab~dhgate-product-supplier-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-dhgate-product-supplier-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "DHgate search queries",
                        "type": "array",
                        "description": "Product keywords such as wireless earbuds, wedding dresses, or phone cases.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "DHgate category or search URLs",
                        "type": "array",
                        "description": "Public URLs on www.dhgate.com under /wholesale/. Product-detail URLs are intentionally excluded from listing-first v1.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum product listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique DHgate products across all inputs.",
                        "default": 25
                    },
                    "maxPagesPerSource": {
                        "title": "Maximum pages per query or URL",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Safety cap for pagination on each keyword or start URL.",
                        "default": 2
                    },
                    "minPrice": {
                        "title": "Minimum listing price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep listings whose minimum displayed price is at least this amount. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum listing price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Keep listings whose maximum displayed price is no more than this amount. Leave empty for no maximum."
                    },
                    "minSold": {
                        "title": "Minimum sold count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings with at least this displayed sales count. Listings without a count fail this filter closed."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. The default uses a sticky US residential session with bounded rotation on blocks.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
