# Alibaba Listings Scraper (`scrapers-hub/alibaba-listings-scraper`) Actor

Alibaba Listings Scraper extracts B2B wholesale listings at scale - title, price, promotion price, discount, MOQ, supplier company, country, review score and Gold Supplier years. 🏭 Ideal for sourcing research, pricing analysis and supplier vetting.

- **URL**: https://apify.com/scrapers-hub/alibaba-listings-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** E-commerce, Developer tools, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Listings Scraper – Extract B2B Product, Price & Supplier Data

The **Alibaba Listings Scraper** turns any Alibaba.com search keyword into a clean, structured dataset of B2B product listings, wholesale price bands, minimum order quantities and supplier details. Instead of scrolling through page after page of the Alibaba search results and copying figures into a spreadsheet, you give the Alibaba scraper a keyword and a result limit, and it returns a dataset you can sort, filter, join and feed straight into your sourcing or pricing models.

This Alibaba listings scraper is built for people who actually source products: importers comparing MOQ and FOB price bands across suppliers, private-label sellers validating unit economics before committing to a purchase order, marketplace analysts tracking wholesale pricing, and procurement teams building supplier shortlists by country and Gold Supplier tenure. Every field it returns comes straight from the public Alibaba search results page — no logins, no cookies, no manual copy-paste.

***

### 📊 What Data Can You Extract with This Alibaba Scraper?

The Alibaba scraper returns one record per product listing found for your search keyword. The fields group naturally into six categories:

| Category | Fields | What it tells you |
|---|---|---|
| 🏷️ Product identity | `title`, `productUrl`, `mainImage` | The listing headline, the canonical Alibaba product-detail URL, and the primary product thumbnail hosted on Alibaba's CDN |
| 💰 Pricing | `price`, `promotionPrice`, `discount` | The listed price or price band as shown on the search page, any promotional price, and the discount value where Alibaba advertises one |
| 📦 Order terms | `moq` | The minimum order quantity string exactly as the supplier states it, e.g. `Min. order: 1 unit` |
| 🏭 Supplier profile | `companyName`, `countryCode`, `goldSupplierYears` | The trading company or manufacturer behind the listing, its ISO country code, and how many years it has held Gold Supplier status |
| ⭐ Social proof | `reviewScore`, `reviewCount` | The aggregated buyer rating and the number of reviews backing it |
| 🚚 Fulfilment | `deliveryEstimate` | The delivery estimate Alibaba surfaces on the listing, where present |

The single most useful field for sourcing decisions is `goldSupplierYears`. Combined with `reviewCount`, it gives you a fast, quantitative filter for supplier maturity: a supplier with several Gold Supplier years and a triple-digit review count is a very different risk profile from a one-year listing with no reviews, even when both quote the same unit price.

***

### 🌟 Key Features of the Alibaba Listings Scraper

| Feature | Description |
|---|---|
| 🔍 Keyword-driven search | Give it any Alibaba.com search term — `samsung galaxy`, `stainless steel water bottle`, `LED strip lights` — and it walks the public search results for that query |
| 📈 Configurable result limit | The `limit` field controls how many product listings are collected, defaulting to 60 so a first exploratory run stays small and fast |
| 💵 Price band capture | Alibaba frequently quotes tiered ranges rather than a single figure; the scraper preserves the full band as returned, e.g. `₹3,560.73-9,043.13` |
| 📦 MOQ extraction | Minimum order quantity is captured verbatim, so you can immediately spot the sample-friendly `1 unit` listings versus `500 pieces` factory minimums |
| 🏭 Supplier attribution | Every record names the selling company and its ISO country code, letting you group results by sourcing region |
| 🥇 Gold Supplier tenure | `goldSupplierYears` exposes the supplier-credibility signal that Alibaba displays on the results page |
| 🔄 Automatic proxy rotation | Requests are routed through rotating proxies managed automatically by the actor — there is nothing to configure |
| ⚡ Browserless architecture | Built on lightweight HTTP requests with `curl_cffi` and HTML parsing rather than a headless browser, which keeps memory use and run cost low |
| 📤 Standard Apify dataset | Results land in an Apify dataset exportable as JSON, CSV, Excel, XML or HTML, or readable through the API |

