# Alibaba Product & Supplier Finder (Reverse Image Search) (`toolsnmoreapi/alibaba-product-and-vender-finder`) Actor

Find real Alibaba suppliers behind any product using text or image search. Extract supplier data, pricing, MOQ, and product links at scale.

- **URL**: https://apify.com/toolsnmoreapi/alibaba-product-and-vender-finder.md
- **Developed by:** [ToolsAPI](https://apify.com/toolsnmoreapi) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 3 total users, 2 monthly users, 68.4% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Alibaba Supplier Finder | Reverse Image Search & Product Supplier Scraper

Find Alibaba suppliers faster using **keywords**, **uploaded product images**, or **image + text search**.

This actor helps ecommerce sellers, Amazon sellers, dropshippers, product researchers, importers, and sourcing teams discover suppliers behind products. Upload product photos, search product keywords, or combine images with matching descriptions to find Alibaba listings, supplier names, profile URLs, prices, MOQ, and supplier details.

---

### What can you use this for?

Use this actor when you want to:

- Find Alibaba suppliers for products you want to resell
- Reverse search product images from Amazon, TikTok Shop, Shopify stores, Instagram, Pinterest, or competitor websites
- Compare multiple Alibaba suppliers for the same product
- Build a sourcing list for trending products
- Find similar products from uploaded images
- Extract supplier profile URLs, prices, MOQ, location, and years in business
- Save results to CSV for research, outreach, or purchasing

---

### Popular product examples

You can search for common resale and sourcing products such as:

- Portable blender
- LED light strips
- Pet grooming brush
- Magnetic phone holder
- Mini projector
- Car vacuum cleaner
- Makeup organizer
- Travel toiletry bag
- Dog water bottle
nizer
- Air fryer accessories
- Desk lamp

---

### How it works

Choose one search mode:

| Mode | Best for | What you provide |
|---|---|---|
| Text search | Searching by product keyword | One or more product keywords |
| Image search | Finding visually similar Alibaba listings | Up to 20 product images or image URLs |
| Image + text search | Most accurate product matching | Product images plus matching text descriptions |

---

### Quick start

#### Option 1: Search by product keyword

Use **Text search** if you already know what product you want to source.

Example input:

```json
{
  "searchMode": "text",
  "searchTerms": [
    "portable blender",
    "pet grooming brush",
    "mini projector"
  ],
  "csvOutputMode": "both"
}
````

This searches Alibaba for each keyword and returns suppliers for each product.

***

#### Option 2: Search by product image

Use **Image search** if you have product photos or screenshots.

Example input:

```json
{
  "searchMode": "image",
  "uploadedImages": [
    "upload product images in the Apify input form"
  ],
  "csvOutputMode": "both"
}
```

You can upload up to **20 images** per run.

Each image is searched separately.

Example:

```text
portable-blender.jpg -> Alibaba reverse image search
pet-brush.jpg -> Alibaba reverse image search
phone-holder.jpg -> Alibaba reverse image search
```

***

#### Option 3: Search by image + text

Use **Image + text search** for the most accurate results.

This is best when an image alone is too broad or when you want to guide Alibaba with a product description.

Example input:

```json
{
  "searchMode": "image_text",
  "uploadedImages": [
    "upload product images in the Apify input form"
  ],
  "imageTextTerms": [
    "portable blender USB rechargeable",
    "pet grooming brush self cleaning",
    "magnetic phone car holder"
  ],
  "csvOutputMode": "both"
}
```

The actor pairs images and text by order:

```text
Image 1 -> portable blender USB rechargeable
Image 2 -> pet grooming brush self cleaning
Image 3 -> magnetic phone car holder
```

It does **not** mix every image with every text term.

***

### Input fields explained

#### Search mode

Choose how you want to search Alibaba.

| Value | Meaning |
|---|---|
| `text` | Search Alibaba by keywords |
| `image` | Upload images or use image URLs |
| `image_text` | Upload images and add matching text for each image |

***

#### Text search terms

Use this for **Text search**.

Add one product keyword per line.

Good examples:

```text
portable blender
LED light strips
pet grooming brush
mini projector
magnetic phone holder
makeup organizer
travel toiletry bag
```

Avoid vague terms like:

```text
hot product
good item
cheap thing
same as picture
```

***

#### Upload product images

Use this for **Image search** or **Image + text search**.

Upload up to **20 product images**.

Best image types:

- Clear product photos
- Product images with plain backgrounds
- Competitor product images
- Product screenshots cropped around the item
- Multiple angles of the same product

Avoid:

- Blurry images
- Collages with many products
- Images with large text overlays
- Screenshots where the product is very small
- Lifestyle images where the product is hard to identify

***

#### Image URLs

Optional alternative to uploading images.

Use this when your product images are already online.

Example:

```json
{
  "searchMode": "image",
  "imageUrls": [
    "https://example.com/portable-blender.jpg",
    "https://example.com/pet-grooming-brush.jpg"
  ]
}
```

***

#### Text for each uploaded image

Use this for **Image + text search**.

Add one text description per uploaded image.

The order matters.

Example:

```text
Image 1: portable blender USB rechargeable
Image 2: pet grooming brush self cleaning
Image 3: magnetic phone car holder
```

Good descriptions are short and product-specific.

Good examples:

```text
portable blender USB rechargeable
pet grooming brush self cleaning
mini projector 1080p WiFi
magnetic phone car holder
makeup organizer acrylic
travel toiletry bag hanging
car vacuum cleaner cordless
insulated tumbler stainless steel
```

Bad examples:

```text
same as image
product
good quality item
Amazon product
viral product
very cheap popular trending ecommerce product for dropshipping
```

***

#### CSV output mode

Choose how CSV files are saved.

| Option | What it does |
|---|---|
| Combined CSV | Saves one CSV with all results |
| Separate CSV per search | Saves one CSV per keyword, image, or image + text pair |
| Both | Saves one combined CSV and separate CSV files |

Recommended setting:

```json
{
  "csvOutputMode": "both"
}
```

This is useful when you upload multiple images or enter multiple keywords because each search can have its own output file.

***

### Output fields

Each result can include:

| Field | Description |
|---|---|
| `search_input` | Keyword, image name, or image + text used for the search |
| `vendor_name` | Alibaba supplier name |
| `vendor_profile_url` | Supplier profile URL |
| `name` | Product listing title |
| `product_url` | Alibaba product listing URL |
| `price` | Displayed price range |
| `min_order` | Minimum order quantity |
| `supplier_from` | Supplier location |
| `years_in_business` | Years active on Alibaba |

***

### Example output

```json
{
  "search_input": "portable blender USB rechargeable",
  "vendor_name": "Shenzhen Example Home Appliance Co., Ltd.",
  "vendor_profile_url": "https://example.en.alibaba.com/",
  "name": "Portable USB Rechargeable Blender for Smoothies",
  "product_url": "https://www.alibaba.com/product-detail/...",
  "price": "$3.80 - $6.50",
  "min_order": "100 Pieces",
  "supplier_from": "China",
  "years_in_business": "6 YRS"
}
```

***

### Recommended workflows

#### Find suppliers for trending products

Use text search with multiple product ideas.

```json
{
  "searchMode": "text",
  "searchTerms": [
    "portable blender",
    "LED light strips",
    "pet grooming brush",
    "mini projector"
  ],
  "csvOutputMode": "both"
}
```

Best for:

- Product research
- Trend validation
- Finding multiple supplier options

***

#### Find suppliers from competitor product photos

Use image search.

```json
{
  "searchMode": "image",
  "uploadedImages": [
    "upload competitor product images in the Apify form"
  ],
  "csvOutputMode": "both"
}
```

Best for:

- Amazon competitor research
- TikTok Shop product research
- Shopify product research
- Finding visually similar Alibaba listings

***

#### Find more accurate suppliers with image + text

Use image + text search.

```json
{
  "searchMode": "image_text",
  "uploadedImages": [
    "upload product images in the Apify form"
  ],
  "imageTextTerms": [
    "portable blender USB rechargeable",
    "pet grooming brush self cleaning",
    "magnetic phone car holder"
  ],
  "csvOutputMode": "both"
}
```

Best for:

- Reducing irrelevant image search results
- Matching specific product types
- Searching multiple product photos with different descriptions

***

#### Search using image URLs

Use image URLs if your images are already hosted online.

```json
{
  "searchMode": "image",
  "imageUrls": [
    "https://example.com/product-1.jpg",
    "https://example.com/product-2.jpg"
  ],
  "csvOutputMode": "both"
}
```

***

#### Advanced API input with image/text pairs

Use `imageTextPairs` if you are calling the actor through the API and want each image source and text term inside one object.

```json
{
  "searchMode": "image_text",
  "imageTextPairs": [
    {
      "imageUrl": "https://example.com/portable-blender.jpg",
      "textTerm": "portable blender USB rechargeable"
    },
    {
      "imageUrl": "https://example.com/pet-brush.jpg",
      "textTerm": "pet grooming brush self cleaning"
    }
  ],
  "csvOutputMode": "both"
}
```

Each item must include exactly one image source:

- `imageUrl`
- `imageKey`
- `imagePath`

and one:

- `textTerm`

***

### Best practices

#### For text search

Use specific product keywords.

Better:

```text
portable blender USB rechargeable
mini projector 1080p WiFi
pet grooming brush self cleaning
```

Worse:

```text
blender
projector
pet product
```

***

#### For image search

Use clear product images.

Better:

- Product centered in the image
- Minimal background
- One product per image
- High resolution
- Cropped screenshot focused on the product

Worse:

- Multiple products in one image
- Heavy text overlays
- Blurry screenshots
- Lifestyle photos where the product is small

***

#### For image + text search

Keep the text short and descriptive.

Better:

```text
magnetic phone car holder
travel toiletry bag hanging
makeup organizer acrylic
```

Worse:

```text
this item from Amazon
viral TikTok product
same as uploaded picture
```

***

### Limits

- Up to 20 uploaded images per run
- Up to 20 image URLs per run
- Up to 20 image + text pairs per run
- Results depend on Alibaba’s current website layout and listing availability
- Some listings may not show supplier information directly

***

### Troubleshooting

#### I uploaded images but got no results

Try:

- using a clearer product image
- cropping the image around the product
- using image + text search
- testing with one image first
- enabling Apify Proxy if requests are blocked
- using an image URL instead of a file upload

***

#### My image + text results look wrong

Check that your text terms are in the same order as your images.

Correct:

```text
Image 1 -> text 1
Image 2 -> text 2
Image 3 -> text 3
```

Incorrect:

```text
Image 1 -> all text terms
Image 2 -> all text terms
```

***

#### I entered multiple text searches but only see one CSV

Set CSV output mode to:

```text
Both combined and separate CSV files
```

or:

```text
Separate CSV file for each search
```

The Apify dataset is always combined, but CSV output files can be split by keyword, image, or image + text pair.

***

#### The input form still looks old

Try:

1. Rebuild the actor
2. Hard refresh the browser
3. Make sure `.actor/actor.json` points to the schema file you edited
4. Check that you updated the active `input_schema.json`

***

#### Alibaba blocks the run

Try enabling Apify Proxy or running fewer pages per search.

***

### CSV output examples

If you choose **Combined CSV**, you get:

```text
alibaba_results.csv
```

If you choose **Separate CSV per search**, you may get:

```text
portable_blender.csv
pet_grooming_brush.csv
mini_projector.csv
```

If you choose **Both**, you get:

```text
alibaba_results.csv
portable_blender.csv
pet_grooming_brush.csv
mini_projector.csv
```

For image search, separate files are named after the uploaded image:

```text
portable-blender.jpg.csv
pet-brush.jpg.csv
phone-holder.jpg.csv
```

***

### Who is this for?

This actor is useful for:

- Amazon sellers
- TikTok Shop sellers
- Shopify store owners
- Dropshippers
- Ecommerce product researchers
- Importers
- Sourcing agents
- Procurement teams
- Private label brands
- Product development teams

***

### Summary

Alibaba Supplier Finder helps you turn product ideas, product photos, and competitor images into supplier research.

Use it to:

- search Alibaba faster
- find supplier profile URLs
- compare product pricing and MOQ
- organize results by keyword or uploaded image
- build sourcing lists for ecommerce products

***

### Disclaimer

Use this actor responsibly and in compliance with Alibaba’s terms of service and all applicable laws.

# Actor input Schema

## `searchMode` (type: `string`):

Choose how you want to search Alibaba. Text search uses keywords only. Image search uses uploaded product images.

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

Use this section only when Search mode is Text search. Add one product keyword per line. Good examples: portable blender, LED light strips, pet grooming brush, mini projector, magnetic phone holder, makeup organizer.

## `uploadedImages` (type: `array`):

Use this section when Search mode is Image search. Upload up to 20 product images. Each image is searched separately. For best results, use clear product photos instead of screenshots with lots of background text.

## `imageUrls` (type: `array`):

Optional alternative to uploading files. Paste public image URLs, one per line. Use this when your product photos are already online. You can add up to 20 URLs.

## `csvOutputMode` (type: `string`):

Choose how CSV files should be saved. Combined creates one CSV for all results. Separate creates one CSV per keyword or image search. Both saves one combined file plus separate files.

## `cookies` (type: `array`):

Optional. Paste Alibaba browser cookies as JSON only if you know you need them. Most users should leave this empty.

## `searchImageKeys` (type: `array`):

Advanced hidden field. Key-value store keys for uploaded binary image files. Normal users should use Upload product images instead.

## `searchImages` (type: `array`):

Advanced hidden field. Local file paths available inside the actor runtime.

## `maxUniqueSuppliers` (type: `integer`):

Maximum unique suppliers returned per keyword or per image.

## `maxPagesText` (type: `integer`):

Maximum Alibaba result pages to scrape per keyword in Text search mode.

## `maxPagesImage` (type: `integer`):

Maximum Alibaba result pages to scrape per image.

## `useApifyProxy` (type: `boolean`):

Enable if Alibaba starts blocking requests.

## `headless` (type: `boolean`):

Run Chrome without a visible browser window. Keep enabled for normal Apify runs.

## `blockImages` (type: `boolean`):

Speeds up result scraping after Alibaba search results load. This does not block your uploaded search image.

## `saveCsvFile` (type: `boolean`):

Save CSV files in the key-value store in addition to pushing results to the default dataset.

## `csvFilename` (type: `string`):

Name of the combined CSV file saved by the actor.

## `userAgent` (type: `string`):

Optional custom browser user agent.

## Actor input object example

```json
{
  "searchMode": "text",
  "csvOutputMode": "combined",
  "cookies": [],
  "searchImageKeys": [],
  "searchImages": [],
  "maxUniqueSuppliers": 10,
  "maxPagesText": 3,
  "maxPagesImage": 3,
  "useApifyProxy": false,
  "headless": true,
  "blockImages": false,
  "saveCsvFile": true,
  "csvFilename": "alibaba_results.csv",
  "userAgent": ""
}
```

# Actor output Schema

## `name` (type: `string`):

Main product summary with vendor, pricing, MOQ, and links.

## `product_url` (type: `string`):

Direct product page link.

## `vendor_profile_url` (type: `string`):

Direct vendor profile link.

## `price` (type: `string`):

Displayed product price.

## `min_order` (type: `string`):

Displayed minimum order quantity.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("toolsnmoreapi/alibaba-product-and-vender-finder").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("toolsnmoreapi/alibaba-product-and-vender-finder").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 '{}' |
apify call toolsnmoreapi/alibaba-product-and-vender-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=toolsnmoreapi/alibaba-product-and-vender-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Alibaba Product & Supplier Finder (Reverse Image Search)",
        "description": "Find real Alibaba suppliers behind any product using text or image search. Extract supplier data, pricing, MOQ, and product links at scale.",
        "version": "0.0",
        "x-build-id": "Xheyx2IPTL8LDVuuI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/toolsnmoreapi~alibaba-product-and-vender-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-toolsnmoreapi-alibaba-product-and-vender-finder",
                "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/toolsnmoreapi~alibaba-product-and-vender-finder/runs": {
            "post": {
                "operationId": "runs-sync-toolsnmoreapi-alibaba-product-and-vender-finder",
                "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/toolsnmoreapi~alibaba-product-and-vender-finder/run-sync": {
            "post": {
                "operationId": "run-sync-toolsnmoreapi-alibaba-product-and-vender-finder",
                "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": [
                    "searchMode"
                ],
                "properties": {
                    "searchMode": {
                        "title": "Search mode",
                        "enum": [
                            "text",
                            "image"
                        ],
                        "type": "string",
                        "description": "Choose how you want to search Alibaba. Text search uses keywords only. Image search uses uploaded product images.",
                        "default": "text"
                    },
                    "searchTerms": {
                        "title": "Keywords to search",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Use this section only when Search mode is Text search. Add one product keyword per line. Good examples: portable blender, LED light strips, pet grooming brush, mini projector, magnetic phone holder, makeup organizer.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "uploadedImages": {
                        "title": "Upload product images",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Use this section when Search mode is Image search. Upload up to 20 product images. Each image is searched separately. For best results, use clear product photos instead of screenshots with lots of background text."
                    },
                    "imageUrls": {
                        "title": "Or paste image URLs",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Optional alternative to uploading files. Paste public image URLs, one per line. Use this when your product photos are already online. You can add up to 20 URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "csvOutputMode": {
                        "title": "CSV output mode",
                        "enum": [
                            "combined",
                            "separate",
                            "both"
                        ],
                        "type": "string",
                        "description": "Choose how CSV files should be saved. Combined creates one CSV for all results. Separate creates one CSV per keyword or image search. Both saves one combined file plus separate files.",
                        "default": "combined"
                    },
                    "cookies": {
                        "title": "Alibaba cookies",
                        "type": "array",
                        "description": "Optional. Paste Alibaba browser cookies as JSON only if you know you need them. Most users should leave this empty.",
                        "default": []
                    },
                    "maxUniqueSuppliers": {
                        "title": "Suppliers to return per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum unique suppliers returned per keyword or per image.",
                        "default": 10
                    },
                    "maxPagesText": {
                        "title": "Text result pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum Alibaba result pages to scrape per keyword in Text search mode.",
                        "default": 3
                    },
                    "maxPagesImage": {
                        "title": "Image result pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum Alibaba result pages to scrape per image.",
                        "default": 3
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Enable if Alibaba starts blocking requests.",
                        "default": false
                    },
                    "headless": {
                        "title": "Headless browser",
                        "type": "boolean",
                        "description": "Run Chrome without a visible browser window. Keep enabled for normal Apify runs.",
                        "default": true
                    },
                    "blockImages": {
                        "title": "Block page images",
                        "type": "boolean",
                        "description": "Speeds up result scraping after Alibaba search results load. This does not block your uploaded search image.",
                        "default": false
                    },
                    "saveCsvFile": {
                        "title": "Save CSV output",
                        "type": "boolean",
                        "description": "Save CSV files in the key-value store in addition to pushing results to the default dataset.",
                        "default": true
                    },
                    "csvFilename": {
                        "title": "Combined CSV filename",
                        "type": "string",
                        "description": "Name of the combined CSV file saved by the actor.",
                        "default": "alibaba_results.csv"
                    },
                    "userAgent": {
                        "title": "Custom user agent",
                        "type": "string",
                        "description": "Optional custom browser user agent.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
