# 1688 Wholesale Scraper (`silentflow/1688-scraper`) Actor

Scrape 1688.com, Alibaba's Chinese wholesale marketplace, by keyword (English or Chinese) or offer ID. Get tiered pricing, MOQ, specs, color and size variants, verified supplier details, after-sales guarantees and buyer reviews. Built for dropshipping, Amazon FBA and private-label sourcing.

- **URL**: https://apify.com/silentflow/1688-scraper.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## 1688 Wholesale Scraper

**Turn 1688.com into a clean wholesale supplier feed.** Product specs, tiered wholesale pricing, every available color and size, supplier trust signals and buyer reviews, structured and ready for analysis. In seconds, not hours.

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/hPvPG863cYcfJmkbi/records/how-it-works-v2.png)

Type a product keyword in English or Chinese, or paste the offer IDs you already have, and press Start. Every result comes back as one structured record: pricing tiers, variant options, supplier profile, after-sales guarantees and a buyer review summary. Export to JSON, CSV or Excel, or pull it straight into your sourcing pipeline.

Three steps, no setup:

1. **Search or paste IDs.** Enter keywords (wireless earbuds or 蓝牙耳机) or a list of offer IDs.
2. **Get structured records.** Each product returns pricing, variants, supplier and reviews as clean fields, not a wall of Chinese HTML.
3. **Export or pipe.** Download as JSON, CSV, Excel, or read the dataset from the API into your own tools.

### ✨ Why teams choose this over other 1688 scrapers

Sourcing from 1688 by hand means copy-pasting Chinese product pages, guessing where the price actually breaks, and never knowing if a supplier is a real factory or a reseller. Running scrapers that hand back half the fields and break on the first run? Paying extra to unlock supplier and factory details other tools hide behind a toggle?

- ⭐ **Buyer reviews on every product.** Star rating, positive rate, and the exact words buyers use (fast shipping, great quality, responsive seller) with sample reviews and the variant each buyer bought. Most 1688 scrapers give you no reviews at all. This one reads buyer sentiment so you can spot a proven product before you contact the supplier.
- 🎨 **Every color and size, reliably.** The available variant options come back on every product that has them, straight from the product page. You see the full choice set (colors, sizes, models) even for listings other scrapers return half-empty.
- 🏭 **Supplier details come free.** Company name, location, factory or trade type, repeat-buyer rate, response rate, platform credentials and service scores, included with every product instead of sold as a paid add-on.
- 💰 **The real price breaks on every product.** The tiers that matter (10 units at one price, 1000 at another) come back as structured steps, so you can compare true unit cost across suppliers instead of eyeballing a headline price.
- 🛡️ **Trust and demand signals built in.** After-sales guarantees (quality guarantee, breakage and late-shipment compensation), buyer protections, monthly sales and 30-day sales value, so you can vet a supplier and gauge real demand in one row.
- 📋 **Full product specs.** Chip type, material, function, model and the rest, as clean name and value pairs, not buried in a description blob.
- 🖼️ **Full image gallery and video.** Every product image plus the product video when the supplier posts one, not just a single thumbnail.
- ⚡ **Fast by default, deep on demand.** Product, pricing, variants, reviews and supplier come from a single fast pass. Turn on the per-variant matrix (each color and size with its own stock and price) only when you need that depth.
- 🌏 **Search in English or Chinese.** Type wireless earbuds or 蓝牙耳机. Chinese keywords reach the full domestic catalog and return far more suppliers.
- 🎯 **Strict result cap.** Set Max results and get exactly that. No surprise overage from a scraper that ignores your limit.

### 🎯 What you can do with 1688 data

| Team | What they build |
|---|---|
| Sourcing | A shortlist of factories for a product, ranked by price break, minimum order and repeat-buyer rate, with supplier guarantees on each row |
| E-commerce | A landed-cost and margin model from cost, variants and shipping weight before importing a single unit |
| Dropshipping | A catalog of low-MOQ suppliers with consignment support and the exact colors and sizes each offers |
| Private label | A factory comparison by years on platform, review sentiment, response rate and verification status |
| Market research | A view of wholesale price ranges and best-selling products across a category, tracked over time |
| Procurement | A weekly watch on a set of offer IDs for price, stock and minimum-order changes |
| Agencies | A supplier database refreshed on a schedule and fed to clients as clean CSV or a Google Sheet |

