# Alibaba Product Details Scraper (`alpha-scraper/alibaba-product-details-scraper`) Actor

Extract structured product data from Alibaba with the Alibaba Product Details Scraper. Collect product names, descriptions, brands, SKUs, MPNs, images, prices, availability, offer data, and source URLs from one or more Alibaba pages or search URLs.

- **URL**: https://apify.com/alpha-scraper/alibaba-product-details-scraper.md
- **Developed by:** [Alpha Scraper](https://apify.com/alpha-scraper) (community)
- **Categories:** SEO tools, E-commerce, Lead generation
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Alibaba Product Details Scraper

The **Alibaba Product Details Scraper** extracts structured product information from Alibaba pages and returns the collected data as dataset records in Apify. It is designed for users who need product metadata in a structured format for research, catalog building, product analysis, market research, supplier discovery, or downstream automation.

Provide one or more Alibaba URLs through the `startUrls` input. The Actor can process direct Alibaba product-detail URLs and can also process Alibaba search URLs, extracting product-page links found in the search results before collecting product information.

For each successfully processed product page, the output can include the source URL, product ID, name, description, SKU, MPN, brand, product images, offer count, availability, currency, price, price-validity date, and the time the data was collected.

### What Is the Alibaba Product Details Scraper?

The Alibaba Product Details Scraper is a structured product data extraction tool for Alibaba pages.

Its workflow is straightforward:

**Alibaba URL → page processing → product metadata extraction → structured dataset output**

You can provide multiple URLs in a single run. Direct product URLs are processed as individual product pages, while supported Alibaba search URLs are examined for product links. The extracted records are then pushed to the Actor dataset.

The Actor focuses on product information that is available in the page's structured metadata or relevant page metadata. This makes the resulting records useful for product research and data workflows without requiring users to manually copy information from individual Alibaba pages.

### Key Features

| Feature                    | Description                                                                           | User Benefit                                                      |
| -------------------------- | ------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| Alibaba product extraction | Collects product information from Alibaba product pages                               | Reduces repetitive manual product research                        |
| Multiple URL input         | Accepts one or more entries in `startUrls`                                            | Process several Alibaba URLs in one run                           |
| Direct product URL support | Accepts Alibaba `/product-detail/` and `/p-detail/` links                             | Target specific products directly                                 |
| Search URL processing      | Can inspect Alibaba search pages and collect product links                            | Useful for discovering multiple product pages from search results |
| Structured product data    | Returns product attributes as dataset fields                                          | Easier analysis and downstream processing                         |
| Product metadata           | Extracts fields such as name, brand, SKU, MPN, price, and availability when available | Provides useful catalog information                               |
| Product images             | Collects product image URLs when present                                              | Supports image-based research and catalog workflows               |
| Collection timestamp       | Adds `scrapedAt` to each successful result                                            | Helps identify when a record was collected                        |
| Dataset output             | Pushes valid product records to the Actor dataset                                     | Convenient for further data processing                            |

### What Data Can You Extract?

The Alibaba Product Details Scraper returns a consistent set of fields for successful product records. Actual values depend on the information available on the Alibaba page being processed.

The main data categories include:

**Product identity:** Product name, Alibaba product ID, SKU, and MPN.

**Product description:** A cleaned product description when structured product metadata or page metadata provides one.

**Brand information:** Brand name when available.

**Images:** Product image URLs discovered from the product metadata or page metadata.

**Offer information:** Offer count, availability, price currency, price, and price-validity information when available.

**Source information:** The original Alibaba URL used for the record.

**Collection metadata:** The UTC timestamp recorded in `scrapedAt`.

Because product pages can differ in the metadata they expose, some fields may contain empty values or defaults when the source page does not provide the corresponding information.

### Why Use This Actor?

Manually collecting Alibaba product information becomes repetitive when researching many product pages. This Actor turns supported Alibaba URLs into structured records that are easier to review, compare, store, and process.

It can be useful when you need to:

- Build a structured Alibaba product dataset.
- Research products and suppliers.
- Collect product names, descriptions, prices, brands, and identifiers.
- Gather product image URLs for catalog research.
- Analyze product metadata across multiple pages.
- Create datasets for internal research or business intelligence workflows.
- Reduce manual copy-and-paste work.

The main advantage is the conversion of page-level product information into a consistent dataset structure.

### Benefits

#### Structured product research

Instead of reviewing every product page manually, you receive records containing defined product fields such as `name`, `brand`, `price`, and `availability`.

#### Multiple URL processing

The `startUrls` field accepts an array, allowing you to provide multiple Alibaba URLs in one Actor run.

#### Search-driven product discovery

Alibaba search URLs can be processed to identify product-detail links before product information is collected.

#### Easier downstream analysis

Structured records are more convenient for filtering, comparing, transforming, or integrating into a larger data workflow than unstructured page content.

#### Useful product metadata

The output includes identifiers, descriptive information, commercial fields, image URLs, and collection timing where available.

### How to Use the Alibaba Product Details Scraper

1. Open the Actor in Apify.
2. Add one or more Alibaba URLs to `startUrls`.
3. Use direct Alibaba product-detail pages when you already know which products you want to collect.
4. You can also provide Alibaba search URLs for product discovery.
5. Start the Actor.
6. Review the resulting dataset records.
7. Use the structured results for research, analysis, catalog preparation, or another supported workflow.

For an initial test, start with a small number of URLs and confirm that the returned fields match your intended data workflow before processing a larger collection.

### Input

The Actor exposes one user-configurable input field in `actor.json`: `startUrls`.

#### Input Fields

| Field       | Type  | Required | Default | Description                                                                                                                          |
| ----------- | ----- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| `startUrls` | Array | No       | None    | One or more Alibaba URLs to process. Direct product-detail URLs and Alibaba search URLs are supported by the current Actor behavior. |

The `startUrls` array is designed for request-list style input. Each entry should contain a URL.

Direct product pages are recognized when the URL contains `/product-detail/` or `/p-detail/`.

Other Alibaba URLs are treated as search-page inputs by the current processing logic. When a supported search page contains product-detail links, those links can be collected and subsequently processed.

### Input Example

```json
{
  "startUrls": [
    {
      "url": "https://www.alibaba.com/product-detail/Purses-Handbags-Set-Fashion-Handbags-Bags_1601698369199.html"
    },
    {
      "url": "https://www.alibaba.com/product-detail/Real-High-Quality-S24-Ultra-2025_1601536239140.html"
    }
  ]
}
```

You can replace these example URLs with the Alibaba product or search URLs you want to process.

### Output

Each successfully processed product produces a structured record. The Actor writes valid results to the dataset.

| Field             | Description                                                 |
| ----------------- | ----------------------------------------------------------- |
| `sourceUrl`       | Original Alibaba URL processed for the product              |
| `id`              | Product identifier extracted from the URL when available    |
| `name`            | Product name                                                |
| `description`     | Product description after HTML markup is cleaned            |
| `sku`             | Product SKU when available                                  |
| `mpn`             | Manufacturer part number when available                     |
| `brand`           | Brand name when available                                   |
| `images`          | Array of product image URLs                                 |
| `offerCount`      | Number of offers reported by the available product metadata |
| `availability`    | Product availability value when available                   |
| `priceCurrency`   | Currency associated with the product price                  |
| `price`           | Product price value                                         |
| `priceValidUntil` | Price validity date when provided                           |
| `scrapedAt`       | UTC timestamp showing when the record was collected         |

Several values originate from structured product metadata when available. The Actor also uses page metadata as a fallback for important fields such as the product name, image, and description.

### Output Example

```json
{
  "sourceUrl": "https://www.alibaba.com/product-detail/example-product_1600000000000.html",
  "id": "1600000000000",
  "name": "Example Product",
  "description": "Example product description",
  "sku": "SKU-12345",
  "mpn": "MPN-67890",
  "brand": "Example Brand",
  "images": [
    "https://example.com/product-image.jpg"
  ],
  "offerCount": 1,
  "availability": "InStock",
  "priceCurrency": "USD",
  "price": 19.99,
  "priceValidUntil": "",
  "scrapedAt": "2026-09-20T10:00:00Z"
}
```

The example illustrates the output structure. Actual product values depend on the Alibaba page and the information exposed by that page.

### Use Cases

#### Alibaba product research

Collect structured product information for research projects involving names, descriptions, brands, prices, identifiers, and availability.

#### Product catalog analysis

Create datasets containing product metadata that can be reviewed or transformed into internal catalog information.

#### Market research

Compare product characteristics and commercial metadata across a set of Alibaba pages.

#### Supplier and sourcing research

Collect product-level information while researching potential products and sourcing opportunities.

#### Competitive product analysis

Build structured records from selected Alibaba pages for internal product comparison and market observation.

#### Dataset creation

Generate reusable product datasets for analytics, filtering, reporting, or other data-processing workflows.

#### Automation workflows

Use structured dataset records as inputs to subsequent data-processing tasks where product metadata is required.

### Advantages

The Actor is especially useful when the goal is to collect Alibaba product metadata in a predefined structure instead of manually transferring information from web pages.

Its practical strengths include support for multiple URL inputs, processing of direct product pages, search-result product discovery, structured output fields, image URL collection, and a collection timestamp.

The output structure is also predictable enough to make common product fields easy to locate across records, while fields that are unavailable on a specific page can remain empty or use the Actor's documented fallback/default behavior.

### Limitations

The Actor depends on information available from the Alibaba pages it processes. As a result, not every product page is guaranteed to provide every optional metadata field.

For example, `sku`, `mpn`, `brand`, `priceValidUntil`, or other product attributes may be empty when the corresponding information is not available in the page metadata.

Search-page processing also depends on product-detail links being present in the processed Alibaba search page. The current default behavior takes up to 10 discovered product URLs from each processed search URL.

Only successfully fetched and parsed product pages are pushed as valid results. A URL that cannot be successfully processed does not produce a normal product record.

### Pros and Cons

| Pros                                            | Cons                                                                            |
| ----------------------------------------------- | ------------------------------------------------------------------------------- |
| Structured Alibaba product records              | Some fields may be unavailable on individual pages                              |
| Supports multiple `startUrls` entries           | Search results depend on product links being available                          |
| Supports direct product URLs                    | Failed pages do not produce normal output records                               |
| Can process Alibaba search URLs                 | Search URL processing uses the current built-in default item selection behavior |
| Includes product images and commercial metadata | Source data can vary from page to page                                          |
| Includes collection timestamps                  | Empty fields are possible when source metadata is incomplete                    |

### Comparison With Alternative Approaches

| Capability                      | This Actor                                | Manual / Typical Alternative               |
| ------------------------------- | ----------------------------------------- | ------------------------------------------ |
| Multiple Alibaba URLs           | Supported through `startUrls`             | Often requires visiting pages individually |
| Structured output               | Product records with predefined fields    | May require manual formatting              |
| Product metadata collection     | Automated extraction from supported pages | Manual copy and paste                      |
| Search-page product discovery   | Supported for Alibaba search URLs         | Often requires manual link collection      |
| Image URL collection            | Included when available                   | Requires separate manual collection        |
| Collection timestamp            | Included as `scrapedAt`                   | Usually must be recorded separately        |
| Large-scale dataset preparation | Designed around dataset output            | More repetitive manual effort              |

This comparison describes workflow differences rather than guaranteeing that one approach is suitable for every research requirement.

### Competitive Advantages

The main practical strengths of the Alibaba Product Details Scraper are its focused product-data schema and straightforward URL-based workflow.

Users can provide multiple Alibaba URLs, receive product records with common identity and commercial fields, and use the resulting dataset without manually designing a separate output structure.

The Actor also combines direct product-page processing with search-page product discovery, making it useful for workflows where some URLs are already known while others need to be discovered from Alibaba search pages.

### Best Practices

Use valid Alibaba URLs and begin with a small test set so you can verify the returned structure.

For direct product extraction, provide the actual product-detail URLs you want to analyze. When using search URLs, review the resulting dataset to confirm that the discovered products match your research objective.

Important fields such as price, availability, brand, SKU, and MPN should be validated before using them for decisions that require current or complete commercial information.

Also account for empty optional fields. Their absence does not necessarily indicate that the product itself lacks that information; it may simply mean that the information was not available in the metadata processed by the Actor.

### Troubleshooting

#### Invalid Input

Check that `startUrls` is an array and that each entry contains a valid URL object with a `url` value.

#### Empty Results

Confirm that the supplied URL is an accessible Alibaba product or search page and that the URL is correctly formatted. For search URLs, verify that the page contains product-detail links that can be discovered.

#### Partial Results

A run can contain fewer results than the number of submitted URLs when some pages cannot be successfully processed or do not yield valid product data.

#### Missing Fields

Review the source product page. Fields such as SKU, MPN, brand, price-validity information, or other metadata can be unavailable on some pages.

#### Temporary Processing Failure

Retry the Actor with the same or a smaller set of inputs and inspect the resulting dataset. Starting with a small sample can make it easier to identify URL-specific issues.

### Frequently Asked Questions

#### What does the Alibaba Product Details Scraper do?

The Alibaba Product Details Scraper collects structured product information from supported Alibaba product and search URLs and writes successful results to an Apify dataset.

#### What input does the Alibaba Product Details Scraper accept?

The user-configurable input is `startUrls`, an array containing one or more Alibaba URL entries.

#### Can I process multiple Alibaba product URLs?

Yes. `startUrls` is an array, so multiple URL entries can be supplied in a single run.

#### Can the Alibaba Product Details Scraper process search URLs?

Yes. The current Actor behavior distinguishes direct product URLs from other Alibaba URLs and can process Alibaba search pages to discover product-detail links.

#### What product data is returned?

The output can include the source URL, product ID, name, description, SKU, MPN, brand, images, offer count, availability, currency, price, price-validity information, and collection timestamp.

#### Does every result contain all fields?

No. Some source pages may not expose every optional product attribute. In those cases, fields can be empty or retain the Actor's documented default value.

#### Where are the results stored?

Successful product records are pushed to the Actor's Apify dataset.

#### What happens when a product page cannot be processed?

The page may fail to produce a normal dataset record. Only valid results collected by the Actor are pushed to the dataset.

#### How should I start with this Alibaba product scraper?

Begin with one or a few Alibaba URLs, run a small test, and verify the returned fields before using a larger set of inputs.

#### Can I use the results for research and automation?

Yes. The structured dataset is suitable for product research, catalog analysis, market research, sourcing workflows, and other automation tasks that use the returned product metadata.

### NLP Keywords

- Alibaba product scraper
- Alibaba product details
- Alibaba product data extraction
- Alibaba product information
- Alibaba product metadata
- Alibaba product research
- Alibaba product dataset
- Alibaba product details scraper
- Alibaba product extractor
- Alibaba product page scraper
- Alibaba product data scraper
- Alibaba catalog data
- Alibaba product price
- Alibaba product availability
- Alibaba product images
- Alibaba SKU extraction
- Alibaba MPN extraction
- Alibaba brand data
- Alibaba product URL scraper
- structured Alibaba product data

### Related Keywords

- Alibaba product scraper tool
- scrape Alibaba product pages
- Alibaba product information scraper
- Alibaba product metadata extractor
- extract Alibaba product details
- Alibaba product data collection
- Alibaba product page data
- Alibaba product catalog scraper
- Alibaba product research tool
- Alibaba product URL extractor
- Alibaba search product scraper
- Alibaba product price scraper
- Alibaba product image extractor
- Alibaba SKU scraper
- Alibaba brand scraper
- Alibaba MPN scraper
- Alibaba product dataset generator
- Alibaba product market research
- Alibaba structured data extraction
- Alibaba product listing scraper

### Final Overview

The Alibaba Product Details Scraper provides a focused way to turn supported Alibaba URLs into structured product records. It supports multiple `startUrls`, direct product pages, and Alibaba search URLs, while returning useful product identity, descriptive, image, offer, pricing, and collection metadata when that information is available.

For product research, catalog analysis, sourcing workflows, and structured dataset creation, the Actor provides a clear **URL → product data → dataset** workflow that reduces repetitive manual collection while keeping the resulting information organized for further analysis.

Contact me: <Alphascraper69@gmail.com>

# Actor input Schema

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

List of one or more Alibaba search urls (e.g. https://www.alibaba.com/...).

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.alibaba.com/product-detail/Purses-Handbags-Set-Fashion-Handbags-Bags_1601698369199.html?spm=a2700.galleryofferlist.normal_offer.d_image.781413a0s9iQCn"
    },
    {
      "url": "https://www.alibaba.com/product-detail/Real-High-Quality-S24-Ultra-2025_1601536239140.html?spm=a2700.prosearch.normal_offer.d_image.75ac67afILeCHN&priceId=dca5c740bef74891be6cf8ea5e7d405b"
    }
  ]
}
```

# Actor output Schema

## `dataset` (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.alibaba.com/product-detail/Purses-Handbags-Set-Fashion-Handbags-Bags_1601698369199.html?spm=a2700.galleryofferlist.normal_offer.d_image.781413a0s9iQCn"
        },
        {
            "url": "https://www.alibaba.com/product-detail/Real-High-Quality-S24-Ultra-2025_1601536239140.html?spm=a2700.prosearch.normal_offer.d_image.75ac67afILeCHN&priceId=dca5c740bef74891be6cf8ea5e7d405b"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("alpha-scraper/alibaba-product-details-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.alibaba.com/product-detail/Purses-Handbags-Set-Fashion-Handbags-Bags_1601698369199.html?spm=a2700.galleryofferlist.normal_offer.d_image.781413a0s9iQCn" },
        { "url": "https://www.alibaba.com/product-detail/Real-High-Quality-S24-Ultra-2025_1601536239140.html?spm=a2700.prosearch.normal_offer.d_image.75ac67afILeCHN&priceId=dca5c740bef74891be6cf8ea5e7d405b" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("alpha-scraper/alibaba-product-details-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 '{
  "startUrls": [
    {
      "url": "https://www.alibaba.com/product-detail/Purses-Handbags-Set-Fashion-Handbags-Bags_1601698369199.html?spm=a2700.galleryofferlist.normal_offer.d_image.781413a0s9iQCn"
    },
    {
      "url": "https://www.alibaba.com/product-detail/Real-High-Quality-S24-Ultra-2025_1601536239140.html?spm=a2700.prosearch.normal_offer.d_image.75ac67afILeCHN&priceId=dca5c740bef74891be6cf8ea5e7d405b"
    }
  ]
}' |
apify call alpha-scraper/alibaba-product-details-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alpha-scraper/alibaba-product-details-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/JVoPehPmOh0YFyjYo/builds/uq4pUcEgRBtHblSDj/openapi.json