***

### 🚀 Why Choose This Alibaba Listings Scraper?

**Only two inputs to learn.** The entire Alibaba scraper configuration is a search keyword and a result limit. There is no proxy group to pick, no session pool to tune, no cookie to paste. You type what you would type into the Alibaba search bar and press Start.

**Real supplier-risk signals, not just prices.** Plenty of scraping tools give you a title and a price. This one also returns `goldSupplierYears`, `reviewScore`, `reviewCount` and `countryCode` — the four fields buyers actually use to decide whether a cheap quote is worth pursuing.

**Price bands preserved as published.** Wholesale pricing on Alibaba is tiered, and flattening a range into a single number destroys information. The `price` field keeps the range string intact so your downstream logic can decide how to interpret it.

**Lightweight and fast by design.** Because the actor uses direct HTTP requests rather than a full browser, runs consume far less compute than browser-based alternatives, and there is no page-render bottleneck when you raise the result limit.

***

### 📥 Input

The Alibaba listings scraper takes a single required field, `search`, plus an optional `limit`.

```json
{
  "search": "samsung galaxy",
  "limit": 60
}
```

#### 🔧 Alibaba Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `search` | string | ✅ Yes | — | Keyword to search for on Alibaba.com (e.g. `"samsung galaxy"`) |
| `limit` | integer | ❌ No | `60` | Maximum number of products to scrape |

#### 💡 Input Examples

**Quick validation run** — a small sample to confirm the keyword returns the category you expect:

```json
{
  "search": "stainless steel water bottle",
  "limit": 20
}
```

**Category sweep** — a broader pull for building a supplier shortlist:

```json
{
  "search": "led strip lights",
  "limit": 200
}
```

**Default behaviour** — omit `limit` entirely and the scraper collects up to 60 listings:

```json
{
  "search": "wireless earbuds"
}
```

***

### 📤 Output

Each dataset item is one Alibaba product listing. This is a real record from an actual run of the Alibaba scraper:

```json
{
  "title": "High Quality GalaxS S24 Ultra 5G 7.3 Inch Original Mobile Phone 16GB+1TB Large Memory Smart Phone C…",
  "price": "₹3,560.73-9,043.13",
  "promotionPrice": null,
  "discount": null,
  "moq": "Min. order: 1 unit",
  "companyName": "Foshan Zhongju Zhilian International Trade Co., Ltd.",
  "countryCode": "CN",
  "productUrl": "https://www.alibaba.com/product-detail/High-Quality-GalaxS-S24-Ultra-5G_1601627418850.html",
  "mainImage": "https://s.alicdn.com/@sc04/kf/Hce514ee76678404bb5f8beed45104b1eS.jpg_300x300.jpg",
  "reviewScore": "4.0",
  "reviewCount": "88",
  "deliveryEstimate": null,
  "goldSupplierYears": "1 yr"
}
```

#### 🧾 Alibaba Listings Output Fields

| Field | Type | Description |
|---|---|---|
| `title` | string | null | Title of the product listing |
| `price` | string | null | Price of the item, often a tiered range as displayed on Alibaba |
| `promotionPrice` | string | null | Promotion price of the item, when one is advertised |
| `discount` | number | null | Discount applied to the item |
| `moq` | string | null | Minimum order quantity string for the listing |
| `companyName` | string | null | Name of the supplier company |
| `countryCode` | string | null | ISO country code of the supplier |
| `productUrl` | string | null | URL of the Alibaba product-detail page |
| `mainImage` | string | null | Main product image URL |
| `reviewScore` | string | null | Aggregated review score for the listing |
| `reviewCount` | string | null | Number of reviews |
| `deliveryEstimate` | string | null | Delivery estimate for the item |
| `goldSupplierYears` | string | null | Number of years the supplier has held Gold Supplier status |

Fields are nullable because Alibaba does not surface every attribute on every card. A listing with no active promotion returns `null` for `promotionPrice` and `discount`; a listing with no shipping estimate returns `null` for `deliveryEstimate`. Design your downstream processing to tolerate nulls rather than assuming every key is populated.

***

### 💻 How to Use the Alibaba Listings Scraper (Step by Step)