### 📥 Input parameters

| Field | Type | Description |
|---|---|---|
| `keywords` | array | Products to search for, English or Chinese. Each keyword is searched separately and Max results applies per keyword. |
| `offerIds` | array | Specific product IDs to scrape directly. When set, keywords are ignored. |
| `maxResults` | integer | Maximum products per keyword. Default 100. |
| `sortBy` | string | `relevance`, `bestSelling`, `priceAsc` or `priceDesc`. |
| `includeSkuMatrix` | boolean | Also return the per-variant matrix (each color and size with its own stock and price). Off by default for the fastest runs. Colors, sizes, pricing, reviews and supplier come regardless. |
| `proxyConfiguration` | object | Residential proxy, selected by default and routed automatically. |
| `debugMode` | boolean | Extra diagnostics for troubleshooting. Leave off for normal runs. |

### 📊 Output data

Each product is one record. Search results and offer-ID lookups return the same shape.

```json
{
  "offerId": "1063153988432",
  "title": "Summer floral V-neck maxi dress, cross-border women's fashion",
  "detailUrl": "https://detail.1688.com/offer/1063153988432.html",
  "images": ["https://cbu01.alicdn.com/img/ibank/O1CN01...jpg"],
  "videoUrl": "https://cloud.video.taobao.com/play/u/.../e/6/t/1/....mp4",
  "price": { "min": 20.0, "max": 22.0, "currency": "CNY", "display": "20.00-22.00" },
  "quantityPrices": [
    { "price": 22.0, "beginAmount": 2, "endAmount": 99 },
    { "price": 20.0, "beginAmount": 100, "endAmount": 0 }
  ],
  "minOrderQuantity": 2,
  "stock": 15773,
  "soldCount": 322,
  "unitWeight": 0.42,
  "skuProperties": [
    { "name": "颜色", "values": ["Green (ships in 24h)", "Blue (presale)", "Custom color and size"] },
    { "name": "尺码", "values": ["S", "M", "L", "XL", "XXL"] }
  ],
  "services": [
    { "name": "Quality guarantee", "description": "Third-party inspection before you confirm receipt; claim if goods do not match." },
    { "name": "Late-shipment compensation", "description": "Compensation when the seller ships later than agreed." }
  ],
  "buyerProtections": ["Ships in 48h", "7-day exchange"],
  "monthlySales": 3205,
  "gmv30Days": 50000,
  "dropship": { "enabled": true },
  "supplier": {
    "companyName": "Guangzhou Caisi Garment Co., Ltd.",
    "memberId": "b2b-2222623069593...",
    "loginId": "caisi001",
    "sellerType": "factory",
    "repeatRate": "23%",
    "responseRate": "96%",
    "certifications": ["TrustPass 4 years"],
    "serviceScores": { "goods": "4.8", "logistics": "4.9" },
    "location": "Guangdong Guangzhou"
  },
  "reviews": {
    "total": 1800,
    "rating": 5.0,
    "goodRate": 99.9,
    "items": [
      { "rating": 5.0, "content": "Great quality, ships fast", "sku": "型号:白色100CM", "date": "2025-07-14" }
    ]
  },
  "sourceType": "search",
  "scrapedAt": "2026-07-02T00:00:00Z"
}
````

When you turn on `includeSkuMatrix`, products that expose it also carry a `skuVariants` array, one row per color and size:

```json
{
  "skuVariants": [
    { "skuId": "6130776786823", "specId": "f561c4f7...", "specs": "Black / M", "stock": 7890, "saleCount": 12 },
    { "skuId": "6130776786824", "specId": "a63c985e...", "specs": "White / L", "stock": 7883, "saleCount": 4 }
  ]
}
```

### 🗂️ Data fields

| Category | Fields |
|---|---|
| Identity | `offerId`, `title`, `detailUrl`, `sourceType`, `sourceKeyword`, `scrapedAt` |
| Media | `images` (full gallery), `videoUrl` |
| Pricing | `price` (min, max, currency, display), `quantityPrices` (tiered: price, beginAmount, endAmount) |
| Variants | `skuProperties` (variant options: name plus every value, colors and sizes), `skuVariants` (per-variant skuId, specId, specs, stock, saleCount, opt-in), `minOrderQuantity`, `stock`, `soldCount`, `unitWeight` |
| Trade | `dropship` (enabled), `customization`, `isCrossBorderTrade`, `shipping` (location, postFee, deliveryDays, freeShipping) |
| Trust and demand | `services` (after-sales guarantees, each with name and a plain-language description), `buyerProtections`, `monthlySales`, `gmv30Days` |
| Supplier | `companyName`, `legalCompanyName`, `memberId`, `loginId`, `sellerType`, `isVerified`, `repeatRate`, `responseRate`, `certifications`, `serviceScores`, `winportUrl`, `location` |
| Reviews | `total`, `rating`, `goodRate`, `withImagesCount`, `impressionTags` (sentiment keyword plus count), `items` (per review: rating, content, date, sku, images) |

The `supplier` object carries up to 12 populated fields, `reviews` up to 6 top-level fields plus a sample of individual reviews with 5 fields each, and `price` 4. `offerId` and `detailUrl` are stable and permanent; image URLs stay valid for a couple of weeks; the product video URL is a CDN link that can expire sooner. Timestamps are ISO 8601 (`scrapedAt`).

### 🚀 Examples

#### Find wireless earbud suppliers

```json
{ "keywords": ["wireless earbuds"], "maxResults": 100 }
```

#### Search the domestic catalog in Chinese

```json
{ "keywords": ["蓝牙耳机", "充电宝"], "maxResults": 200 }
```

#### Find the cheapest suppliers first

```json
{ "keywords": ["phone case"], "sortBy": "priceAsc", "maxResults": 50 }
```

#### Pull the best-selling products in a category

```json
{ "keywords": ["LED strip lights"], "sortBy": "bestSelling", "maxResults": 100 }
```

#### Get per-variant stock and price for apparel

```json
{ "keywords": ["卫衣 女"], "includeSkuMatrix": true, "maxResults": 60 }
```

#### Audit specific products you already source

```json
{ "offerIds": ["1063153988432", "738026063940"] }
```

### 🤖 Copy to your AI assistant

Paste this block into Claude, ChatGPT or Cursor to give it full context about this scraper:

```
You have access to the 1688 Wholesale Scraper on Apify: silentflow/1688-scraper

