# Shopee Product Scraper — No Login (`kazkn/shopee-product-scraper-no-login`) Actor Extract Shopee product data without login: local price/currency, seller, rating, optional seller-rating scope when available, availability, IDs, and canonical URL. Choose 14 official Shopee storefronts; Singapore is Verified and 13 are Beta pending market-local canaries. Incomplete rows are skipped. - **URL**: https://apify.com/kazkn/shopee-product-scraper-no-login.md - **Developed by:** [KazKN](https://apify.com/kazkn) (community) - **Categories:** E-commerce - **Stats:** 13 total users, 6 monthly users, 88.6% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $4.80 / 1,000 complete shopee products This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? 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 ## Shopee Scraper — Products, Prices & Sellers Use this Shopee scraper to search products by keyword or public URL across 14 official storefronts and export identity-checked product data to JSON, CSV, or Excel. Every accepted row includes the observed local price and currency, seller, rating, availability evidence, IDs, and canonical URL. The optional seller-rating scope is included when the source identifies it; incomplete candidates are skipped instead of exported. No Shopee login, user-supplied cookies, or user proxy configuration is requested from you. [![Shopee product export — 14 storefronts, one clean Dataset with price, seller, rating, stock and IDs](https://api.apify.com/v2/key-value-stores/IzOWcdC9rqNhBZFvI/records/shopee-product-data-hero-v2.png)](https://console.apify.com/actors/uXyD4hkjyl2M8jXgu/input) ### Choose your Shopee scraper workflow | What you want | Use this input | What you get | | ----------------------- | ------------------ | -------------------------------------------------------------------------- | | Discover products | Keyword search | Bounded storefront search; only identity-checked complete rows are written | | Check one known product | Public product URL | One exact complete product row, or a clear missing-field diagnostic | ### Quick start The form is ready for a fast, verified product check when it opens: 1. **Choose a Shopee storefront.** Singapore is selected by default and is the Verified route. Beta storefronts are labeled in the selector. 2. **Keep the verified product URL or replace it.** The Singapore sample is already filled in. The default returns one complete product and checks one page, which keeps the automated health test fast and deterministic. 3. **Start the run and download the dataset.** Export JSON, CSV, Excel, XML, RSS, or JSONL, or retrieve the Dataset through the Apify API. ```json { "market": "sg", "startUrls": [ { "url": "https://shopee.sg/Shokz-OpenFIT-2-Open-Ear-Air-Conduction-Technology-True-Wireless-Earbuds-i.47620.28778086815" } ], "maxItems": 1, "maxPages": 1 } ``` To discover products by keyword instead, clear the URL and enter one or more product phrases. Keyword mode remains available, but it is not used as the automated health-check prefill because public search results can change. ```json { "market": "sg", "searchTerms": ["wireless earbuds"], "maxItems": 5, "maxPages": 3, "sort": "relevancy" } ``` ### Storefront coverage The selector exposes the 14 official Shopee storefronts below. Singapore is **Verified** by the current canary. The other 13 are **Beta · unverified** and need a market-local canary before their transport and parser behavior can be called verified. This README does not promise that every Beta market returns a complete row yet. | Storefront | Code | Official host | Currency | Evidence status | | ----------- | ---- | --------------- | -------- | -------------------------- | | Indonesia | `id` | `shopee.co.id` | IDR | Beta · unverified | | Singapore | `sg` | `shopee.sg` | SGD | **Verified** | | Malaysia | `my` | `shopee.com.my` | MYR | Beta · unverified | | Thailand | `th` | `shopee.co.th` | THB | Beta · unverified | | Philippines | `ph` | `shopee.ph` | PHP | Beta · unverified | | Vietnam | `vn` | `shopee.vn` | VND | Beta · unverified | | Brazil | `br` | `shopee.com.br` | BRL | Beta · unverified | | Taiwan | `tw` | `shopee.tw` | TWD | Beta · unverified | | Mexico | `mx` | `shopee.com.mx` | MXN | Beta · unverified | | Colombia | `co` | `shopee.com.co` | COP | Beta · unverified | | Chile | `cl` | `shopee.cl` | CLP | Beta · unverified | | Cambodia | `kh` | `shopeekh.com` | KHR | Beta · unverified | | Argentina | `ar` | `shopee.com.ar` | ARS | Beta · keyword unavailable | | Laos | `la` | `shopee.com.la` | LAK | Beta · unverified | ### Best proven entry points Start with the storefront that matches the local catalog and currency you want to analyze. These are the clearest starting points backed by current product evidence; they are not a ranking of total market demand: | Storefront and currency | Best first workflow | Evidence boundary | | ----------------------------- | ------------------------------------------------------ | ------------------------------------------------------------------------- | | Singapore — `sg` — SGD | Keyword search or a known product URL | Verified route; one bounded URL canary is documented below | | Indonesia — `id` — IDR | Keyword product discovery and local-price export | Beta; a bounded 10-row keyword run succeeded, with 9-of-10 relevance | | Malaysia — `my` — MYR | Keyword search for catalog, seller, and price research | Beta; a bounded three-row keyword run succeeded | | Every other selectable market | Start with a small market-local keyword run | Beta; each still needs a market-local canary before any reliability claim | #### Acquisition research priority Fresh Google Keyword Planner research used both required paths across eight priority countries. Its September 2026 hypothetical **Maximize clicks** model ordered the acquisition opportunity as: **Indonesia → Vietnam → Malaysia / Thailand → Philippines / Brazil → Singapore → Mexico** Indonesia accounted for most of the modeled clicks; Vietnam was the next largest signal. Singapore remained valuable as the Verified technical entry point but carried the highest modeled CPC. This was a planning forecast under a hypothetical EUR 10 average daily budget—not observed organic demand, an Actor reliability guarantee, or a recommendation to spend. No campaign was created and no advertising spend was incurred. The remaining storefronts stay available through the selector with the exact status shown above. Beta means **use a small test run first**; it does not mean that every field, listing, or query has already been verified. Choose one storefront explicitly for keyword runs. For a direct URL run you can choose **🌐 Detect from URL — one storefront per run**; the URL host must be one of the official hosts above, and mixed storefront hosts are rejected. The default remains Singapore (`sg`) for compatibility with earlier API clients. The user-facing flow asks you for no Shopee login, no user-supplied cookies, and no user proxy configuration. This is an input boundary, not a claim that every upstream transport is cookie- or proxy-free. Argentina keyword search is currently unavailable and fails before any network request. When the optional Decodo fast-search credential is configured by the deployment, eligible canonical URLs can use a Google-indexed product source for detail reads. Other discovery and detail lanes keep their guarded fallback behavior. Provider availability is an implementation detail and is not a promise of complete results for every storefront. ### KazKN commerce intelligence suite
KazKN · Commerce intelligence suite   •  Shopee, Shopify, Vinted & Vestiaire data
Shopee Product Scraper logo  Shopee Products ↗
➤ You are here
Prices, sellers + stock evidence 		Shopify Apps Spy logo  Shopify Apps ↗
Products, reviews + installed apps 		Vinted Smart Scraper logo  Vinted Smart ↗
Cross-market resale arbitrage 		Vestiaire Collective Smart Scraper logo  Vestiaire ↗
Live + sold luxury market data
### Copy to your AI assistant Copy the **entire block below** into ChatGPT, Claude, Claude Code, Codex, Kimi Code, or your IDE assistant. It already contains the Actor reference, a ready-filled Malaysia keyword input, the Python call, Dataset retrieval, the live schema endpoint, and the token setup link. ```text kazkn/shopee-product-scraper-no-login on Apify. Searches public Shopee product listings by keyword or reads a public Shopee product URL for one selected storefront. One Dataset row per identity-checked product with market, local currency, title, price, seller, seller rating when explicitly identified, stock evidence, shop_id, product_id, canonical URL, source timestamp, data_status, and missing_fields. Incomplete candidates are skipped instead of being exported. Use Python. If needed, install the dependency with `pip install apify-client`. Read the token from the `APIFY_API_TOKEN` environment variable and never print it, paste it into chat, or commit it. Run this ready-filled Malaysia example: from apify_client import ApifyClient import os client = ApifyClient(os.environ["APIFY_API_TOKEN"]) run_input = { "market": "my", "searchTerms": ["airpods"], "sort": "sales", "maxItems": 3, "maxPages": 2, "requestDelayMs": 1000, } run = client.actor("kazkn/shopee-product-scraper-no-login").call(run_input=run_input) items = client.dataset(run["defaultDatasetId"]).list_items().items print(items) For keyword mode, `searchTerms` is a string array and `market` must be one explicit storefront code; `maxItems` caps the run output. For a known product instead, replace `searchTerms` with `startUrls`: [{"url": "https://shopee.sg/product-i.47620.28778086815"}] and set `market` to "sg". Argentina keyword discovery is currently unavailable and fails before a network request. Full spec: GET https://api.apify.com/v2/acts/kazkn~shopee-product-scraper-no-login/builds/default with `Authorization: Bearer APIFY_API_TOKEN`, then inspect inputSchema, actorDefinition.storages.dataset, and README. Create or copy your token at https://console.apify.com/account/integrations and store it only in the `APIFY_API_TOKEN` environment variable. Never paste or share the real token with an AI assistant. ``` ### What the output contains Verified identity and provenance fields are returned first so every row can be used even when a public page exposes only a subset of product details: - Product title, `product_id`, and `shop_id` when present - `market`, local `currency`, product/source links, and `source_mode` - `data_status` plus `missing_fields` for transparent completeness checks; incomplete candidates are skipped before Dataset push - Price, discount, seller, rating, stock, shipping, images, reviews, and sold counts **when Shopee exposes those values to the selected source** - `rating_scope` is optional: it is `seller` when the source explicitly identifies the seller rating scope, and `null` when no scope is available - Stock can include `available_variants` and the evidence label `indexed_variations_available` for indexed variation availability, or `public_variant_labels_available` / `public_variations_available` for explicit public PDP variant availability. A public keyword card can instead use `public_search_listing_available` to report that the listing was currently available in Shopee search. In each case, `stock.quantity` remains `null`: neither variation nor listing availability is an exact unit quantity. Details are source-bound: a required value must be observed and identity checked before a row is emitted. If the selected public page or index does not expose it, the candidate is skipped and the run summary names the missing field. When keyword discovery identifies a canonical product URL, the Actor sequentially enriches bounded candidates through the configured detail lane. Only identity-matching values observed on the canonical result are merged; a blocked, mismatched, stale, or incomplete detail response is skipped rather than emitted as an incomplete row. Price comparison is conditional: compare rows only when `price` is present and use the accompanying `currency` and `data_status` values. Do not compare local amounts across markets without converting the currencies yourself. `source_fetched_at` records when the selected source supplied the observation. Indexed results can become stale between indexing and collection, so use this timestamp when freshness matters and do not treat an indexed observation as a live inventory guarantee. ### Shopee scraper for product search and price data Use this Shopee product scraper, Shopee keyword scraper, or Shopee search scraper to collect structured product data from a phrase or a known public URL. Each accepted row keeps the storefront's local price and currency beside the product IDs, seller, rating, availability evidence, canonical URL, and source timestamp. That makes price observations useful for catalog monitoring, product research, seller analysis, or your own currency-normalized comparison workflow. Download the Dataset as JSON, CSV, or Excel, or retrieve it through the Apify API. A Shopee price scraper run never converts currencies automatically: filter and compare products within one storefront, or apply your own exchange-rate logic downstream. Rows that do not satisfy the identity and completeness contract are skipped instead of being exported with invented values. ### Limits and useful options - Up to 20 keyword searches and 100 public Shopee URLs per run - Up to 5,000 unique products and 100 opened pages per run - The configured Actor uses 1,024 MB by default, accepts 512 MB as its minimum, and caps each run at 1,024 MB. A run-level memory override cannot exceed this Actor maximum (or a lower Apify platform clamp), so the configured `$0.005` setup event remains based on one billed GB. - Search ordering: best match, best-selling, newest, price low-to-high, or price high-to-low - Products are deduplicated by marketplace, shop ID, and product ID - Large Shopee identifiers are kept as exact strings for downstream joins - Keyword enrichment is sequential and bounded; each candidate is emitted only after an identity-matching complete-detail check ### Pay-per-result pricing This Actor uses pay-per-event pricing: one **$0.005 setup charge** per run, then one result charge for every complete product row written to the Dataset: | Apify plan | Setup per run | Complete product | | ---------- | ------------: | ---------------: | | Free | $0.005 | $0.0080 | | Bronze | $0.005 | $0.0068 | | Silver | $0.005 | $0.0058 | | Gold | $0.005 | $0.0048 | | Platinum | $0.005 | $0.0048 | | Diamond | $0.005 | $0.0048 | Example Actor charges (Free / Bronze / Silver / Gold; Platinum and Diamond use the Gold result rate) are **$0.013 / $0.0118 / $0.0108 / $0.0098** for one complete product, **$0.045 / $0.039 / $0.034 / $0.029** for five, **$0.805 / $0.685 / $0.585 / $0.485** for 100, and **$8.005 / $6.805 / $5.805 / $4.805** for 1,000. Apify platform usage is included in the active Actor price and is not billed separately to you. The Actor is capped at 1,024 MB, so the `apify-actor-start` setup event is charged once per run. The `apify-default-dataset-item` result event is charged only after a complete row has passed validation and is written to the Dataset. A candidate missing a required value is skipped before Dataset push and is not charged as a result. The `minimalMaxTotalChargeUsd` value of **$0.05** is the minimum charge-limit setting accepted for a run. It is not a minimum spend, subscription, or extra fee; the actual event charges still depend on the number of complete products returned. ### Shopee scraper API, Python, n8n, and exports Use the **API** tab for generated Shopee scraper API and Python examples. Use the Dataset link for JSON, CSV, or Excel exports. For n8n, Make, Zapier, or a custom workflow, call the Actor through Apify or consume the Dataset after the run finishes. Apify Tasks and schedules can repeat the same saved input. ### Limits and data boundaries The Actor asks you for no Shopee login, user-supplied cookies, credentials, or user proxy configuration. Public pages can render different fields, challenge automated traffic, or return indexed search results instead of a full product page. Public listing candidates are labeled `source_mode: shopee_public_search`; indexed candidates use `source_mode: search_index`. Both are emitted only after the required identity, local price/currency, seller, seller-rating, and availability checks pass. The 13 enabled public-search storefronts are fail-closed and do not start an unbounded browser retry; if no complete row is proven, the Actor returns no result. Argentina keyword search currently returns `MARKET_NOT_READY` before any network request. This user-input boundary does not assert that every upstream transport is cookie- or proxy-free. ### Live market proof These are bounded, point-in-time runs—not an availability or relevance guarantee for later listings: - **Singapore:** A bounded canary v58 (build `iUSCPMZU19SBHqMN4`, run `aJ6d7aw73WzvTjUj6`) observed one product only: shop/item `47620/28778086815`, title “Shokz OpenFIT 2 Open-Ear Air Conduction Technology True Wireless Earbuds”, price `268.90 SGD`, seller `p2oMobile`, seller rating `4.939463`, and two public variant labels. Its normalized canonical URL was `https://shopee.sg/product-i.47620.28778086815`. - **Indonesia:** bounded run `BCVMtYvdl9bTBCXz6` returned 10 complete IDR rows for `airpods`; 9 of 10 titles matched AirPods and one adjacent iPhone result was also returned. This is disclosed rather than presented as perfect search precision. - **Malaysia:** bounded run `IERkI8IWo6cFb7HhY` returned 3 complete MYR rows for `airpods`, each with seller, seller rating, availability evidence, exact IDs, and a canonical product URL. The local and canary checks also cover input validation, deduplication, pagination, retries, output records, and browser isolation. This is not a promise that every Singapore listing exposes these fields, and the Indonesia and Malaysia observations do not verify the remaining Beta storefronts. ### FAQ and support #### How do I scrape Shopee product data? Choose a storefront, keep or replace the example keyword, and start the Actor. It writes only identity-checked, complete Shopee data rows to the Dataset. For a known listing, clear the keyword and paste its public product URL instead. #### Can I search Shopee products by keyword? Yes. Choose one storefront, add one or more product phrases, and keep **Best match** unless you need a different order. Each phrase runs within the same storefront and shares the overall product and page limits. #### Can I export Shopee prices to CSV or Excel? Yes. Open the run's Dataset and choose CSV, Excel, or JSON. Keep the `currency` column with every `price`, because amounts use the selected storefront's local currency and are not converted by the Actor. #### How do I call the Shopee product scraper from the Apify API? Use the exact Actor reference `kazkn/shopee-product-scraper-no-login` with the Apify API. The examples above show a synchronous call and Dataset retrieval; load `APIFY_API_TOKEN` from an environment variable and never paste or share it. #### Do I need a Shopee account? No Shopee login is requested from you. You do not need to supply user cookies or a user proxy configuration for the input form. #### Why is a field empty? Shopee pages and indexed results differ by listing and storefront. Check `data_status` and `missing_fields`; unavailable public values are returned as `null` instead of being invented. A Beta storefront may be skipped until its market-local canary passes. #### Can I use the results in an automation? Yes. Download the dataset in the format you need, call the Actor through the Apify API, or connect a Task, schedule, webhook, Make, Zapier, or spreadsheet workflow. #### Where can I report a problem? Use the Actor's **Issues** tab and include the marketplace, input type, run ID, and observed `data_status`. Never include account credentials or cookies. # Actor input Schema ## `market` (type: `string`): Choose one storefront for product searches. Use Detect from URL only when you paste a single public Shopee URL. Argentina keyword search is currently unavailable and stops before any network request. ## `searchTerms` (type: `array`): Optional keyword mode: clear the prefilled product URL, then enter product names such as `wireless earbuds`, `running shoes`, or `phone case`. Each phrase is searched independently in the selected storefront. ## `startUrls` (type: `array`): The prefilled Singapore product is the stable one-click example used by Apify's automated health test. Replace it with another public Shopee product URL, or clear it before using keyword search. A product URL can return exact identity, title, price, rating, optional seller rating scope when available, and explicit availability. ## `maxItems` (type: `integer`): Stop after this many unique, complete product rows across all searches or URLs. ## `sort` (type: `string`): Best match is recommended. Change this only when you need best-selling, newest, or price ordering. Direct product URLs are unaffected. ## `minPrice` (type: `integer`): Hidden compatibility field for existing API clients. ## `maxPrice` (type: `integer`): Hidden compatibility field for existing API clients. ## `maxPages` (type: `integer`): Hard ceiling for Shopee search pages across the run. This limits time and platform usage; it does not force every page to open. ## `request_id` (type: `string`): Hidden compatibility identifier for API clients and resumable diagnostics. ## `mode` (type: `string`): Hidden compatibility selector. The friendly form detects the source automatically. ## `keyword` (type: `string`): Hidden single-keyword compatibility field. ## `url` (type: `string`): Hidden single-URL compatibility field. ## `shop_id` (type: `string`): Hidden decimal shop identifier for API detail mode. ## `item_id` (type: `string`): Hidden decimal product identifier for API detail mode. ## `max_items` (type: `integer`): Hidden snake\_case compatibility limit. ## `max_pages` (type: `integer`): Hidden snake\_case compatibility limit. ## `cursor` (type: `string`): Hidden recovery cursor returned by a previous compatible API run. ## `min_price` (type: `integer`): Hidden snake\_case compatibility filter. ## `max_price` (type: `integer`): Hidden snake\_case compatibility filter. ## `request_delay_ms` (type: `integer`): Hidden snake\_case compatibility delay. ## `requestDelayMs` (type: `integer`): Hidden safe delay between successful page requests. ## Actor input object example ```json { "market": "sg", "searchTerms": [], "startUrls": [ { "url": "https://shopee.sg/Shokz-OpenFIT-2-Open-Ear-Air-Conduction-Technology-True-Wireless-Earbuds-i.47620.28778086815" } ], "maxItems": 1, "sort": "relevancy", "maxPages": 1, "request_id": "shopee-run", "requestDelayMs": 1000 } ``` # Actor output Schema ## `results` (type: `string`): Open the complete product dataset. Download it as JSON, CSV, Excel, XML, RSS, or JSONL from Apify. ## `runReport` (type: `string`): See collected, skipped, duplicate, retry, page, and status counters for this run. ## `openRun` (type: `string`): Open the run details, logs, storage, and exports in Apify Console. # 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 = { "searchTerms": [], "startUrls": [ { "url": "https://shopee.sg/Shokz-OpenFIT-2-Open-Ear-Air-Conduction-Technology-True-Wireless-Earbuds-i.47620.28778086815" } ] }; // Run the Actor and wait for it to finish const run = await client.actor("kazkn/shopee-product-scraper-no-login").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 = { "searchTerms": [], "startUrls": [{ "url": "https://shopee.sg/Shokz-OpenFIT-2-Open-Ear-Air-Conduction-Technology-True-Wireless-Earbuds-i.47620.28778086815" }], } # Run the Actor and wait for it to finish run = client.actor("kazkn/shopee-product-scraper-no-login").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 '{ "searchTerms": [], "startUrls": [ { "url": "https://shopee.sg/Shokz-OpenFIT-2-Open-Ear-Air-Conduction-Technology-True-Wireless-Earbuds-i.47620.28778086815" } ] }' | apify call kazkn/shopee-product-scraper-no-login --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,kazkn/shopee-product-scraper-no-login" } } } ``` 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/uXyD4hkjyl2M8jXgu/builds/h2J17tOo5RsJtpnjy/openapi.json