#### Step 1: Pick the Right Alibaba Search Keyword

The quality of your dataset is decided before the scraper even starts, by the keyword you choose. Alibaba's search behaves like a marketplace search engine, not a taxonomy browser, so a broad term like `bottle` will return an unusable mix of baby bottles, gas bottles and water bottles. Use the phrasing a buyer would use — `insulated stainless steel water bottle 500ml` — and test it manually on Alibaba.com first. If the first page of results looks right in the browser, it will look right in the dataset.

#### Step 2: Set a Small Result Limit for the First Run

Leave `limit` at its default of 60, or drop it lower, for your first pass. A small run finishes quickly and lets you inspect whether the returned `title` and `companyName` values match the product category you had in mind. It is far cheaper to discover a bad keyword after 20 records than after 2,000.

#### Step 3: Start the Alibaba Scraper and Watch the Log

Click **Start** in the Apify Console. The run log reports progress as listings are collected. Because the actor uses direct HTTP requests rather than a headless browser, startup is quick and there is no browser-launch delay before the first results appear. Proxy rotation is handled automatically in the background.

#### Step 4: Inspect the Dataset Before Scaling Up

Open the **Dataset** tab and switch to table view. Scan the `price`, `moq` and `goldSupplierYears` columns specifically — these are the fields most likely to reveal that your keyword pulled in the wrong tier of the market. If you wanted factory-direct suppliers but every row shows `Min. order: 1 unit`, you are looking at drop-ship resellers and should tighten the keyword.

#### Step 5: Raise the Limit for the Full Collection Run

Once the keyword is validated, re-run with a higher `limit` to build the full dataset. There is no page-number field to manage; the scraper walks the search results until it reaches the limit you set or exhausts available listings, whichever comes first.

#### Step 6: Export or Pipe the Alibaba Data Downstream

Export the dataset as CSV or Excel for manual analysis, or pull it through the Apify API into your own system. Because `productUrl` is a canonical product-detail link, the dataset doubles as a worklist: filter to the suppliers that pass your `reviewCount` and `goldSupplierYears` thresholds, then open only those URLs for detailed evaluation.

#### Step 7: Schedule Repeat Runs to Track Price Movement

Alibaba pricing moves with raw-material costs, exchange rates and seasonal demand. Schedule the same keyword and limit to run weekly, and store each dataset with its run date. Joining successive runs on `productUrl` gives you a per-listing price history without any extra tooling.

***

### 🔌 API Access & Integrations

Run the Alibaba listings scraper directly from your own code. The synchronous endpoint starts a run and returns the dataset items in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~alibaba-listings-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "search": "samsung galaxy",
    "limit": 60
  }'
```

With the official Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "search": "stainless steel water bottle",
    "limit": 100,
}

run = client.actor("scrapers-hub/alibaba-listings-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["companyName"], item["price"], item["moq"])
```

The actor also connects to Zapier, Make, Google Sheets, Slack and any HTTP webhook through Apify's standard integrations, so a finished run can push new Alibaba listings straight into a sheet or a channel.

***

### 💡 Best Use Cases for Alibaba Listings Data

#### 🧮 Landed-Cost and Margin Modelling

Pull `price` and `moq` across a category and model your landed cost before you contact a single supplier. Because the `price` field preserves Alibaba's tiered range, you can model both the low-volume and high-volume ends of a quote, then compare the resulting margin against your target retail price.

#### 🏭 Supplier Shortlisting and Vetting

Filter on `goldSupplierYears`, `reviewScore` and `reviewCount` to build a shortlist that has already cleared your credibility bar. Adding `countryCode` to the filter lets you enforce sourcing-region policy — for instance excluding or prioritising particular manufacturing hubs — before anyone spends time on outreach.

#### 📉 Wholesale Price Monitoring

Re-run the same `search` keyword on a schedule and track how `price` and `promotionPrice` shift over time. Persistent downward movement across many suppliers usually signals falling input costs or oversupply, which is exactly the moment to renegotiate an existing contract.

#### 🔎 Competitor and Private-Label Research

If a competitor's product looks like a rebadged Alibaba listing, search the product description and compare returned `title` and `mainImage` values. Matching imagery across several listings tells you which factory is behind a private-label brand and roughly what the wholesale floor price is.

