# Made-in-China Supplier & Product Scraper (`automation-lab/made-in-china-scraper`) Actor

🏭 Scrape public Made-in-China product listings, prices, MOQ, supplier names, locations, badges, ratings, and URLs for sourcing research.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

Extract public Made-in-China product listings and supplier summary data from search results, category pages, and keyword searches. The actor is built for sourcing workflows where you need product names, FOB prices, MOQ, supplier names, locations, badges, ratings, and listing URLs in a clean dataset.

### What does Made-in-China Supplier & Product Scraper do?

This actor visits public Made-in-China result pages and saves product listing rows to an Apify dataset. It does not log in, send inquiries, open chat, or scrape private account-only data.

Use it to collect public B2B marketplace intelligence such as:

- 🔎 Product listing titles and URLs
- 💵 Price ranges and minimum order quantities
- 🏭 Supplier names and profile URLs
- 📍 Supplier locations visible on listing cards
- ✅ Public badges such as Audited Supplier or Diamond Member
- 🖼️ Listing image URLs and video flags
- ⭐ Public rating/review snippets where visible

### Who is it for?

#### Importers and sourcing teams

Build supplier shortlists from Made-in-China categories and compare pricing, MOQ, and trust badges before contacting vendors.

#### Procurement analysts

Monitor supplier coverage for products such as solar panels, batteries, machinery, packaging, textiles, or components.

#### Market researchers

Export marketplace data to spreadsheets or BI tools to analyze product positioning, supplier clusters, and visible certification signals.

#### Ecommerce operators

Discover wholesale products and suppliers for private-label or marketplace sourcing workflows.

#### Lead generation teams

Create structured B2B prospect lists from public supplier listings without manually copying names and profile URLs.

### Why use this actor?

- ⚡ HTTP-first extraction, no heavy browser by default
- 📄 Works with public Made-in-China search/category URLs
- 🔁 Follows pagination with a configurable page limit
- 🧾 Produces clean table rows ready for CSV, Excel, JSON, or API export
- 🔐 Keeps login-only actions out of scope
- 💰 Pay-per-result pricing model for predictable costs

### What data can you extract?

| Field | Description |
| --- | --- |
| `position` | Result order in the dataset |
| `productName` | Public product listing title |
| `productUrl` | Product detail URL |
| `productId` | Product identifier parsed from the URL |
| `imageUrl` | First visible listing image URL |
| `price` | Public price/FOB range text |
| `minimumOrder` | MOQ text visible on the listing |
| `supplierName` | Supplier/company name |
| `supplierUrl` | Supplier profile URL |
| `supplierLocation` | Public location text |
| `supplierBadges` | Visible badge/certification labels |
| `rating` | Public rating text when shown |
| `reviewSnippet` | Public review snippet when shown |
| `hasVideo` | Whether the listing advertises video media |
| `hasSecuredTrading` | Whether Secured Trading text is visible |
| `inquiryUrl` | Public inquiry URL only; no form submission |
| `pageUrl` | Result page URL where the row was found |
| `searchUrl` | Original URL or keyword-derived source |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape Made-in-China suppliers?

The actor uses pay-per-event pricing: a small start event plus a per-result event for every saved product listing. Start with a low `maxItems` value to verify your input URLs, then scale up after checking the sample dataset.

For example, if you request 50 products, you should expect one start charge plus one result charge per product saved. Final platform pricing is shown on the Apify Store page before each run.

### How to use it

1. Open the actor on Apify.
2. Add one or more Made-in-China search/category URLs, or enter product keywords.
3. Set `maxItems` to the maximum number of listings you want.
4. Set `maxPagesPerInput` if you want deeper pagination.
5. Run the actor.
6. Download the dataset as CSV, XLSX, JSON, XML, or via API.

### Input options

#### `startUrls`

Paste public Made-in-China result pages, for example:

```json
[
  { "url": "https://www.made-in-china.com/products-search/hot-china-products/Solar_Panel.html" }
]
````

#### `searchTerms`

Enter keywords such as:

```json
["solar panel", "lithium battery", "packaging machine"]
```

The actor converts each keyword into a Made-in-China product search URL.

#### `maxItems`

Maximum product listing rows to save across all URLs and keywords.

#### `maxPagesPerInput`

Maximum paginated pages to follow per URL or keyword.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.made-in-china.com/products-search/hot-china-products/Solar_Panel.html" }
  ],
  "searchTerms": ["lithium battery"],
  "maxItems": 50,
  "maxPagesPerInput": 3
}
```

### Example output

```json
{
  "position": 1,
  "productName": "Black 120cells PV Panel Mono 360watt 370W 380wp 24V Solar Module Half Cell",
  "price": "US$0.10-0.13",
  "minimumOrder": "1,000 Watt",
  "supplierName": "Rosen Solar Energy Co., Ltd.",
  "supplierLocation": "Anhui, China",
  "supplierBadges": ["Diamond Member", "Audited Supplier"],
  "productUrl": "https://rosensolar.en.made-in-china.com/product/...html",
  "supplierUrl": "https://rosensolar.en.made-in-china.com",
  "hasVideo": true,
  "hasSecuredTrading": true,
  "scrapedAt": "2026-06-10T10:00:00.000Z"
}
```