Input schema:
- keywords (array of strings): products to search, English or Chinese
- offerIds (array of strings): specific product IDs; when set, keywords are ignored
- maxResults (integer, default 100): products per keyword
- sortBy (string): relevance | bestSelling | priceAsc | priceDesc
- includeSkuMatrix (boolean, default false): also return per-variant stock and price
- debugMode (boolean, default false)

Output per product:
- offerId, title, detailUrl, images[], videoUrl
- price { min, max, currency, display }
- quantityPrices[] { price, beginAmount, endAmount }  (tiered wholesale pricing)
- skuProperties[] { name, values[] }  (variant options: colors, sizes)
- skuVariants[] { skuId, specId, specs, stock, saleCount }  (per-variant, opt-in)
- minOrderQuantity, stock, soldCount, unitWeight
- services[] { name, description }, buyerProtections[], monthlySales, gmv30Days
- dropship { enabled }, customization, isCrossBorderTrade, shipping { location, postFee, deliveryDays, freeShipping }
- supplier { companyName, memberId, loginId, sellerType, isVerified, repeatRate, responseRate, certifications[], serviceScores, winportUrl, location }
- reviews { total, rating, goodRate, withImagesCount, impressionTags[] { name, count }, items[] { rating, content, date, sku, images } }
- sourceType, sourceKeyword, scrapedAt

No login, no API key. Proxies included. Use apify-client for Python or JS.
```

### 💻 Integrations

#### Build a supplier shortlist in Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("silentflow/1688-scraper").call(run_input={
    "keywords": ["wireless earbuds"],
    "sortBy": "bestSelling",
    "maxResults": 100,
})

suppliers = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    s = item.get("supplier") or {}
    r = item.get("reviews") or {}
    suppliers.append({
        "title": item["title"],
        "unit_price": item["price"]["min"],
        "moq": item["minOrderQuantity"],
        "company": s.get("companyName"),
        "repeat_rate": s.get("repeatRate"),
        "good_rate": r.get("goodRate"),
    })

suppliers.sort(key=lambda x: (x["unit_price"], -(x["good_rate"] or 0)))
for s in suppliers[:10]:
    print(s)
```

