# Made-in-China.com Scraper - Suppliers, Prices & MOQ (`haketa/made-in-china-scraper`) Actor

Search Made-in-China.com and extract products with FOB prices, MOQ, specs, certifications, OEM/sample support and supplier credentials (Diamond Member, Audited Supplier) for B2B sourcing.

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

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Made-in-China.com Scraper – Chinese Suppliers, Prices, MOQ & Certifications

**Extract product and supplier data from [Made-in-China.com](https://www.made-in-china.com/), one of the largest B2B platforms for sourcing from China, in minutes.** This Made-in-China scraper turns any keyword into a clean, structured database of Chinese manufacturers and trading companies — complete with **FOB prices, minimum order quantities (MOQ), product specifications, supplier credentials (Diamond Member, Audited Supplier), business type, province, certifications and supplier websites.**

Whether you are doing **product sourcing, import research, price comparison, supplier verification, dropshipping or competitor analysis**, this Actor gives you ready-to-use data exported as **JSON, CSV, Excel, or via API** — no coding required.

> 💡 Built for importers, sourcing agents, Amazon/eBay sellers, procurement teams, dropshippers and B2B buyers who need reliable Chinese supplier data at scale — a fast, affordable alternative to manual sourcing.

---

### 🔎 Why scrape Made-in-China.com?

Made-in-China.com connects global buyers with hundreds of thousands of Chinese suppliers across virtually every product category — electronics, lighting, machinery, textiles, auto parts, packaging, hardware, chemicals and more. It is one of the richest public sources of Chinese manufacturer data, alongside Alibaba and Global Sources.

But Made-in-China has no public bulk export, and copying listings by hand is slow. This scraper automates everything: you give it keywords, it returns hundreds of clean supplier and product records you can sort, filter and import anywhere.

**Common reasons people scrape Made-in-China.com:**

- Build **supplier shortlists** of Chinese manufacturers for a product
- Compare **FOB prices and MOQ** across dozens of suppliers
- Verify supplier **credibility** (Audited Supplier, Diamond Member, business type)
- Source products for **import, Amazon FBA, retail, dropshipping or private label**
- Monitor **prices and new products** in a category over time
- Run **market and competitor research** on Chinese manufacturing

---

### ✨ What this Made-in-China scraper does

- ✅ Searches Made-in-China.com by **any keyword** (e.g. `led light`, `solar panel`, `hydraulic pump`, `power bank`)
- ✅ Returns **hundreds of products per keyword** with automatic pagination (de-duplicated by product ID)
- ✅ Captures **full product details** — name, FOB price range, MOQ, specifications, image, product URL and ID
- ✅ Captures **supplier credentials** — company name, website, business type, province, Diamond Member tier, Audited Supplier status
- ✅ Extracts **supplier intelligence** — quality certification signals, OEM service, export experience and more
- ✅ Powerful **filters** — only Audited Suppliers, only Diamond Members, only manufacturers/factories, only suppliers offering samples
- ✅ Exports to **JSON, CSV, Excel, XML** and integrates with Google Sheets, Make, Zapier, Slack and your own apps
- ✅ **Fast and affordable** — runs at scale without heavy anti-bot overhead

---

### 🎯 Use cases

#### 1. Product sourcing & supplier discovery
Find Chinese manufacturers for any product in minutes. Each record includes the **company name, website, business type, province, FOB price and MOQ** — everything you need to build a supplier shortlist and start outreach. Filter to manufacturers only to skip pure trading companies.

#### 2. Import & Amazon FBA research
Evaluate landed-cost potential before you buy. Pull FOB price ranges and MOQ across dozens of suppliers for the same product, so you can model margins for **Amazon FBA, retail arbitrage or private label** and pick the right supplier.

#### 3. Price comparison & benchmarking
Compare prices for the same product across many suppliers to find the most competitive source and benchmark quotes you've received. Re-run on a schedule to track how prices move over time.

#### 4. Supplier verification & risk reduction
Reduce sourcing risk by filtering for **Audited Suppliers** (passed Made-in-China's third-party audit) and **Diamond Members** (top-tier paid membership). Combine with business type and certification signals to qualify suppliers before contacting them.

#### 5. Dropshipping & private label sourcing
Discover manufacturers for products you want to sell, complete with MOQ, specifications and images, so you can evaluate suppliers before requesting samples. Filter to suppliers that offer samples.

#### 6. Market & competitor research
Map out who manufactures what, in which province, at what price, and with what credentials in any category — invaluable for market-entry analysis, competitive benchmarking and category planning.

#### 7. Lead generation for B2B services
Logistics, inspection, trade-finance and SaaS companies use the data to build targeted lists of active Chinese exporters by category and province.

---

### 🏭 Popular categories & industries you can scrape

Made-in-China.com covers virtually every manufacturing category. This scraper handles all of them — just type any product into `queries`. Popular examples:

- **Lighting & electrical** — LED lights, strip lights, lamps, switches, cables
- **Electronics** — power banks, chargers, sensors, PCB, consumer gadgets
- **Machinery** — CNC machines, hydraulic pumps, compressors, packaging machines
- **Auto & motorcycle parts** — bearings, filters, lamps, accessories
- **Home & garden** — furniture, kitchenware, décor, tools
- **Textiles & apparel** — fabric, garments, bags, footwear
- **Building & hardware** — fasteners, valves, pipes, fittings
- **Packaging & printing** — boxes, bottles, labels, pouches
- **Sporting goods & toys** — fitness gear, outdoor equipment, toys
- **Chemicals & plastics** — additives, resins, raw materials

…and thousands more product categories across China's manufacturing base.

---

### ⚙️ How it works

1. **Enter one or more search keywords** — exactly what you'd type into the Made-in-China.com search box.
2. **Set how many results you want** per keyword and (optionally) apply filters.
3. **Run the Actor** — it collects, de-duplicates and structures the data, then makes it available for download or via API.

No login, no captcha solving, and a sensible proxy default is built in.

#### 🔬 Deep product details (optional)

Most Made-in-China scrapers stop at the search listing. Enable **`scrapeProductDetails`** and this Actor also visits each product's detail page to pull the data buyers actually negotiate on:

- **Full specification table** — model, power, voltage, IP rating, beam angle, lifespan and every other attribute the supplier listed
- **Certifications** — CE, RoHS, CCC, ISO and more, plus management certs like ISO9001:2015 / ISO14001
- **HS code** — the customs classification you need for import/export and duty calculation
- **Production capacity** — e.g. `10000PC/Month`, to judge whether a supplier can meet your volume
- **Packaging & logistics** — transport package, carton size and gross weight
- **Brand, SKU, MPN, full description and all product images**

This turns a quick supplier list into a sourcing-grade dataset. It's optional because it adds one request per product (slower, more compute), so enable it when you need depth rather than just breadth.

---

### ✅ Proven results (real runs)

| Use case | Input | Items | Audited | Manufacturer | Province | Member tier |
| --- | --- | --- | --- | --- | --- | --- |
| Supplier list | `led light`, 90 | 90 unique | 98% | — | 100% | 100% |
| Audited factories | `solar panel` + audited + manufacturers | 45 | 100% | 100% | 100% | 100% |

Product name, FOB price, MOQ, specifications, company name, supplier URL, member tier and province come back on **virtually every record** — and the filters work exactly as expected: an "audited manufacturers" run returns only audited factories.

### 🔧 Input parameters

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `queries` | array | ✅ Yes | One or more search terms, exactly as typed into Made-in-China.com (e.g. `led light`, `solar panel`). |
| `maxItemsPerQuery` | integer | No | Maximum products to collect per keyword. ~30 products per page, paginated automatically. Default `60`. |
| `onlyAuditedSuppliers` | boolean | No | Keep only suppliers with the Audited Supplier badge (third-party verified). Default `false`. |
| `onlyDiamondMembers` | boolean | No | Keep only top-tier Diamond Member suppliers. Default `false`. |
| `onlyManufacturers` | boolean | No | Keep only manufacturers/factories (filters out pure trading companies). Default `false`. |
| `supportsSample` | boolean | No | Keep only products whose supplier offers samples. Default `false`. |
| `scrapeProductDetails` | boolean | No | Visit each product's detail page for full specs, certifications, HS code, production capacity, packaging and brand/SKU. Richer but slower. Default `false`. |
| `proxyConfiguration` | object | No | Apify Proxy settings. Datacenter proxies work well. |

#### Example input — simple supplier list

```json
{
    "queries": ["led light"],
    "maxItemsPerQuery": 120
}
````

#### Example input — audited factories only

```json
{
    "queries": ["solar panel", "lithium battery"],
    "maxItemsPerQuery": 200,
    "onlyAuditedSuppliers": true,
    "onlyManufacturers": true
}
```

#### Example input — top-tier suppliers offering samples

```json
{
    "queries": ["power bank"],
    "maxItemsPerQuery": 100,
    "onlyDiamondMembers": true,
    "supportsSample": true
}
```

***

### 📤 Output

The Actor stores one row per product, each with full supplier context. Data can be downloaded as **JSON, CSV, Excel, XML** or pulled via the Apify API.

#### Sample output record

```json
{
    "productName": "IP67 Waterproof LED Floor Tile Light for Decoration Landscape Lighting",
    "productUrl": "https://lishidagp.en.made-in-china.com/product/nTBRSZOwZYra/...html",
    "productId": "nTBRSZOwZYra",
    "priceText": "US$44.00-49.00",
    "priceMin": 44,
    "priceMax": 49,
    "currency": "USD",
    "priceType": "FOB",
    "minOrderQuantity": "100 Pieces",
    "specifications": {
        "LED Chips Brand": "Epistar",
        "Material": "Aluminum",
        "Warranty": "3 Years"
    },
    "image": "https://image.made-in-china.com/.../1.webp",
    "supportsSample": false,
    "tradeAssurance": true,
    "companyName": "Sichuan Lishida Smart Lighting Technology Co., Ltd.",
    "supplierUrl": "https://lishidagp.en.made-in-china.com",
    "businessType": "Manufacturer/Factory",
    "memberType": "Diamond Member",
    "isAuditedSupplier": true,
    "supplierProvince": "Sichuan",
    "providesOem": true,
    "hasQualityCertification": true,
    "exportYears": 10,
    "searchKeyword": "led light",
    "page": 1,
    "scrapedAt": "2026-05-25T16:00:00.000Z"
}
```

#### Output fields reference

**Product fields**

| Field | Description |
| --- | --- |
| `productName` | Product title |
| `productUrl` | Link to the product page |
| `productId` | Made-in-China product ID (used for de-duplication) |
| `priceText` | Human-readable FOB price, e.g. `US$44.00-49.00` |
| `priceMin` / `priceMax` | Numeric price range |
| `currency` | Price currency (USD) |
| `priceType` | Price basis (FOB when shown) |
| `minOrderQuantity` | Minimum order quantity, e.g. `100 Pieces` |
| `specifications` | Structured product attributes (brand, material, warranty…) |
| `image` | Product image URL |
| `supportsSample` | Whether the supplier offers samples |
| `tradeAssurance` | Secured-trading / trade-assurance flag |

**Supplier fields**

| Field | Description |
| --- | --- |
| `companyName` | Supplier company name |
| `supplierUrl` | Supplier's store on Made-in-China.com |
| `companyProfileUrl` | Supplier profile / company page |
| `businessType` | Manufacturer/Factory, Trading Company, or both |
| `memberType` | Membership tier (e.g. Diamond Member) |
| `isAuditedSupplier` | Passed Made-in-China's third-party audit |
| `supplierProvince` | Chinese province (e.g. Guangdong, Zhejiang) |
| `providesOem` | OEM service signal |
| `hasQualityCertification` | ISO9001 / quality-management signal |
| `exportYears` | Years of export experience (when shown) |

**Deep detail fields** (only when `scrapeProductDetails` is enabled)

| Field | Description |
| --- | --- |
| `detailedSpecifications` | Full product spec table (model, power, voltage, IP rating, CCT…) |
| `certifications` | Product certifications, e.g. `["CE","RoHS","CCC","ISO"]` |
| `hsCode` | Harmonized System (HS) customs code — useful for import/export |
| `productionCapacity` | Stated production capacity, e.g. `10000PC/Month` |
| `transportPackage` | Packaging description |
| `packageSize` / `packageWeight` | Carton dimensions and gross weight |
| `trademark` | Brand/trademark |
| `origin` | Place of origin |
| `modelNumber` | Manufacturer model number |
| `sku` / `mpn` | Made-in-China SKU and manufacturer part number |
| `brand` | Brand name |
| `fullDescription` | Full product description |
| `detailImages` | All product images from the detail page |
| `availability` | Stock availability (e.g. InStock) |
| `qualityCertifications` | Management certs, e.g. `["ISO9001:2015","ISO14001"]` |

**Metadata**

| Field | Description |
| --- | --- |
| `searchKeyword` | The keyword this record came from |
| `page` | Result page number |
| `scrapedAt` | Timestamp of extraction |

***

### ✅ Why this scraper stands out

- **Supplier credentials, not just listings.** Member tier, audited status, business type and province come back on virtually every record — the signals that actually matter when qualifying a Chinese supplier.
- **Extra supplier intelligence** parsed straight from the listing — OEM service, quality-certification and export-experience signals that most scrapers skip.
- **De-duplication built in.** De-duplicated by product ID, so overlapping keywords never produce duplicate rows.
- **Powerful, sourcing-focused filters** — audited only, Diamond only, manufacturers only, samples only.

***

### 🧰 Filters explained

- **Only Audited Suppliers (`onlyAuditedSuppliers`)** — keep suppliers that passed Made-in-China's third-party audit. The single best filter for reducing sourcing risk.
- **Only Diamond Members (`onlyDiamondMembers`)** — keep top-tier paid-membership suppliers, usually more established exporters.
- **Only manufacturers (`onlyManufacturers`)** — keep factories and skip pure trading companies, so you can source closer to the source.
- **Only sample-offering (`supportsSample`)** — keep suppliers that provide samples, ideal before placing a bulk order.

Combine filters freely — for example, *audited manufacturers offering samples* — to produce a tightly qualified supplier list.

***

### 🔌 Integrations

Send your Made-in-China data anywhere with Apify's built-in integrations and webhooks:

- **Google Sheets** — push supplier lists straight into a spreadsheet
- **Make (Integromat) & Zapier** — trigger workflows on every run
- **Slack / email** — get notified when new data is ready
- **CRMs & databases** — via API, webhooks or no-code connectors
- **Your own app** — pull results through the Apify API in JSON

***

### ▶️ How to use this Made-in-China scraper (step by step)

1. Click **Try for free** at the top of this page.
2. In the **Input** tab, add your search keywords under `queries`.
3. Set `maxItemsPerQuery` (e.g. `120`) and apply any filters you need.
4. Click **Start** and wait for the run to finish.
5. Open the **Output / Dataset** tab and download your data as **JSON, CSV or Excel**, or copy the API endpoint to pull it programmatically.

You can also **schedule** the Actor to run daily/weekly to keep your supplier data fresh.

***

### ❓ Frequently asked questions

**Does it include supplier phone numbers and emails?**
Direct contact details on Made-in-China are gated behind login / inquiry forms, so personal phone numbers and emails are not included. You do get the supplier's **store URL and company profile page**, business type, province and credentials — the best starting points for outreach and contact enrichment.

**What is an Audited Supplier?**
A supplier whose company and capabilities have been verified by a third-party inspection commissioned by Made-in-China. The `isAuditedSupplier` field flags these, and `onlyAuditedSuppliers` keeps only them.

**What is a Diamond Member?**
Diamond Member is the highest paid membership tier on Made-in-China — usually more established suppliers with stronger export track records. Use `onlyDiamondMembers` to focus on them.

**How many results can I get?**
Made-in-China paginates deeply, so a single keyword can return hundreds of products. Set `maxItemsPerQuery` to your target and the scraper paginates automatically.

**Can I get prices and MOQ?**
Yes. FOB price ranges (`priceMin`/`priceMax`/`priceText`) and `minOrderQuantity` are returned on virtually every product.

**Can I filter to factories only?**
Yes — enable `onlyManufacturers` to keep suppliers whose business type includes Manufacturer/Factory and skip pure trading companies.

**What export formats are supported?**
JSON, CSV, Excel (XLSX), XML and RSS — plus direct API access.

**How much does it cost to run?**
You only pay for the results you collect (pay-per-result). Made-in-China has no heavy anti-bot protection, so runs are fast and economical even at scale.

**Can I run it on a schedule?**
Yes. Use Apify Schedules to run the scraper automatically and keep your supplier database up to date.

**How fresh is the data?**
Every run scrapes Made-in-China.com live, so the prices, MOQ and supplier credentials reflect what's on the platform at the moment you run it. Schedule recurring runs to track changes over time.

**Can I scrape a specific supplier or category page?**
This version is keyword-driven, which covers the most common sourcing workflow. For category- or supplier-specific needs, use precise keywords (e.g. `outdoor solar street light`) to narrow results to the niche you care about.

**What's the difference between Audited Supplier and Diamond Member?**
*Diamond Member* is a paid membership tier (signals investment and tenure). *Audited Supplier* means a third party physically verified the company. For lower-risk sourcing, prefer suppliers that are **both** — easy to do by combining `onlyAuditedSuppliers` and `onlyDiamondMembers`.

**Will I get duplicate suppliers if I use several keywords?**
No. Results are de-duplicated by product ID across the whole run, so overlapping keywords never produce duplicate rows.

**Is scraping Made-in-China.com legal?**
This Actor collects only publicly available data. You are responsible for using the data in compliance with Made-in-China.com's terms of use and applicable laws.

***

### 💡 Tips & best practices

- **Use specific keywords.** `outdoor led flood light` returns more relevant suppliers than just `led light`. Combine several related keywords for broader coverage.
- **Filter early.** Turn on `onlyAuditedSuppliers` and `onlyManufacturers` to focus on high-quality, factory-direct suppliers from the start.
- **Set a realistic `maxItemsPerQuery`.** 100–300 per keyword is a good range for most sourcing projects.
- **Compare across suppliers.** Export to a spreadsheet and sort by `priceMin` and `minOrderQuantity` to spot the best offers fast.
- **Schedule regular runs** to monitor prices and discover newly listed suppliers over time.
- **De-duplication is automatic** — feel free to add overlapping keywords.
- **Prefer "both" credentials.** Suppliers that are both Audited and Diamond Member tend to be the safest bet for first orders.
- **Watch the province.** Clusters like Guangdong and Zhejiang often mean more competitive pricing and mature supply chains for electronics and lighting.
- **Export to a spreadsheet** and pivot by province or member tier to spot the strongest sourcing regions for your product at a glance.

***

### ⚠️ Limitations

- Personal emails and direct phone numbers are gated behind login / inquiry forms and are **not** included.
- Some supplier-intelligence signals (OEM, certification, export years) are only shown for part of the listings and may be empty when the platform doesn't display them publicly.
- Result volume per keyword depends on how many products Made-in-China lists for that term.

***

### 🚀 Get started

Click **Try for free**, enter a keyword like `led light` or `solar panel`, and get a clean list of verified Chinese suppliers — with FOB prices, MOQ, credentials and websites — in minutes. Perfect for **product sourcing, import research, price comparison and supplier verification**.

Have a feature request or question? Open an issue from the Actor's page and we'll help.

***

### 🔗 Related sourcing scrapers

Sourcing from more than one marketplace? Combine this scraper with other B2B supplier scrapers on Apify to compare Chinese and Indian suppliers side by side, or to enrich an existing supplier database across platforms. Use precise keywords on each platform and merge the de-duplicated results in your spreadsheet or CRM for a complete sourcing picture.

# Actor input Schema

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

One or more product search terms, exactly as you would type them into the Made-in-China.com search box (e.g. "led light", "solar panel", "hydraulic pump").

## `maxItemsPerQuery` (type: `integer`):

Maximum number of products to collect for each search query. Made-in-China returns ~30 products per page and is paginated automatically.

## `onlyAuditedSuppliers` (type: `boolean`):

Keep only suppliers that have passed Made-in-China's third-party audit (Audited Supplier badge). Raises supplier trustworthiness.

## `onlyDiamondMembers` (type: `boolean`):

Keep only top-tier Diamond Member suppliers (the highest paid membership, usually more established exporters).

## `onlyManufacturers` (type: `boolean`):

Keep only suppliers whose business type includes Manufacturer / Factory (filters out pure trading companies). Best for buyers who want to source directly from the factory.

## `supportsSample` (type: `boolean`):

Keep only products whose supplier offers samples.

## `scrapeProductDetails` (type: `boolean`):

Visit each product's detail page to extract full specifications, certifications (CE, RoHS, ISO…), HS code, production capacity, packaging, brand/SKU/MPN and all images. Much richer data, but slower and uses more compute (one extra request per product).

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

Made-in-China.com has no aggressive anti-bot, so inexpensive datacenter proxies work well. A proxy is recommended to avoid rate limits on large runs.

## Actor input object example

```json
{
  "queries": [
    "led light",
    "solar panel"
  ],
  "maxItemsPerQuery": 30,
  "onlyAuditedSuppliers": false,
  "onlyDiamondMembers": false,
  "onlyManufacturers": false,
  "supportsSample": false,
  "scrapeProductDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Clean JSON array of every scraped product with its supplier details.

## `productsCsv` (type: `string`):

The same data as a spreadsheet-ready CSV file.

## `dataset` (type: `string`):

Default dataset of this run for programmatic access.

# 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 = {
    "queries": [
        "led light"
    ],
    "maxItemsPerQuery": 30,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/made-in-china-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 = {
    "queries": ["led light"],
    "maxItemsPerQuery": 30,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/made-in-china-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 '{
  "queries": [
    "led light"
  ],
  "maxItemsPerQuery": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/made-in-china-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Made-in-China.com Scraper - Suppliers, Prices & MOQ",
        "description": "Search Made-in-China.com and extract products with FOB prices, MOQ, specs, certifications, OEM/sample support and supplier credentials (Diamond Member, Audited Supplier) for B2B sourcing.",
        "version": "0.1",
        "x-build-id": "AbPBFenJmafTcF9IH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~made-in-china-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-made-in-china-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/haketa~made-in-china-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-made-in-china-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/haketa~made-in-china-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-made-in-china-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "One or more product search terms, exactly as you would type them into the Made-in-China.com search box (e.g. \"led light\", \"solar panel\", \"hydraulic pump\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerQuery": {
                        "title": "Max items per query",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to collect for each search query. Made-in-China returns ~30 products per page and is paginated automatically.",
                        "default": 60
                    },
                    "onlyAuditedSuppliers": {
                        "title": "Only Audited Suppliers",
                        "type": "boolean",
                        "description": "Keep only suppliers that have passed Made-in-China's third-party audit (Audited Supplier badge). Raises supplier trustworthiness.",
                        "default": false
                    },
                    "onlyDiamondMembers": {
                        "title": "Only Diamond Members",
                        "type": "boolean",
                        "description": "Keep only top-tier Diamond Member suppliers (the highest paid membership, usually more established exporters).",
                        "default": false
                    },
                    "onlyManufacturers": {
                        "title": "Only manufacturers / factories",
                        "type": "boolean",
                        "description": "Keep only suppliers whose business type includes Manufacturer / Factory (filters out pure trading companies). Best for buyers who want to source directly from the factory.",
                        "default": false
                    },
                    "supportsSample": {
                        "title": "Only suppliers offering samples",
                        "type": "boolean",
                        "description": "Keep only products whose supplier offers samples.",
                        "default": false
                    },
                    "scrapeProductDetails": {
                        "title": "Scrape full product detail pages (richer, slower)",
                        "type": "boolean",
                        "description": "Visit each product's detail page to extract full specifications, certifications (CE, RoHS, ISO…), HS code, production capacity, packaging, brand/SKU/MPN and all images. Much richer data, but slower and uses more compute (one extra request per product).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Made-in-China.com has no aggressive anti-bot, so inexpensive datacenter proxies work well. A proxy is recommended to avoid rate limits on large runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```