### Tips for best results

- Start with `maxItems: 20` to validate a new URL.
- Use specific product keywords for better supplier relevance.
- Use Made-in-China result/category URLs rather than inquiry or account pages.
- Increase `maxPagesPerInput` only when you need deeper market coverage.
- Keep duplicate or overlapping URLs out of the same run when possible.

### Integrations

Connect this actor to common sourcing and analytics workflows:

- 📊 Export CSV/XLSX to Google Sheets or Excel for supplier comparison.
- 🧠 Send JSON results to a lead-scoring workflow.
- 🔁 Schedule daily or weekly runs for price/MOQ monitoring.
- 🧰 Use Apify webhooks to push completed datasets into your CRM or warehouse.
- 🧪 Compare product categories across repeated runs for market research.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/made-in-china-scraper').call({
  searchTerms: ['solar panel'],
  maxItems: 25,
  maxPagesPerInput: 2,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/made-in-china-scraper').call(run_input={
    'searchTerms': ['solar panel'],
    'maxItems': 25,
    'maxPagesPerInput': 2,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~made-in-china-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["solar panel"],"maxItems":25,"maxPagesPerInput":2}'
```

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP Server:

```text
https://mcp.apify.com/?tools=automation-lab/made-in-china-scraper
```

Claude Code setup example:

```bash
claude mcp add apify-made-in-china https://mcp.apify.com/?tools=automation-lab/made-in-china-scraper
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-made-in-china": {
      "url": "https://mcp.apify.com/?tools=automation-lab/made-in-china-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 30 Made-in-China solar panel suppliers and summarize the lowest MOQ suppliers."
- "Find public lithium battery listings and group suppliers by province."
- "Export product names, prices, and supplier badges from this Made-in-China category URL."

### Legality and responsible use

This actor extracts public information visible without logging in. It does not submit inquiry forms, bypass paywalls, access private accounts, or collect hidden user data. You are responsible for using the output in compliance with applicable laws, contracts, and Made-in-China terms.

### FAQ and troubleshooting

#### Why did I get fewer items than requested?

The selected URL or keyword may have fewer public listings than your `maxItems` value, or pagination may end before the limit is reached. Try another category URL or increase `maxPagesPerInput`.

#### Why are some fields empty?

Made-in-China does not show every field on every listing. For example, some products may not show a rating, review snippet, badge, or MOQ on the result page.

#### Can this actor send inquiries or scrape messages?

No. Inquiry, chat, basket, and message flows can require user interaction or login and are intentionally out of scope.

### Related scrapers

Explore related Automation Lab actors for sourcing, ecommerce, and lead generation workflows:

- https://apify.com/automation-lab/1688-scraper
- https://apify.com/automation-lab/alibaba-scraper
- https://apify.com/automation-lab/amazon-scraper
- https://apify.com/automation-lab/ebay-scraper
- https://apify.com/automation-lab/google-shopping-scraper

### Changelog

#### 0.1

Initial HTTP/Cheerio actor for public Made-in-China product listings and supplier summary fields.

# Actor input Schema

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

Public Made-in-China product search, category, or supplier product-list URLs to scrape.

## `searchTerms` (type: `array`):

Optional product keywords. Each keyword is converted to a Made-in-China product search URL.

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

Maximum number of product listing rows to save across all URLs and keywords.

## `maxPagesPerInput` (type: `integer`):

How many paginated result pages to follow for each URL or keyword.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.made-in-china.com/products-search/hot-china-products/Solar_Panel.html"
    }
  ],
  "searchTerms": [
    "solar panel"
  ],
  "maxItems": 20,
  "maxPagesPerInput": 3
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.made-in-china.com/products-search/hot-china-products/Solar_Panel.html"
        }
    ],
    "searchTerms": [
        "solar panel"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "startUrls": [{ "url": "https://www.made-in-china.com/products-search/hot-china-products/Solar_Panel.html" }],
    "searchTerms": ["solar panel"],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "startUrls": [
    {
      "url": "https://www.made-in-china.com/products-search/hot-china-products/Solar_Panel.html"
    }
  ],
  "searchTerms": [
    "solar panel"
  ]
}' |
apify call automation-lab/made-in-china-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Made-in-China Supplier & Product Scraper",
        "description": "🏭 Scrape public Made-in-China product listings, prices, MOQ, supplier names, locations, badges, ratings, and URLs for sourcing research.",
        "version": "0.1",
        "x-build-id": "SVMwcv3u9ZqfCYRYs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~made-in-china-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~made-in-china-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~made-in-china-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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",
                "properties": {
                    "startUrls": {
                        "title": "Made-in-China URLs",
                        "type": "array",
                        "description": "Public Made-in-China product search, category, or supplier product-list URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerms": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Optional product keywords. Each keyword is converted to a Made-in-China product search URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of product listing rows to save across all URLs and keywords.",
                        "default": 20
                    },
                    "maxPagesPerInput": {
                        "title": "Maximum pages per input",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many paginated result pages to follow for each URL or keyword.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```