#### 📦 MOQ Feasibility Screening

For a new product test, you need suppliers who will accept small orders. Filter the dataset on `moq` to isolate listings that quote single-unit or low-quantity minimums, and you have an instant sampling list rather than a category dump.

#### 🌏 Sourcing-Region Analysis

Group the dataset by `countryCode` and aggregate `price` to see how quotes for the same product differ by manufacturing region. This is often the fastest way to test whether a diversification-away-from-one-country strategy is financially viable for a given SKU.

#### 🖼️ Catalogue and Listing Enrichment

Use `title`, `mainImage` and `productUrl` to bootstrap an internal product catalogue. The image URL points at Alibaba's CDN and the product URL is canonical, so a small team can populate a sourcing database in minutes instead of days of manual data entry.

***

### ⚙️ Tips for Better Alibaba Scraping Results

- **Search the way a buyer searches.** Include material, capacity and specification in the keyword (`500ml insulated stainless steel bottle` rather than `bottle`). Alibaba's relevance ranking rewards specific queries, and a specific query gives you a cleaner dataset.
- **Start small, then scale.** Run with a low `limit` first, confirm the results are on-target, and only then raise it. This is the cheapest way to catch a mis-targeted keyword.
- **Treat `price` as a string, not a number.** The field frequently contains a currency symbol and a range. Parse it deliberately in your own code rather than assuming it will cast cleanly to a float.
- **Never filter on a single field.** A high `reviewScore` with a `reviewCount` of 2 means very little. Combine review volume, review score and `goldSupplierYears` before drawing a conclusion about supplier quality.
- **Run several narrow keywords instead of one broad one.** Three focused searches usually produce a better shortlist than one generic search with a large limit, because Alibaba's relevance drops off sharply deeper into a broad result set.
- **Timestamp every run.** Store the run date alongside the dataset. Alibaba pricing is volatile and an undated price table becomes misleading within weeks.

***

### 🛠️ Troubleshooting

**The run finished but returned fewer items than my `limit`.**
The limit is a ceiling, not a quota. If Alibaba's search returns fewer listings than you asked for — common with very specific or unusual keywords — the run ends with what it found. Broaden the keyword if you need more volume.

**Several fields come back as `null`.**
This is expected. `promotionPrice`, `discount` and `deliveryEstimate` only exist when Alibaba displays them on the listing card, and many listings have no active promotion or published shipping estimate. Nulls indicate absence of data on the page, not a scraping failure.

**The results are the wrong product category.**
Alibaba's search is keyword-relevance driven and broad terms pull in adjacent categories. Test your keyword in a browser first: if page one on Alibaba.com is off-target, the dataset will be too. Add specifying terms and re-run.

**`price` shows an unexpected currency.**
Alibaba localises pricing display, so the returned currency symbol reflects what the site served for that request. Treat the currency as part of the string and normalise it in your own pipeline if you are comparing across runs.

**The run is slower than expected on a large limit.**
Higher limits mean more search result pages, and the scraper paces requests to stay reliable. If you need a large dataset, prefer a scheduled overnight run over a large interactive one.

***

### ❓ Frequently Asked Questions About Alibaba Scraping

**What is the Alibaba Listings Scraper?**
It is an Apify actor that searches Alibaba.com for a keyword you supply and returns the public product listings as structured data — title, price, MOQ, supplier name, country, review stats and Gold Supplier tenure.

**Do I need an Alibaba account or login to use this Alibaba scraper?**
No. The scraper reads publicly visible search results only. There is no account, cookie or session token to supply.

**How many Alibaba listings can I scrape in one run?**
As many as the `limit` field allows and the search results contain. The default is 60. Setting a higher limit collects more listings, subject to how many Alibaba actually returns for your keyword.

**Can I scrape multiple keywords at once?**
The input accepts one `search` keyword per run. To cover several keywords, start several runs — this is straightforward to automate through the API or an Apify schedule.

**Does the Alibaba scraper return supplier contact details?**
No. The output fields are limited to what appears on the public search results: company name, country code and Gold Supplier tenure. Email addresses and phone numbers are not among the returned fields.