#### Monitor price and stock changes in Node.js

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('silentflow/1688-scraper').call({
    offerIds: ['1063153988432', '738026063940'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const p of items) {
    console.log(`${p.offerId}: ${p.price.min} CNY, stock ${p.stock}, MOQ ${p.minOrderQuantity}`);
}
```

#### Export a category to CSV

```python
import csv
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("silentflow/1688-scraper").call(run_input={"keywords": ["phone case"], "maxResults": 200})

with open("suppliers.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(["offerId", "title", "minPrice", "moq", "company", "monthlySales"])
    for it in client.dataset(run["defaultDatasetId"]).iterate_items():
        s = it.get("supplier") or {}
        w.writerow([it["offerId"], it["title"], it["price"]["min"], it["minOrderQuantity"], s.get("companyName"), it.get("monthlySales")])
```

### 📈 Performance

| Metric | Value |
|---|---|
| Speed | Fast by default: product, pricing, variant options, reviews and supplier from a single pass |
| Depth on demand | Turn on `includeSkuMatrix` for per-variant stock and price when you need it |
| Always included | Tiered pricing, specs, variant options, gallery, shipping, supplier and review summary on every product |
| Search depth | Up to 2,000 products per keyword |
| Languages | English and Chinese keywords |
| Freshness | Live, fetched on demand at run time, no caching |

### 💾 Data export

Every run writes to a dataset you can export as JSON, CSV, Excel, HTML or RSS from the Apify console, or pull programmatically:

```
https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=csv&token=YOUR_TOKEN
```

### 💡 Tips for best results

- Use Chinese keywords for the widest selection. 1688 is a domestic Chinese marketplace, so 蓝牙耳机 returns far more suppliers than its English equivalent.
- Sort by `bestSelling` to surface proven products with real order volume before you contact a supplier.
- Read `quantityPrices` to find the order quantity where the unit price drops. The break point is often lower than the listing headline suggests.
- Use `reviews.goodRate` and the review samples to filter for products buyers actually like, then `monthlySales` to confirm real demand.
- Leave `includeSkuMatrix` off for fast category scans, and turn it on only for the shortlist where you need each color and size with its own stock and price.

### ❓ FAQ

**What does the scraper return?**
A structured record per product: title, images, video, tiered pricing, variant options, minimum order quantity, stock, supplier profile, after-sales guarantees, buyer protections, demand signals and a buyer review summary.

**What is 1688?**
1688.com is Alibaba's domestic Chinese B2B wholesale marketplace, the factory-direct source that sits upstream of Alibaba.com and AliExpress. It is where most cross-border sellers buy at wholesale prices.

**Can I search in English?**
Yes. English and Chinese keywords both work. Chinese keywords reach the full domestic catalog and return more results.

**Do I need a 1688 account?**
No. The scraper reads publicly available product data. No login, no API key, no cookies.

**How do I scrape a specific product?**
Put its offer ID (the number in the product URL) in the `offerIds` field. Keywords are ignored when offer IDs are set.

**Does it return review text?**
Yes. Each review summary carries the total count, star rating, positive rate and top sentiment keywords, plus a sample of individual reviews with their text, star level, purchase date and the variant the buyer bought.

**Do I get every color and size?**
The variant options (available colors, sizes and models) come on every product that lists them. For the deeper matrix with per-variant stock and price, turn on `includeSkuMatrix`; it is added when the product page exposes it.

**How do the sort and filter options combine?**
`sortBy` applies to each keyword search, and `maxResults` caps each keyword separately. For example, `keywords: ["phone case"]` with `sortBy: "bestSelling"` and `maxResults: 50` returns the 50 best-selling phone case offers.

**How many products can I get per keyword?**
Up to 2,000 per keyword, capped by your Max results setting.

**Is the price in dollars?**
Prices are in Chinese yuan (CNY), the currency 1688 lists in. The `price` object includes the currency so you can convert as needed.

**Are the image and video links permanent?**
`offerId` and `detailUrl` are stable. Image URLs stay valid for a couple of weeks. The product video is a CDN link that can expire sooner, so download it if you need to keep it.

### ⚖️ Legal

This Actor extracts publicly available data from 1688.com. It does not bypass any login, paywall or CAPTCHA. Users are responsible for complying with 1688's terms of service and applicable data protection laws (GDPR, CCPA, and PIPL where relevant). When the output contains personal data, such as supplier contact names or reviewer nicknames, users must handle it accordingly. The data returned is informational; verify accuracy for regulated use cases.

### 🔗 Related scrapers

Building a China sourcing pipeline? See the full set of marketplace and supplier scrapers on our profile: [silentflow on Apify](https://apify.com/silentflow).

### 📬 Support

Need something this scraper does not do yet? We ship features fast.

- Feature requests go straight to our backlog
- Enterprise needs? We do custom integrations and high-volume plans
- Pricing questions? Check the Monetization tab on the actor page

Response time: usually under 24 hours.

Check out our other scrapers: [silentflow on Apify](https://apify.com/silentflow)

# Actor input Schema

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

Products to search for. Works with English (wireless earbuds, phone case) or Chinese (手机壳, 蓝牙耳机). Each keyword is searched separately and Max results applies per keyword. Chinese keywords usually return more results since 1688 is a domestic Chinese marketplace. Ignored when Offer IDs are provided.

## `offerIds` (type: `array`):

Specific product IDs to scrape directly (skips search). The ID is the number in any 1688 product URL, for example offer/735353578254.html. When set, keywords are ignored.

## `maxResults` (type: `integer`):

Maximum products to scrape per keyword. Ignored when Offer IDs are provided.

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

How to sort search results.

## `includeSkuMatrix` (type: `boolean`):

Also fetch the per-variant matrix (each color and size with its own stock and price). This adds time. Available colors and sizes, tiered pricing, reviews and supplier details come on every product regardless. Leave off for the fastest runs.

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

Keyword search needs a residential proxy. Residential is selected by default and routing is handled automatically.

## `debugMode` (type: `boolean`):

Log extra diagnostics for troubleshooting. Leave off for normal runs.

## Actor input object example

```json
{
  "keywords": [
    "wireless earbuds"
  ],
  "maxResults": 100,
  "sortBy": "relevance",
  "includeSkuMatrix": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "debugMode": false
}
```

# Actor output Schema

## `results` (type: `string`):

Each product: offerId, title, price, quantityPrices, skuProperties, skuVariants, minOrderQuantity, stock, soldCount, services, buyerProtections, monthlySales, gmv30Days, supplier, reviews, shipping, dropship, scrapedAt.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "wireless earbuds"
    ],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/1688-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["wireless earbuds"],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/1688-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "wireless earbuds"
  ],
  "maxResults": 100
}' |
apify call silentflow/1688-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "1688 Wholesale Scraper",
        "description": "Scrape 1688.com, Alibaba's Chinese wholesale marketplace, by keyword (English or Chinese) or offer ID. Get tiered pricing, MOQ, specs, color and size variants, verified supplier details, after-sales guarantees and buyer reviews. Built for dropshipping, Amazon FBA and private-label sourcing.",
        "version": "1.0",
        "x-build-id": "aNgk9XghZ94TLFMkg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~1688-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-1688-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/silentflow~1688-scraper/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-1688-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/silentflow~1688-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-1688-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": {
                    "keywords": {
                        "title": "Search keywords (English or Chinese)",
                        "type": "array",
                        "description": "Products to search for. Works with English (wireless earbuds, phone case) or Chinese (手机壳, 蓝牙耳机). Each keyword is searched separately and Max results applies per keyword. Chinese keywords usually return more results since 1688 is a domestic Chinese marketplace. Ignored when Offer IDs are provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "offerIds": {
                        "title": "Offer IDs",
                        "type": "array",
                        "description": "Specific product IDs to scrape directly (skips search). The ID is the number in any 1688 product URL, for example offer/735353578254.html. When set, keywords are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results per keyword",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum products to scrape per keyword. Ignored when Offer IDs are provided.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "bestSelling",
                            "priceAsc",
                            "priceDesc"
                        ],
                        "type": "string",
                        "description": "How to sort search results.",
                        "default": "relevance"
                    },
                    "includeSkuMatrix": {
                        "title": "Include per-variant stock and price",
                        "type": "boolean",
                        "description": "Also fetch the per-variant matrix (each color and size with its own stock and price). This adds time. Available colors and sizes, tiered pricing, reviews and supplier details come on every product regardless. Leave off for the fastest runs.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Keyword search needs a residential proxy. Residential is selected by default and routing is handled automatically.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Log extra diagnostics for troubleshooting. Leave off for normal runs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
