# 1688 Product Scraper & Price Monitor — $0.005/item + $0.01 fee (`crawleast/1688-product-scraper`) Actor

Scrape any 1688.com category from one English keyword — English titles, MOQ ladders, dropship scores, landed costs, compliance hints — or watch a shortlist of offers over time (price curves + drop/stock alerts). Failed runs cost $0; success: $0.01 base + per-event fees.

- **URL**: https://apify.com/crawleast/1688-product-scraper.md
- **Developed by:** [Kyle Wang](https://apify.com/crawleast) (community)
- **Categories:** E-commerce, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 search result cards

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

# README

## 1688 Product Scraper — Any Category, China Factory Prices, Decision-Ready Data

**Research ANY product category on 1688.com — Alibaba's domestic wholesale marketplace — and get sourcing-grade rows, not raw Chinese HTML.**

Type one English keyword ("led strip lights", "yoga mat", "phone case"), and get back research-ready products: AI-translated English titles, MOQ price ladders, supplier trust signals, a 0–100 dropship score, an estimated landed cost in USD, and compliance hints for your target market. Every row carries a `scrapedAt` timestamp so freshness is verifiable.

No Chinese needed. No 1688 account. Failed or zero-result runs cost $0; a successful run bills a $0.01 base fee plus per-event fees. Fail-not-billed.

**New — Price Monitoring Mode:** paste a shortlist of 1688 offer IDs (`watchlistOfferIds`), attach a Schedule (e.g. daily), and get a per-offer history curve, day-over-day / 7-day-low change metrics and price-drop / stock-tight alerts — without ever re-searching. See **Price Monitoring Mode** below.

**Keywords:** 1688, 1688 scraper, wholesale, dropshipping, product research, supplier search, landed cost, MOQ, China sourcing

***

#### 🎯 What you can do with it

- **Product selection** — scan a category at factory prices before you commit to a supplier
- **Price comparison** — sort by price or sales and read the full quantity-break ladder per product
- **Dropshipping evaluation** — every product scored 0–100 on dropship-readiness (MOQ, 48h pickup, one-piece dropship support)
- **Margin math** — estimated landed cost (product + shipping + duty + fees) and suggested retail with margin % for US / EU / UK
- **Compliance screening** — required certs and risk level per target market (FDA / CE / Prop 65 / FCC hints)

***

#### 📈 Price Monitoring Mode

Already know which 1688 offers you care about? Stop re-searching — **watch their prices over time.** Fill `watchlistOfferIds` (up to 200 offer IDs) and the Actor switches from search mode to monitoring mode: each run snapshots every watched offer at card level, appends it to your private history, and returns the curve + change metrics + alerts in one `monitorReport` row.

**Three steps:**

1. **Fill the watchlist** — paste the numeric offer IDs (from a product URL, e.g. `994632611553`) into `watchlistOfferIds`. Optionally set alert thresholds (`alertOnPriceDropPct`, `alertOnStockTightPct`) and a `webhookUrl`.
2. **Attach a Schedule** — the Actor never self-schedules; bind a Schedule (e.g. `0 8 * * *` for 08:00 daily) so history accumulates. One run per day = one point on the curve.
3. **Read the report** — each run delivers a `monitorReport` row: `snapshotAt`, `watchlistSize`, and per offer `current{price, moq, bookedCount, supplier}`, `history{days, min, max, last7dLow}`, `changes{vsPrevDayPct, vs7dLowPct, stockTightPct}`, `alertHit`, plus a run-level `alerts[]`. Set `includeTrendReport=true` for a weekly `trendReport` roll-up.

**What it costs (monitoring mode):**

| Event | Price | When it's charged |
| --- | --- | --- |
| `snapshot-item` | $0.015 | Per offer successfully snapshotted **and** written to history |
| `trend-report` | $0.25 | Once per run when `includeTrendReport=true` delivers a report |
| `alert` | **$0.00** | Never billed (price-drop / stock-tight alerts are a free retention hook) |
| `run-base-fee` | $0.01 | Once per run that bills at least one event |

A daily run watching 10 offers costs **10 × $0.015 + $0.01 = $0.16** (no trend report). **Degradation is free:** if the history store is ever unreachable, the run still delivers the current snapshots, marks `errorCode: KV_UNAVAILABLE`, and charges **$0.00**. Truncated IDs (over 200) and invalid IDs are reported per-item and never billed.

**Your history is private.** Snapshots live in an owner-side named Key-Value store (`price-snapshots`) keyed by *your* Apify user id, so two users watching the same offer never see each other's curves. The Actor reaches it with a scoped, secret-injected API token — never a hard-coded credential.

Ready-made monitoring templates (one click):

- **[Track my 1688 shortlist prices daily](https://apify.com/crawleast/1688-product-scraper/track-my-1688-shortlist-prices-daily)** — a 3-offer watchlist wired for a daily Schedule
- **[Weekly price-drop radar](https://apify.com/crawleast/1688-product-scraper/weekly-price-drop-radar)** — a weekly drop / stock-tightening sweep with the trend report on

**Monitor quick-start input:**

```json
{
  "watchlistOfferIds": ["994632611553", "951309417091", "700000000001"],
  "historyDays": 30,
  "alertOnPriceDropPct": 5,
  "alertOnStockTightPct": 20,
  "includeTrendReport": true
}
```

***

#### ⚡ Three points that matter

1. **Decision-grade enrichment, not raw dumps** — landed cost, dropship score and compliance hints come attached to each product row. You stop paying for data you still have to research by hand.
2. **Honest billing** — you pay only for rows actually delivered. Zero-result or failed runs cost **$0.00**; a successful run includes a transparent **$0.01 base fee** plus per-event fees, and every run writes a SUMMARY ledger (`charged` vs `intended`) you can audit.
3. **A budget cap you control** — set `maxTotalChargeUsd` and the run truncates billing to your ceiling instead of silently overshooting. Items beyond the cap are free, never dropped.

***

#### ⚡ One-click examples

Skip the input form — these public tasks run proven configurations in one click:

- **[Product Selection — 40 enriched products](https://apify.com/crawleast/1688-product-scraper/1688-product-selection-quickstart)** — the standard research batch (~$0.33)
- **[Price Comparison — sorted by price](https://apify.com/crawleast/1688-product-scraper/1688-price-comparison-scan)** — cheapest first for instant comparison
- **[Price Ladder Deep Scan](https://apify.com/crawleast/1688-product-scraper/1688-price-ladder-deep-scan)** — MOQ price-break ladders across a whole niche
- **[Supplier Vetting Report](https://apify.com/crawleast/1688-product-scraper/1688-supplier-vetting-report)** — detail-enriched rows for supplier shortlisting
- **[MOQ Ladder Comparison](https://apify.com/crawleast/1688-product-scraper/1688-moq-ladder-comparison)** — side-by-side MOQ and unit-price comparison

***

#### 🔑 What keywords can you use? Any category.

This is not a vertical scraper — one input accepts any English product keyword, translated to Chinese search terms internally. Examples that work today:

| Keyword | Typical use |
| --- | --- |
| `led strip lights` | Consumer electronics price scan |
| `phone case` | High-volume accessory sourcing |
| `yoga mat` | Sports & fitness selection |
| `stainless steel water bottle` | Home & outdoor comparison |
| `car phone holder` | Auto accessories research |
| `plush toy` | Gifts & toys compliance screening |

Anything sold on 1688.com is in scope — if you can name it in English, you can research it here.

***

#### 📄 Sample output

Actual row from a live run (`keyword: "led strip lights"`):

```json
{
  "offerId": "994632611553",
  "titleCn": "24V/220V户外防水灯带COB水下IP68灌胶无光斑柔性线性灯硅胶泳池",
  "titleEn": "24V/220V Outdoor Waterproof LED Strip COB Underwater IP68 Flexible Linear Light",
  "price": { "min": 4.7, "max": 93.94, "currency": "CNY", "unit": "piece" },
  "moq": 1,
  "salesTotal": 867,
  "supplierName": "Zhongshan Qinghe Lighting Co., Ltd.",
  "isSuperFactory": true,
  "detailUrl": "https://detail.1688.com/offer/994632611553.html",
  "skuDetails": [ "…quantity-break price ladder…" ],
  "estLandedCostUsd": {
    "totalLandedCostUSD": 2.77,
    "suggestedRetailPriceUSD": 8.31,
    "estimatedMarginPercent": 66.7
  },
  "dropshipReadyScore": 65,
  "dropshipGrade": "C+",
  "compliance": { "targetMarket": "US", "suggestedCertifications": ["…"], "riskFlags": ["…"] },
  "scrapedAt": "2026-08-28T10:57:59.797Z"
}
```

Plus 30 more fields per row: SKU details, attributes, shipping & stock, supplier repeat rate, factory-inspection flags, product images and description images.

**Translation honesty rule:** `titleEn` only ever carries an English title. Titles are translated via a free translation API chain (`translationMethod="api"`) with an offline dictionary fallback (`translationMethod="dictionary"`). When neither can produce clean English for a title, `titleEn` is left empty rather than shipping a Chinese/English mix — the original Chinese is always preserved in `titleCn`.

***

#### 🆚 How it compares

| | **This Actor** | zen-studio 1688 wholesale | Typical 1688 scrapers |
| --- | --- | --- | --- |
| Startup / run fee | **None** — a $0.01 base fee applies only to successful runs | $0.0049 per run — billed even when nothing is delivered | Often yes |
| Failed / zero-result runs | **$0.00 — never billed** | Billed at least the startup fee | Usually billed |
| Enrichment trio (landed cost + dropship score + compliance) | **Included** | Not offered | Not offered |
| Budget cap (`maxTotalChargeUsd`) | **Enforced in code + ledger** | Not offered | Not offered |
| English titles | AI-translated | Chinese only | Chinese only |
| Freshness proof | `scrapedAt` on every row | — | — |
| Pricing | $0.005/search-item + $0.003/detail-item + $0.01 base (successful runs only) | $0.00499/item + startup + extras | Per-row tables |

***

#### 🛡️ Trust at a glance

| What we commit to | How it works here |
| --- | --- |
| Pay only for delivered results | Zero-result runs cost **$0.00** — billed per row actually delivered; successful runs add a single $0.01 base fee, nothing else |
| No hidden usage fees | Pure pay-per-event pricing; proxy and platform compute costs are included, never passed through |
| Honest degradation | Every run's SUMMARY discloses exactly what happened — partial deliveries always come with a named reason |
| Audit-ready billing ledger | SUMMARY reports `intended` vs `charged` events and whether the budget cap truncated anything |
| MCP / agentic-payment ready | Input, dataset, key-value-store and output schemas are all declared — machines can validate the contract before calling |
| Issues answered fast | Open an Issue instead of guessing — our response time is public on the developer profile |
| Loved it? Leave a review | If this saved you sourcing hours, a quick review helps other buyers find it — and we read every one |

***

#### 💰 Pricing (pay-per-event, no subscription)

| Event | Price | When it's charged |
| --- | --- | --- |
| `search-item` | $0.005 | Per delivered product card |
| `detail-item` | $0.003 | Per delivered card with full detail enrichment |
| `snapshot-item` | $0.015 | Per offer successfully snapshotted in Price Monitoring Mode |
| `trend-report` | $0.25 | Once per monitoring run when `includeTrendReport=true` |
| `run-base-fee` | $0.01 | Once per successful run (charged once per successful run, only when at least one row was delivered) |
| Startup fee | **$0.00** | Never |

**There is no minimum charge.** Small orders bill strictly per event (a 1-card run costs $0.015). The platform price list's `minimalMaxTotalChargeUsd` ($0.04) is a budget-PROTECTION parameter for the platform, not a minimum spend.

The "from $3.50 / 1,000" price shown on the Store page is the **GOLD subscription-tier** rate; on the FREE tier you pay $5 per 1,000 items (the list prices above).

Volume subscribers get the standard Apify platform tier discounts. Set `maxTotalChargeUsd` for a hard per-run ceiling.

**Failed or zero-result runs cost $0. A successful run bills a $0.01 base fee plus per-event fees ($0.005/search-item, $0.003/detail-item, $0.015/snapshot-item, $0.25/trend-report).**

Worked examples (FREE tier):

| Run shape | Math | Total |
| --- | --- | --- |
| 1-item trial (card only) | 1 × $0.005 + $0.01 base | **$0.015** |
| 10 cards (card only) | 10 × $0.005 + $0.01 base | **$0.06** |
| 40 fully enriched products | 40 × $0.005 + 40 × $0.003 + $0.01 base | **$0.33** |

**Best value at 20+ items** — per-item fees amortize the $0.01 run fee, and detail enrichment is only offered from 20 items up (`includeDetails=true` requires `maxItems ≥ 20`; below that, use `includeDetails=false` for a cheap card-only trial).

***

#### 🧭 Part of the 1688 sourcing toolkit

- 🖼️ **[1688 Image Search Scraper](https://apify.com/crawleast/1688-image-search-scraper)** — have a product photo instead of a keyword? Reverse-image-search 1688 and get the same sourcing-grade rows.
- 🐾 **[1688 Pet Supplies Scraper](https://apify.com/crawleast/china-pet-supplies-scraper)** — the pet-vertical edition with 500+ built-in pet EN→CN keyword mappings and a dropship-only filter.

***

#### 🤖 For AI agents / MCP

All four schemas are published: input schema (validated form), dataset schema (draft-07 with views), key-value-store schema (SUMMARY / OUTPUT), and an Actor-level output schema. Error paths are machine-readable: `errorCode` (`NO_INPUT`, `DETAILS_MIN_20`, and in monitoring mode `WATCHLIST_INVALID`, `SNAPSHOT_PARTIAL`, `KV_UNAVAILABLE`) + `message` + `chargedEvents: 0` in SUMMARY, with the run finishing SUCCEEDED so your pipeline can branch deterministically without parsing logs. In monitoring mode the SUMMARY also carries `monitorEvents{snapshotsDelivered, alertsSent, historyReadOk}` which reconciles with the billing ledger.

***

#### 🔧 Input configuration

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `keyword` | string | ✅ | — | English keyword; translated to Chinese search terms internally |
| `offerIds` | string\[] | — | — | Direct-fetch path: fetch exactly these offers by numeric ID, bypassing keyword search. Same batch economics apply — `includeDetails=true` (details enrichment) requires `maxItems ≥ 20`; smaller batches fall to the `DETAILS_MIN_20` guard (honest refusal, run finishes SUCCEEDED with `$0.00` charged). Use `includeDetails=false` for small card-only lookups. Price Monitoring (`watchlistOfferIds`) is a separate mode and is **not** subject to this guard |
| `maxItems` | integer | — | 40 | 1–200. With `includeDetails=true`, minimum 20 (detail enrichment only breaks even at batch scale) |
| `includeDetails` | boolean | — | `true` | `false` = cheap card-only mode (any batch size, good for trials) |
| `targetMarket` | enum | — | `US` | `US` / `EU` / `UK` — drives landed-cost duty and compliance rules |
| `sort` | enum | — | `relevant` | `relevant` / `sales` (most sold first) / `price` (low to high) — the delivered dataset arrives in that order |
| `priceMin` / `priceMax` | number | — | — | Approximate price range filter in CNY, **anchored to the card's min (bulk/MOQ) price**: passed to 1688's search and re-checked at delivery — cards whose min price is outside the range are dropped and never charged. Note: a card's `price.max` (one-piece / top-of-ladder price) may still exceed `priceMax`, since 1688 prices by quantity breaks |
| `maxTotalChargeUsd` | number | — | — | Hard billing ceiling for this run (minimum 0.04) |
| `watchlistOfferIds` | string\[] | — | — | **Price Monitoring Mode:** up to 200 offer IDs to watch. Filling this switches the run from search to monitoring (takes priority over `keyword`). $0.015 per snapshotted offer per run. Any watchlist size works (1–200) — the `DETAILS_MIN_20` minimum does not apply to monitoring mode |
| `historyDays` | integer | — | 30 | Monitoring curve window in days (1–400) |
| `alertOnPriceDropPct` | number | — | — | Fire a free `priceDrop` alert when price fell ≥ this % vs the previous snapshot |
| `alertOnStockTightPct` | number | — | — | Fire a free `stockTight` alert when the bookable amount shrank ≥ this % vs the previous snapshot |
| `webhookUrl` | string | — | — | POST the alert payload here when an alert fires (non-fatal, time-bounded) |
| `includeTrendReport` | boolean | — | `false` | Also deliver a weekly `trendReport` roll-up ($0.25) |
| `proxyConfiguration` | object | — | Residential (CN) | Defaults to Apify residential proxies; override only if you know why |

**Quick start input:**

```json
{
  "keyword": "led strip lights",
  "maxItems": 40,
  "includeDetails": true,
  "targetMarket": "US",
  "sort": "relevant"
}
```

Typical default run: 40 fully-enriched products ≈ **$0.33**, finished in under 5 minutes.

### For AI agents

Built to be called by software, not just clicked by people:

- **Complete output schema** — every delivered field (English titles, MOQ price ladders, supplier trust signals, dropship scores, landed cost, compliance) is typed and documented, so tool-calling loops can parse results without guesswork.
- **API-first** — one English keyword in; one POST to `run-sync-get-dataset-items` returns the final dataset in a single call. No Chinese required, no browser session, login or captcha step.
- **Agentic payments ready** — `maxTotalChargeUsd` sets a hard per-run budget the platform enforces, fail-not-billed (zero-result and refused runs cost $0, with a machine-readable `errorCode` in SUMMARY). Safe to hand an autonomous agent a budget and let it decide.

***

### Reviews

Found a bug or have a wishlist? Open an **Issue** — a fixed bug helps you more than a one-star rating, and we answer fast.

If this run saved you sourcing hours, a quick review on the Store page helps other buyers find it — 30 seconds, hugely appreciated.

# Actor input Schema

## `keyword` (type: `string`):

One English search keyword, e.g. "led strip lights" or "yoga mat". It is mapped to its Chinese equivalent and searched on 1688.com automatically — no Chinese required.

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

Number of products to deliver (1–200). Default 40 — the sweet spot: full detail coverage in ~5 minutes for a few cents. Large orders (>55) are automatically sharded across fresh identities so EVERY delivered item keeps full detail (run time and cost grow with size; SUMMARY reports exactly what you got). NOTE: when detail enrichment is ON, 20 items is the minimum — below that the run exits instantly with errorCode DETAILS\_MIN\_20, nothing charged.

## `includeDetails` (type: `boolean`):

ON (default): every delivered item carries the full detail layer — SKU price range, attributes, landed cost breakdown, suggested retail & margin estimate, dropship-ready score and compliance assessment. Requires maxItems >= 20 (economies of scale). OFF: a cheap card-only trial (headline price, titles, supplier card) at any batch size.

## `targetMarket` (type: `string`):

Drives the landed-cost tariff model and the compliance rulebook (required certifications, risk level, notes).

## `sort` (type: `string`):

Order of the DELIVERED dataset: relevance (platform search order), sales volume (most sold first) or unit price (low to high). The Actor passes the sort to 1688's search layer AND re-sorts the full delivery set before pushing, so the dataset always arrives in the promised order.

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

Minimum price in Chinese Yuan. Approximate filter ANCHORED to the card's min (bulk/MOQ) listing price: passed to 1688's search AND re-checked at delivery — cards whose min listing price falls below it are dropped (and never charged). Leave empty for no lower limit.

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

Maximum price in Chinese Yuan. Approximate filter ANCHORED to the card's min (bulk/MOQ) listing price: passed to 1688's search AND re-checked at delivery — cards whose min listing price exceeds it are dropped (and never charged). Note: a card's max (one-piece / top-of-ladder) price may still exceed this bound, since 1688 prices by quantity breaks. Leave empty for no upper limit.

## `maxTotalChargeUsd` (type: `number`):

Hard ceiling for this run's event charges. When the intended charge would exceed it, billing is truncated to fit (items delivered beyond the cap are FREE, never dropped) and SUMMARY.billing.truncatedByBudget tells you so. Leave empty for no code-level cap.

## `watchlistOfferIds` (type: `array`):

Up to 200 1688 offer IDs to watch (the numeric ID in a product URL, e.g. 994632611553). IDs beyond 200 are tail-truncated and never billed; invalid IDs are reported per-item and never billed.

## `historyDays` (type: `integer`):

How many days of snapshots the curve aggregates over (min / max / 7-day-low and the change metrics). Default 30.

## `alertOnPriceDropPct` (type: `number`):

Optional. Fire a priceDrop alert for an offer when its price fell by at least this percent versus the previous snapshot. Alerts are free (never billed). Leave empty to disable.

## `alertOnStockTightPct` (type: `number`):

Optional. Fire a stockTight alert for an offer when its bookable amount shrank by at least this percent versus the previous snapshot. Alerts are free (never billed). Leave empty to disable.

## `webhookUrl` (type: `string`):

Optional. When set and at least one alert fires, the run POSTs a JSON alert payload here. Time-bounded and non-fatal — a failing webhook is logged and never fails the run.

## `includeTrendReport` (type: `boolean`):

Optional. Also deliver a trendReport row aggregating the biggest price drops and stock-tightening offers across the watchlist. Billed at $0.25 per report (only when the history store was reachable). Default off.

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

Apify proxy configuration used for all 1688 traffic.

## Actor input object example

```json
{
  "keyword": "led strip lights",
  "maxItems": 40,
  "includeDetails": true,
  "targetMarket": "US",
  "sort": "relevant",
  "historyDays": 30,
  "includeTrendReport": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "proxyCountry": "CN"
  }
}
```

# Actor output Schema

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

One row per product researched on 1688.com: bilingual titles, price range and quantity-break ladder, MOQ, stock, supplier trust signals, dropship-ready score and grade, estimated landed cost in USD and compliance hints. Every row carries a scrapedAt freshness timestamp. Field meanings are described in the dataset schema (Overview view).

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

Machine-readable run report stored under the SUMMARY key: item totals, keyword stats, quality mix (full/partial/minimal), average dropship-ready score, billing ledger (intended vs charged events), PPE cost estimate and search/detail diagnostics.

# 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 = {
    "keyword": "led strip lights",
    "maxItems": 40,
    "includeDetails": true,
    "targetMarket": "US",
    "sort": "relevant",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "proxyCountry": "CN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawleast/1688-product-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 = {
    "keyword": "led strip lights",
    "maxItems": 40,
    "includeDetails": True,
    "targetMarket": "US",
    "sort": "relevant",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "proxyCountry": "CN",
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "keyword": "led strip lights",
  "maxItems": 40,
  "includeDetails": true,
  "targetMarket": "US",
  "sort": "relevant",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "proxyCountry": "CN"
  }
}' |
apify call crawleast/1688-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawleast/1688-product-scraper"
        }
    }
}

```

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

## OpenAPI specification

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