**Why is the price a range instead of a number?**
Alibaba quotes tiered wholesale pricing, where the unit price falls as order quantity rises. The scraper preserves the range exactly as published so you do not lose the tier information.

**What does `goldSupplierYears` actually mean?**
It is the number of years the supplier has held Alibaba's Gold Supplier status, reported as a string such as `1 yr`. Longer tenure generally indicates a supplier with a sustained trading history on the platform.

**Can I filter results by country before the run?**
There is no country input field. Run the search, then filter the resulting dataset on `countryCode` — this gives you the same outcome and lets you compare regions in a single dataset.

**Do I need to configure proxies for Alibaba scraping?**
No. Proxy rotation is handled automatically by the actor and is not user-configurable, so there is nothing to set up.

**Does this Alibaba scraper use a headless browser?**
No. It uses direct HTTP requests and HTML parsing, which is why runs are lightweight and quick to start compared with browser-based scrapers.

**In what formats can I export the Alibaba data?**
Apify datasets export as JSON, CSV, Excel, XML, RSS and HTML, and can be read programmatically through the Apify API or official clients.

**How do I track Alibaba price changes over time?**
Schedule the same `search` and `limit` on a recurring basis and keep each dataset separately. Joining runs on `productUrl` gives you a per-listing price series.

**Why are `reviewScore` and `reviewCount` strings rather than numbers?**
They are captured as they appear on the page. Cast them in your own pipeline if you need numeric comparison — and check for `null` first, since not every listing has reviews.

**Is scraping Alibaba search results legal?**
The scraper accesses only publicly available listing pages. You remain responsible for using the collected data in line with Alibaba's terms of service and the laws that apply to you. See the disclaimer below.

**Can I integrate this Alibaba scraper with Google Sheets or Slack?**
Yes. Apify's built-in integrations cover Google Sheets, Slack, Zapier, Make and generic webhooks, so a completed run can push results directly into your workflow.

***

### 🆘 Support & Feedback

Found a bug, a missing field, or a search keyword that produces odd results? Open a ticket on the **Issues** tab of this actor — that is the fastest route to a fix, and it keeps the report attached to the run so it can be reproduced.

Need something custom — a different Alibaba data cut, a bespoke output shape, or a scraper for another sourcing platform? Get in touch at **scraperhubapi@gmail.com** and describe what you need.

If the Alibaba Listings Scraper saves you time, please leave a review on the actor page. Ratings genuinely help other buyers and sourcing teams find the tool, and the feedback shapes what gets built next.

***

### ⚖️ Disclaimer

The Alibaba Listings Scraper collects only publicly available information from Alibaba.com search results — data that any visitor can see in a browser without logging in. It does not bypass authentication, access private supplier dashboards, or retrieve content behind a login.

You are responsible for how you use the data this Alibaba scraper produces. That includes complying with Alibaba.com's terms of service, applicable copyright in product imagery and descriptions, and the data-protection laws of your jurisdiction. Where any collected field constitutes personal data — for example a company name that identifies a sole trader — GDPR, UK GDPR, CCPA and equivalent privacy regimes may apply, and you must establish a lawful basis for processing it and honour data-subject rights.

Product listings, prices and supplier details are reproduced as published by third parties on Alibaba.com. Accuracy, availability and pricing are controlled by those suppliers and may change at any time; verify critical figures directly with the supplier before making a commercial commitment.

If you believe data collected by this actor relates to you and should be removed, contact **scraperhubapi@gmail.com** with the details and we will action the request.

# Actor input Schema

## `search` (type: `string`):

Keyword to search for on Alibaba.com (e.g. "samsung galaxy").

## `limit` (type: `integer`):

Maximum number of products to scrape.

## Actor input object example

```json
{
  "limit": 60
}
```

# Actor output Schema

## `results` (type: `string`):

Records scraped by Alibaba Listings Scraper, stored in the run's default dataset.

# 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("scrapers-hub/alibaba-listings-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("scrapers-hub/alibaba-listings-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 scrapers-hub/alibaba-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/alibaba-listings-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/p5WSXxlYFBQupHfTD/builds/j8cdDNCIEMrbLIApZ/openapi.json