# AliExpress Reviews Scraper — Product Feedback & Ratings (`kestrel/aliexpress-reviews-scraper`) Actor Every AliExpress buyer review of any product: star rating, the buyer's own words plus a translation, buyer country, the SKU variant bought, their photos, the shipping method and the follow-up review. Product URLs or item ids in, reviews out. No key, no login, no browser. Pay per review. - **URL**: https://apify.com/kestrel/aliexpress-reviews-scraper.md - **Developed by:** [Tedj MEABIOU](https://apify.com/kestrel) (community) - **Categories:** E-commerce, Automation, Lead generation - **Stats:** 5 total users, 4 monthly users, 99.9% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $2.00 / 1,000 review rows This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. 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 ## AliExpress Reviews Scraper — every buyer review of any product This AliExpress reviews scraper turns any product page into a clean table of AliExpress product reviews: the 1-5 star rating, the buyer's own words plus a machine translation into the language you pick, the buyer's country, the exact SKU variant the review is about, the photos they uploaded, the shipping method the order used, the follow-up review they came back and wrote weeks later, and the helpful votes other shoppers gave it. Give it product URLs or item ids and it reads the same public AliExpress feedback endpoint the product page's own review widget calls — no API key, no login, no cookies, no headless browser. It is built as an AliExpress product research tool for dropshipping product validation: buyer reviews and buyer photos are how you tell a product worth listing from one that will drown you in refunds, and this is the cheapest way to pull them in bulk. Last verified working: 2026-08-29. ### What does the AliExpress Reviews Scraper do? You hand it a list of products. For each one it walks every review page AliExpress will serve, drops the duplicates AliExpress serves twice, applies your filters, and writes one dataset row per review. Alongside the reviews it can emit a free product row carrying the whole rating breakdown — the average, the 5/4/3/2/1-star histogram, the positive/neutral/negative split, how many reviews carry photos, how many carry a follow-up, and the structured attributes buyers were asked to rate the item on. Nothing here needs a browser. The endpoint answers plain HTTP requests from datacenter IP ranges, so a run is fast and cheap: a 2,836-review best-seller reads in about 15 requests, not 142. Three row types share one dataset, and you can filter them apart in the **Output** tab with the built-in views: | Row | What it is | Charged | | --- | --- | --- | | `review` | One buyer review | Yes | | `product` | The product's title, image and rating statistics | Free | | `status` | One per target: what happened, how many rows, why not | Free | ### AliExpress reviews for product research and dropshipping If you sell online, the review list is the product. A 4.6 average hides the fact that eleven buyers in a row said the cable frays; a 4.2 average with 313 photo reviews and a hundred people writing "arrived in 9 days, exactly as described" is a better bet than either. This scraper gives you the raw material for that judgement in bulk: - **Photos.** `images` and `follow_up_images` are the buyer's own pictures. AliExpress buyer photos show what the product actually looks like out of the bag, which is very often not what the listing photos show — for dropshipping research, AliExpress review photos are worth more than the whole listing. - **Follow-up reviews.** AliExpress lets a buyer return weeks later and add to their review. `follow_up_text` and `follow_up_days` are the closest thing the site has to a durability signal: a product with hundreds of positive first reviews and a wall of angry follow-ups at day 45 is a returns problem. - **Variant-level truth.** `sku_info` tells you which colour, size or plug type the review is about, so you can find out that the black one is fine and the white one arrives scratched. - **Shipping reality.** `logistics` is the shipping method the order actually used, which lets you separate "the product is bad" from "the shipping line is slow". - **Buyer country.** `buyer_country` lets you read only the reviews from the market you sell into. Delivery complaints do not transfer between countries. Because the output is one flat row per review, bulk AliExpress reviews drop straight into whatever you already use: pipe `text` and `rating` into an AliExpress review sentiment model, group `attributes` by SKU, or join `sku_info` against your own catalogue. ### What data does each AliExpress review row contain? ```json { "type": "review", "review_id": "60094105248269979", "product_id": "1005006255429323", "product_title": "Original Lenovo LP40 wireless headphones TWS Bluetooth Earphones", "product_url": "https://www.aliexpress.com/item/1005006255429323.html", "rating": 5, "rating_100": 100, "review_date": "2025-11-29", "review_date_raw": "29 Nov 2025", "text": "Fast delivery! Package came within estimate delivery. The headphones came in perfect condition, and the sound and connection is very nice.", "text_translated": "Fast delivery! Package came within estimate delivery.", "language": "en", "buyer_name": "AliExpress Shopper", "buyer_country": "US", "buyer_anonymous": true, "sku_id": "12000036486711239", "sku_info": "Color:LP40 white", "images": ["https://ae-pic-a1.aliexpress-media.com/kf/Ab1b4386f35a14c28b499f08897b6fea0y.jpg"], "image_count": 1, "logistics": "AliExpress Selection Standard", "helpful_votes": 0, "unhelpful_votes": 0, "attributes": {"Quality of sound": "Fast", "Durability": "Fast", "User Friendly": "Good"}, "follow_up_text": null, "follow_up_days": null, "featured": true, "ai_generated": false } ``` Every review row also carries `target` (the URL or id you asked for), `buyer_gender`, `buyer_avatar`, `follow_up_translated`, `follow_up_date`, `follow_up_images` and `fetched_at`. ### Product rows: the whole rating breakdown, free Set **Include a product row** (`includeProductRow`, on by default) and every product also gets one free row: ```json { "type": "product", "product_id": "1005006255429323", "product_title": "Original Lenovo LP40 wireless headphones", "product_image": "https://ae-pic-a1.aliexpress-media.com/kf/Haa1bfb60935a4a3ca5e24c9ef3bcd163R.jpg", "product_url": "https://www.aliexpress.com/item/1005006255429323.html", "rating": 4.2, "rating_percent": 84.9, "reviews_total": 2836, "reviews_fetched": 100, "five_star": 1888, "four_star": 380, "three_star": 207, "two_star": 106, "one_star": 266, "positive_count": 2268, "neutral_count": 207, "negative_count": 372, "positive_rate": 79.7, "negative_rate": 13.0, "with_photos_count": 313, "with_follow_up_count": 82, "same_country_count": 257, "product_type": "ORDINARY", "review_attributes": [{"attribute": "Durability : Fits ok", "reviews": 1493, "value_id": 1500325947}] } ``` `review_attributes` is the part most people miss. It is the structured attribute panel AliExpress builds from every review of the item, with the count behind each phrase — a one-row summary of what 1,493 buyers said about durability, before you read a single sentence. ### Review filters that run before you are charged Every filter runs **before billing**. A review the filters drop is never delivered and never charged, so a complaints-only run on a 3,000-review product costs you the handful of rows you keep. Three of them are applied by AliExpress itself, through **Server-side review filter** (`reviewsFilter`), so the pages you do not want are never fetched at all: | `reviewsFilter` | What AliExpress returns | | --- | --- | | `all` | Every review (default) | | `with_photos` | Only reviews carrying buyer photos | | `with_follow_up` | Only reviews the buyer came back and added to | | `same_country` | Only buyers in the one country you list in `countries` | The rest run inside the actor, on rows already in memory: - `minRating` / `maxRating` — whole stars, 1 to 5. `maxRating: 3` is the complaints feed. AliExpress has no server-side star filter, so this one has to be ours. - `requireText` — drop star-only reviews. About one review in five on a busy product is a bare rating with nothing written. - `countries` — ISO-2 buyer countries, e.g. `["US", "BR"]`. The first entry also tells AliExpress which market to answer as, which changes the order it serves. ### How do I run the AliExpress reviews scraper? Paste product URLs into **AliExpress product URLs** (`productUrls`) or numeric item ids into **AliExpress item ids** (`productIds`), set **Max reviews per product** (`maxReviewsPerProduct`, `0` = every review), press Start. ```json { "productUrls": ["https://www.aliexpress.com/item/1005006255429323.html"], "productIds": ["1005008342451530"], "maxReviewsPerProduct": 200, "reviewsFilter": "all", "minRating": 0, "maxRating": 3, "requireText": true, "countries": ["US"], "sort": "lowest_rating", "language": "en_US", "includeProductRow": true, "sessions": 2, "perIp": 1, "proxyConfiguration": {"useApifyProxy": true} } ``` Every URL form works: `aliexpress.com/item/.html`, `aliexpress.us`, `aliexpress.ru`, the `/i/.html` short form, and share links with a tail of tracking parameters. All three id namespaces (`1005…`, `3256…` on the US site, and legacy `2255…`/`4000…` ids) resolve to the same review list, and the id is always in the path, so nothing has to be loaded first to resolve a target. `sort` orders what you get back: `default`, `newest`, `oldest`, `lowest_rating`, `highest_rating`. `language` picks the translation language for `text_translated` from twelve options (English, Spanish, Portuguese, French, German, Italian, Dutch, Polish, Turkish, Russian, Japanese, Korean). `sessions` and `perIp` control pace, `proxyConfiguration` the proxy — the defaults are right for almost every run. ### Scrape AliExpress reviews from Python, JavaScript, curl, n8n and AI agents Python: ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("kestrel/aliexpress-reviews-scraper").call(run_input={ "productUrls": ["https://www.aliexpress.com/item/1005006255429323.html"], "maxReviewsPerProduct": 500, "reviewsFilter": "with_photos", "requireText": True, }) for row in client.dataset(run["defaultDatasetId"]).iterate_items(): if row["type"] == "review": print(row["rating"], row["buyer_country"], row["sku_info"], row["text"]) ``` JavaScript / Node: ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: '' }); const run = await client.actor('kestrel/aliexpress-reviews-scraper').call({ productIds: ['1005006255429323'], maxReviewsPerProduct: 0, maxRating: 3, sort: 'lowest_rating', }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items.filter((i) => i.type === 'review').length, 'complaints'); ``` curl: ```bash curl -X POST "https://api.apify.com/v2/acts/kestrel~aliexpress-reviews-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \ -H 'Content-Type: application/json' \ -d '{"productUrls":["https://www.aliexpress.com/item/1005006255429323.html"],"maxReviewsPerProduct":100}' ``` **n8n**, **Make.com** and **Zapier** all have an Apify connector: drop in a "Run an Actor" step, paste the same JSON, and pipe the dataset into Google Sheets, Airtable, Slack or a warehouse. For **AI agents**, Apify's **MCP** server exposes this actor as a tool, so a Claude or GPT agent can pull buyer feedback for a product mid-conversation and reason over it. The dataset is also exportable straight to CSV, JSON, Excel or XML from the run page — an AliExpress reviews CSV is two clicks away. ### Buyer photos, follow-up reviews and the fields nobody else exports | Field | Why it matters | | --- | --- | | `review_id` | AliExpress's own evaluation id — a stable key for deduping across runs | | `rating` / `rating_100` | Stars 1-5, and AliExpress's raw 0-100 score behind them | | `review_date` / `review_date_raw` | An ISO date parsed back from whatever language the review was requested in, plus the original string | | `text` / `text_translated` / `language` | The buyer's own words, the translation, and the served language code | | `sku_info` / `sku_id` | The exact variant the review is about | | `images` / `image_count` | Full-size buyer photo URLs | | `logistics` | The shipping method the order used | | `helpful_votes` / `unhelpful_votes` | How other shoppers voted on the review | | `attributes` | The structured attributes this buyer rated, e.g. `{"Durability": "Good"}` | | `follow_up_text` / `follow_up_translated` / `follow_up_date` / `follow_up_days` / `follow_up_images` | The review the buyer added later, and how long they waited | | `buyer_name` / `buyer_country` / `buyer_gender` / `buyer_anonymous` / `buyer_avatar` | Who wrote it, as far as AliExpress publishes it | | `featured` / `ai_generated` | AliExpress promotes this review; AliExpress believes it was AI-written | | `product_title` / `product_url` / `product_id` / `product_image` | Product context on every row | | `type` / `target` / `fetched_at` | Row type, the input it came from, and when it was read | Product rows add `rating_percent`, `reviews_total`, `reviews_fetched`, `five_star`, `four_star`, `three_star`, `two_star`, `one_star`, `positive_count`, `neutral_count`, `negative_count`, `positive_rate`, `negative_rate`, `with_photos_count`, `with_follow_up_count`, `same_country_count`, `product_type` and `review_attributes`. Status rows add `status`, `reviews`, `filtered`, `pages`, `total`, `repeats`, `duplicates` and `error`. Five saved views sit in the **Output** tab: **Overview**, **Reviews**, **Complaints** (low stars with the text, photos, shipping method and follow-up next to each other), **Photo reviews** and **Products**, plus **Status**. ### How much does this AliExpress scraper cost? You pay **$0.002 per review row** and nothing else. Product rows, status rows, duplicate targets, item ids that do not exist, and every review your filters remove are free. There is no monthly rental and no per-run platform fee beyond Apify's usual compute, so 1,000 buyer reviews cost $2. Because filtering happens before billing, a run with `maxRating: 3` on a 3,000-review product reads the whole product but only charges for the complaints it keeps. ### What are the limits of the AliExpress feedback endpoint? Worth knowing before you plan a job, all measured on 2026-08-29: - **AliExpress does not sort.** Every sort value its own endpoint accepts returns the identical page. That is why `sort` here orders the reviews the run collected rather than pretending the site does it. - **Page 1 always returns 20 rows**, whatever page size is requested, while later pages honour up to 500 at a plain offset. A naive scraper asking for 100 per page silently loses reviews 21-100 of every product. This one only ever asks for a page size that divides the offset and counts the rows it actually received, so nothing is skipped. - **The backend shuffles.** Two result orderings are served at random, so a deep walk sees a small share of reviews twice. They are deduped by `review_id`, and the count that was dropped is reported in `repeats`. - **An empty answer is ambiguous.** A product with no reviews and an item id that does not exist return byte-identical responses. This actor never guesses: an empty list is re-asked on a fresh IP and then settled against the product page, so you get `no_reviews` or `not_found`, never a false "no reviews" because of a throttle. A genuine refusal is reported as `status: "error"` with the reason. - **Price, stock and seller data are not in this dataset.** The product page renders them in the browser, so a reviews scraper cannot read them without one. Use a product scraper for those. ### Is scraping AliExpress reviews legal? Scraping publicly available data is generally lawful in the EU and the US, and reading public product reviews is one of the clearest cases: there is no login, no paywall and no personal account involved. Court decisions such as *hiQ v. LinkedIn* have repeatedly held that accessing public web pages is not unauthorised access. That said, this is general information and not legal advice. Practical guidance: the buyer names this endpoint publishes are already masked by the site (`S***l`, or "AliExpress Shopper"), but review text and photos can still contain personal data, so if you are in the EU or UK, treat the dataset under the GDPR — have a lawful basis, keep only what you need, and do not re-publish reviews in a way that identifies an individual. Respect the site's terms for your use case, do not use the data to impersonate buyers or to build fake reviews, and keep request rates reasonable. The defaults here are deliberately gentle. ### FAQ #### Do I need an AliExpress API key or account? No. This reads the same public feedback endpoint the product page itself calls. No key, no cookies, no login, no browser. #### How do I get AliExpress reviews by product id? Put the numeric id straight into `productIds`. It is the number in `/item/.html`, and it is what the `product_id` column of an earlier run gives you, so a two-stage pipeline (find products, then pull reviews) needs no URL building at all. #### Can I download AliExpress reviews as a CSV? Yes — every run's dataset exports to CSV, JSON, Excel, XML or RSS from the run page, or through the Apify API. Use the **Reviews** or **Complaints** view first if you want a tidy column set. #### How do I get AliExpress negative reviews only? Set `maxRating: 3` and `sort: "lowest_rating"`. The **Complaints** view then puts the text, the photos, the variant, the shipping method and any follow-up side by side. Filtered-out reviews are never charged. #### Can I get only AliExpress review photos? Yes. Set `reviewsFilter: "with_photos"` — that is the site's own filter, so the pages without photos are never fetched. The `images` and `image_count` columns carry the full-size URLs of the AliExpress buyer photos. #### Is there an AliExpress reviews API? There is no public AliExpress reviews API you can sign up for. This actor is the practical substitute: a REST endpoint you call with a token, returning AliExpress reviews without an api key of your own, in JSON or CSV. #### How many reviews can I get per product? Every review the site will page through. `maxReviewsPerProduct: 0` takes them all; the ceiling in practice is what a product actually has. Very large products run to a few thousand and take a couple of minutes. #### Does it translate reviews? Yes. `text` keeps the buyer's original words and `text_translated` carries the site's machine translation into whichever of the twelve `language` options you choose, so a Polish buyer's complaint arrives readable in English. #### Can I schedule it to monitor new reviews? Yes — schedule the actor daily or weekly, sort `newest`, cap `maxReviewsPerProduct` at a hundred or so, and dedupe on `review_id` downstream. That is the cheapest form of review monitoring for a catalogue you resell. #### What happens if a product id is wrong? You get a free `status` row with `status: "not_found"` and a reason, and the run carries on with the other targets. Nothing is charged. ### Related scrapers Product research rarely stops at one marketplace. These share the same row discipline and the same pay-per-delivered-row billing: - [Amazon Reviews Scraper](https://apify.com/kestrel/amazon-reviews-scraper) — the same job on Amazon, for comparing the same product across both marketplaces. - [Amazon Product Scraper](https://apify.com/kestrel/amazon-product-scraper) — titles, prices, ratings and specifications when you need the listing rather than the feedback. - [eBay Scraper](https://apify.com/kestrel/ebay-search-scraper) — eBay search results with price, shipping, condition, seller feedback, watchers and units sold, for the third marketplace in a resale or dropshipping price check. - [Amazon Search Scraper](https://apify.com/kestrel/amazon-search-scraper) — Amazon keyword results with page position and a sponsored flag, when the question is what ranks for a phrase rather than what buyers said. - [Amazon Best Sellers Scraper](https://apify.com/kestrel/amazon-best-sellers-scraper) — the Top 100 of any Amazon category with every rank filled, for finding products worth sourcing before you read their feedback. # Changelog This Actor's version history is a separate document: https://apify.com/kestrel/aliexpress-reviews-scraper/changelog.md # Actor input Schema ## `productUrls` (type: `array`): AliExpress product pages, e.g. https://www.aliexpress.com/item/1005006255429323.html — aliexpress.us, aliexpress.ru, the /i/.html short form and any share link with tracking junk after the ? all work, because every AliExpress item URL carries the numeric item id in its path. No page has to be loaded to resolve them. ## `productIds` (type: `array`): AliExpress numeric item ids, e.g. 1005006255429323 — the number in /item/.html, and what an earlier run's product\_id gives you. All three AliExpress id namespaces work (1005…, 3256… on aliexpress.us, and the legacy 2255…/4000… ids), and they resolve to the same reviews. ## `maxReviewsPerProduct` (type: `integer`): 0 = every review the product has (AliExpress pages them in blocks of up to 500; a best-seller runs to a few thousand). N = the first N AliExpress serves. This is the main cost control: it caps how many reviews are read, and the filters below then decide which of them are worth paying for. ## `reviewsFilter` (type: `string`): The only three filters AliExpress itself applies, so the pages you do not want are never even fetched. All reviews = no filter. Only reviews with photos = AliExpress's own photo filter (buyer photos are the fastest way to judge whether a product is worth listing). Only reviews with a follow-up = buyers who came back weeks later to update their review, the best durability signal on the site. Only buyers from the chosen country = AliExpress's one country filter; it needs exactly one entry in Buyer countries. ## `minRating` (type: `integer`): AliExpress reviews are whole stars, 1 to 5. 0 = no floor; 5 keeps only the perfect scores. AliExpress has no server-side star filter, so this one runs in the actor — the pages are still read, the filtered reviews are simply never charged. ## `maxRating` (type: `integer`): The other end of the same 1-5 scale: 0 = no ceiling, 3 gives a complaints feed of everything a buyer was unhappy about. Combine with Sort = lowest rated first and the Complaints view in the dataset tab. Filtered reviews are never charged. ## `requireText` (type: `boolean`): Drop star-only reviews (an empty feedback field) before billing. On AliExpress roughly one review in five is a bare star rating, so this is a real saving when you are after review text for product research. ## `countries` (type: `array`): Keep only reviews from buyers in these ISO-2 countries, e.g. US, BR, ES, PL. Empty = every country. The first entry also tells AliExpress which market to answer as, which decides the ordering it serves and which reviews the "Only buyers from the chosen country" filter keeps. Filtered reviews are never charged. ## `sort` (type: `string`): The order the reviews are delivered in. AliExpress ignores every sort parameter its own endpoint accepts (verified 2026-08-29: complex\_default, dateDescending and positive\_first all return the identical page), so this actor orders the reviews it collected instead of pretending the site does. Newest/oldest use the review date; lowest rated first is the complaints feed. ## `language` (type: `string`): AliExpress machine-translates every review into one language of your choice: text\_translated comes back in this language whatever the buyer wrote in, and text keeps the original. It also decides the language the review date is written in, which the actor parses back to an ISO date for you. ## `includeProductRow` (type: `boolean`): Also emit one free row per product with its title, image, average rating, the full 1-5 star histogram, the positive/neutral/negative split, how many of its reviews carry photos or a follow-up, and the structured attributes buyers rated it on. It is what a product-research run actually wants, it costs one extra request per product, and it is never charged. ## `sessions` (type: `integer`): How many proxy sessions (egress IPs) run in parallel. More is faster; each is paced separately. ## `perIp` (type: `number`): Pace for each session. AliExpress's feedback endpoint answered 150 back-to-back requests from a single datacenter IP with no throttling at all, and 10 of 10 at 1 req/s; 1-2 is comfortable. ## `proxyConfiguration` (type: `object`): Apify Proxy with the datacenter group is enough: the feedback endpoint answers plain HTTP requests from datacenter ranges with no key, no cookies and no bot gate. Residential works too and costs more. Keep the default. ## Actor input object example ```json { "productUrls": [ "https://www.aliexpress.com/item/1005006255429323.html" ], "productIds": [], "maxReviewsPerProduct": 100, "reviewsFilter": "all", "minRating": 0, "maxRating": 0, "requireText": false, "countries": [], "sort": "default", "language": "en_US", "includeProductRow": true, "sessions": 2, "perIp": 1, "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `dataset` (type: `string`): One row per buyer review, plus per-product context and status rows. Charged rows are billed as delivered; product and status rows are always free. ## `summary` (type: `string`): One JSON record with the counts this run delivered and charged, its error, duplicate and repeat tallies, and its HTTP stats. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "productUrls": [ "https://www.aliexpress.com/item/1005006255429323.html" ] }; // Run the Actor and wait for it to finish const run = await client.actor("kestrel/aliexpress-reviews-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "productUrls": ["https://www.aliexpress.com/item/1005006255429323.html"] } # Run the Actor and wait for it to finish run = client.actor("kestrel/aliexpress-reviews-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 '{ "productUrls": [ "https://www.aliexpress.com/item/1005006255429323.html" ] }' | apify call kestrel/aliexpress-reviews-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,kestrel/aliexpress-reviews-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 ` 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/0dLlweZuLCsHkdi3y/builds/NFs7dV5qfOyUS0RHG/openapi.json