# Alibaba RFQ Scraper (`codingfrontend/alibaba-rfq-scraper`) Actor

Extracts public Alibaba sourcing RFQ metadata with direct HTTP, robots-aware fail-closed access, and no buyer contact or quote-submission fields.

- **URL**: https://apify.com/codingfrontend/alibaba-rfq-scraper.md
- **Developed by:** [Coding Frontned](https://apify.com/codingfrontend) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 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.

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

### What does Alibaba RFQ Scraper do?

Alibaba RFQ Scraper searches public buying requests (RFQs) on [Alibaba Sourcing](https://sourcing.alibaba.com/rfq/rfqSearchList.htm) and saves one dataset row for each validated request. It supports optional keyword and country query values, bounded list-page collection, and optional enrichment from public RFQ detail pages.

The Actor makes ordinary public HTTP requests and follows Alibaba's `robots.txt` rules. It does not sign in, submit quotations, use private APIs, or collect buyer contact details. A blocked or empty run produces no fabricated RFQ rows.

Alibaba's current access rules can allow the default list while disallowing keyword searches, country searches, later pages, or details. In that situation, use the available list results; changing limits does not make a disallowed page accessible.

### Why use Alibaba RFQ Scraper?

Use the Actor to review public product demand, compare buyer requirements, monitor RFQ listings, or collect a bounded research sample. Apify can schedule runs and provide dataset downloads, API access, run history, and integrations with other services.

Set `maxItems` and `maxPages` to bound a run. Enable details when you need the full public description, category, posting date, remaining time, specification labels, or visible PDF links that Alibaba exposes on detail pages. A requested detail page can still be unavailable or disallowed; the Actor retains the list record and marks the run partial when an attempted page cannot be collected usefully.

### What data can Alibaba RFQ Scraper extract?

Each row contains a public Alibaba RFQ business record. Alibaba may omit any optional value. The full JSON example is illustrative and does not represent a verified live result.

```json
{
  "rfqId": "1234567890",
  "subject": "Bulk reusable stainless steel water bottles",
  "description": "Please quote for 5,000 reusable bottles.\nMaterial: Stainless steel\nCapacity: 750 ml",
  "category": {
    "id": "12345",
    "name": "Home & Garden"
  },
  "postedAt": "2026-09-30",
  "timeRemaining": "5 days",
  "specifications": {
    "Material": [
      "Stainless steel"
    ],
    "Capacity": [
      "750 ml"
    ]
  },
  "buyer": {
    "country": "Canada",
    "countryCode": "CA"
  },
  "quantity": {
    "value": "5000",
    "unit": "pieces"
  },
  "opened": {
    "relative": "2 days ago"
  },
  "quotes": {
    "extraCount": 8,
    "leftCount": 12,
    "rfqExtraCount": 3,
    "rfqLeftCount": 9,
    "discountCost": 5,
    "originalCost": 10
  },
  "quality": {
    "starLevel": 4,
    "starMax": 5,
    "rfqLevel": "industrySelected"
  },
  "imageUrl": "https://sc04.alicdn.com/kf/illustrative-rfq-image.jpg",
  "tags": [
    "Experienced buyer",
    "Typically replies"
  ],
  "hasAnnexes": true,
  "detailUrl": "https://sourcing.alibaba.com/rfq_detail.htm?p=illustrative-only",
  "annexes": [
    {
      "url": "https://www.alibaba.com/rfq/attachments/illustrative-specification.pdf",
      "name": "Product specification"
    }
  ]
}
```

| Field | Type | Required? | Meaning |
| --- | --- | --- | --- |
| `rfqId` | Text | Required | Alibaba identifier for the buying request. |
| `subject` | Text | Required | RFQ title shown on the list or detail page. |
| `description` | Text | Optional | Full public request text when available. Newlines are preserved; a detail page may provide more text than the list page. |
| `category` | Object | Optional | Public `id` and `name` for the RFQ category, when exposed. Both nested values are text. |
| `postedAt` | Text (date) | Optional | Public RFQ posting date in ISO date form when available. |
| `timeRemaining` | Text | Optional | Remaining time text shown on the public RFQ. |
| `specifications` | Object | Optional | Source specification labels mapped to arrays of text values. Labels are kept as keys and repeated values are retained. |
| `buyer` | Object | Optional | Public location fields: `country` (text) and, when exposed, `countryCode` (text). Contact fields are not collected. |
| `quantity` | Object | Optional | `value` (text or number) and `unit` (text). Either nested value may be absent. |
| `opened` | Object | Optional | Public `relative` opening-time text when shown. |
| `quotes` | Object | Optional | Numeric public counts `extraCount`, `leftCount`, `rfqExtraCount`, and `rfqLeftCount`, plus numeric `discountCost` and `originalCost` values when shown. |
| `quality` | Object | Optional | Numeric `starLevel` and `starMax`, and the public `rfqLevel` badge code when shown. |
| `imageUrl` | URL text | Optional | Public RFQ image link. |
| `tags` | Array of text | Optional | Public RFQ labels exposed by Alibaba. |
| `hasAnnexes` | Boolean | Optional | Whether the public page indicates that the RFQ has annexes. This does not mean a downloadable public PDF is available. |
| `detailUrl` | URL text | Optional | Public Alibaba detail page for the RFQ. |
| `annexes` | Array of objects | Optional | Visible public PDF links found on a fetched detail page. Each object has a required `url` (URL text) and an optional visible `name` (text). |

Only `rfqId` and `subject` are required for a dataset row. Optional fields that Alibaba does not expose are omitted. The example includes every public field and nested field documented above. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### How to scrape Alibaba RFQs

1. Open the Actor's **Input** tab.
2. Enter a keyword or country, or paste an eligible Alibaba RFQ list URL. Choose your item and page limits.
3. Turn on **Fetch RFQ details** only when you need public detail-page information and visible PDF links.
4. Click **Start**. When the run finishes, open **Dataset** to view or download the RFQ rows. Open **Output summary** to see the run status and acknowledged row count.

### How much will it cost to scrape Alibaba RFQs?

The Actor does not set a fixed price. Apify charges depend on your account plan and the compute and storage used by each run. More requested pages and items increase public page requests; detail enrichment can add a request for each RFQ that has a usable detail link. The per-request timeout also affects how long a slow response can hold compute. Keep the limits low while exploring and check the run's usage details in Apify Console.

### Input

All eight input fields are optional; unknown fields are rejected. Defaults below apply when a value is omitted. Text fields accept Unicode text with the stated character limits and reject blank, non-string, or control-character values.

#### Search settings

| Field | Type | Required? | Default | Description |
| --- | --- | --- | --- | --- |
| `keyword` | Text | Optional | None | Adds a product or buying-request keyword to the search. Maximum 200 Unicode characters. |
| `country` | Text | Optional | None | Filters by buyer country. A two-letter code such as `US` is sent to Alibaba's country filter and checked against each candidate's public country fields; a full country name is matched locally against visible buyer-country text. Maximum 100 Unicode characters. |
| `searchUrl` | URL text | Optional | Alibaba's public RFQ list URL | Starts from an HTTPS RFQ list page on `sourcing.alibaba.com`. Accepted paths are `/rfq/rfqSearchList.htm`, `/rfq/rfq_search_list.htm`, and `/rfq_search_list.htm`. Credentials, ports, fragments, raw whitespace, control characters, and malformed percent-encoding are rejected. Supported query fields are `SearchText` or `searchText`, `country`, `page`, `fsb`, `IndexArea`, `categoryIds`, and `tracelog`; duplicates and aliases are rejected. Maximum 2,000 characters. |

When `searchUrl` is supplied, a provided `keyword` replaces the `SearchText` or `searchText` value; a provided `country` replaces the `country` value. Other supported URL fields remain available. The Actor follows the website's visible next-page links. If `searchUrl` is omitted, it starts at Alibaba's public RFQ list page.

#### Limits

| Field | Type | Required? | Default | Description |
| --- | --- | --- | --- | --- |
| `maxItems` | Integer | Optional | `20` | Maximum unique RFQ rows to save across the run. Minimum `1`, maximum `200`. RFQs are deduplicated by Alibaba RFQ ID, keeping the first occurrence. |
| `maxPages` | Integer | Optional | `1` | Maximum number of public RFQ list pages requested. Minimum `1`, maximum `20`. |

Reaching `maxItems` is normal completion. Pages are processed in source order by following an observed next-page link, stopping when the item limit is reached or `maxPages` is reached. A two-letter country code is sent to Alibaba's public country filter and checked against each candidate's country fields; a full country name is matched locally against visible buyer-country text. Results cover only the pages this run collects.

#### Details

| Field | Type | Required? | Default | Description |
| --- | --- | --- | --- | --- |
| `includeDetails` | Boolean | Optional | `false` | Requests a public RFQ detail page when the list record exposes an eligible detail URL. |
| `includeAnnexes` | Boolean | Optional | `true` | Keeps visible public PDF links found on fetched detail pages. It has no effect when `includeDetails` is `false`. |

The Actor retains a list record if its optional detail request is unavailable. A failed or unhelpful detail request makes a run partial when at least one row was saved. Alibaba's indication that an RFQ has annexes does not guarantee a public PDF link.

#### Request timing

| Field | Type | Required? | Default | Description |
| --- | --- | --- | --- | --- |
| `timeoutSecs` | Integer | Optional | `30` seconds | Maximum wait for each public page request. Minimum `5`, maximum `120` seconds. |

#### Example inputs

Search by keyword with a small result limit:

```json
{
  "keyword": "stainless steel water bottle",
  "maxItems": 5
}
```

Filter for the United States and request more list pages. Alibaba's country filter accepts a two-letter code; use `US` for the United States:

```json
{
  "keyword": "reusable food containers",
  "country": "US",
  "maxItems": 30,
  "maxPages": 4
}
```

Start from an Alibaba RFQ list URL:

```json
{
  "searchUrl": "https://sourcing.alibaba.com/rfq_search_list.htm?searchText=packaging&fsb=y&IndexArea=rfq_en&categoryIds=",
  "maxItems": 15,
  "maxPages": 3
}
```

Keep list-page information only:

```json
{
  "keyword": "cotton tote bags",
  "maxItems": 10,
  "includeDetails": false,
  "includeAnnexes": false
}
```

### Output

The dataset contains one validated public RFQ business row per saved request. A run succeeds only after at least one dataset write is acknowledged. `OUTPUT_SUMMARY` is a separate key-value-store record with exactly three fields: `status`, `itemsStored`, and `isPartial`. `SUCCEEDED` means at least one RFQ row was saved; `FAILED` means none were saved. A later collection failure can leave a successful run marked partial.

| Summary field | Type | Meaning |
| --- | --- | --- |
| `status` | Text | `SUCCEEDED` after one or more acknowledged RFQ rows; otherwise `FAILED`. |
| `itemsStored` | Integer | Number of RFQ dataset writes acknowledged during the run. |
| `isPartial` | Boolean | `true` when collection or requested enrichment failed after at least one row was saved. |

Completed run:

```json
{
  "status": "SUCCEEDED",
  "itemsStored": 5,
  "isPartial": false
}
```

Some results saved before a later failure:

```json
{
  "status": "SUCCEEDED",
  "itemsStored": 3,
  "isPartial": true
}
```

No RFQ rows saved:

```json
{
  "status": "FAILED",
  "itemsStored": 0,
  "isPartial": false
}
```

### Tips and advanced options

- Begin with a small `maxItems` value and raise `maxPages` when you need a wider sample.
- Fetch details only when you need public detail-page information. Detail pages and query URLs can be disallowed by Alibaba's current `robots.txt` rules or blocked by the source; the Actor does not try to bypass those restrictions.
- Use a longer `timeoutSecs` only when public responses need more time. The setting applies to each public page request.
- An empty or blocked run has zero saved rows and a `FAILED` summary. Run logs can help distinguish access problems from a search that returned no supported RFQs.

### FAQ, support, and responsible use

#### Why did my run save no rows?

The query may have no supported public results, Alibaba may have blocked the request, or `robots.txt` may disallow the requested URL. Review the run log and `OUTPUT_SUMMARY`. The Actor reports a failed run when no real RFQ row was saved.

#### Where can I get help?

Use the Actor's **Issues** tab for bugs or feature requests. Include a run ID and a short description when possible. The **API** tab shows how to start runs programmatically.

#### Is this Actor affiliated with Alibaba?

No. This Actor is independent and is not affiliated with Alibaba. Use it in line with Alibaba's terms, its public access rules, applicable rate limits, and local law. It collects public business-request information and does not request buyer email addresses, phone numbers, account information, or quotation-submission data. Public records could still contain personal information; use the data only for a legitimate purpose and consult qualified counsel when needed.

# Actor input Schema

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

Optional product or buying-request keyword. Provide non-blank Unicode text of up to 200 characters; control characters are rejected.

## `country` (type: `string`):

Optional buyer-country filter. A two-letter country code is sent to Alibaba's public country filter and checked against each candidate's country fields; a full country name is matched locally against visible buyer-country text. Provide non-blank Unicode text of up to 100 characters; control characters are rejected.

## `searchUrl` (type: `string`):

Optional HTTPS URL for an Alibaba public RFQ list page on sourcing.alibaba.com. Accepted paths are /rfq/rfqSearchList.htm, /rfq/rfq_search_list.htm, and /rfq_search_list.htm. Credentials, ports, fragments, raw whitespace, control characters, malformed percent-encoding, and query fields other than SearchText, searchText, country, page, fsb, IndexArea, categoryIds, or tracelog are rejected. If omitted, the Actor starts at Alibaba's public RFQ list page.

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

Maximum number of unique RFQ records to save across the selected pages.

## `maxPages` (type: `integer`):

Maximum number of public RFQ list pages to request.

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

Also request public RFQ detail pages when the list provides a valid detail URL.

## `includeAnnexes` (type: `boolean`):

Keep visible public PDF links found on fetched detail pages. This has an effect only when Fetch RFQ details is enabled.

## `timeoutSecs` (type: `integer`):

Maximum wait for each public page request.

## Actor input object example

```json
{
  "maxItems": 20,
  "maxPages": 1,
  "includeDetails": false,
  "includeAnnexes": true,
  "timeoutSecs": 30
}
```

# Actor output Schema

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

Public Alibaba RFQ business records saved to the default dataset.

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

Run status and the count of acknowledged RFQ records in the default key-value store.

# 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("codingfrontend/alibaba-rfq-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 = {}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,codingfrontend/alibaba-rfq-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/41cMYQNBJ5YDHuSZn/builds/5jQvfaDVegf6CRnrt/openapi.json