# Amazon Product Scraper: Offers, Buy Box, BSR & Price Monitor (`cleanpull/amazon-product-scraper`) Actor Amazon product data API by ASIN, URL, search or barcode in 22 marketplaces: price, Buy Box seller, every seller's offer, Best Sellers Rank at every level, bought-past-month, ratings, variants, specs and what changed since your last run. From $3 per 1,000 products. - **URL**: https://apify.com/cleanpull/amazon-product-scraper.md - **Developed by:** [CleanPull](https://apify.com/cleanpull) (community) - **Categories:** E-commerce, Automation - **Stats:** 3 total users, 1 monthly users, 95.1% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $2.40 / 1,000 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? 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 ## Amazon Product Scraper: Offers, Buy Box, BSR & Price Monitor Amazon product data by **ASIN, product URL, search or barcode** in **22 marketplaces**, as each country's shoppers see it: **price and list price**, the **Buy Box seller** (or that the Buy Box is suppressed), **every seller's offer** with seller rating and FBA, **Best Sellers Rank at every category level**, **"bought in past month"**, ratings with the **star breakdown**, variants, images, specs and featured reviews. Schedule it and every row says **what changed since your last run**: price, Buy Box owner, stock, rank, rating, sellers joining or leaving. From **$3 per 1,000 products**. ### What you can do with it - **"Who holds the Buy Box on my products, and at what price?"** Read your ASINs with every seller's offer; Buy Box changes and suppression show up as changes. - **"Alert me when a competitor changes price or goes out of stock."** Schedule Changes only: only products that moved are returned, with the old and new value. - **"Which products in this niche actually sell?"** Search a term and get each product's rank at every category level and its "bought in past month" figure. - **"Is my product priced right in Germany, France and Japan?"** The same ASIN in each marketplace, priced as local shoppers see it, in local currency. - **"What does Amazon keep from each sale?"** Every US product row carries its referral fee and FBA fee, worked out from Amazon's published 2026 fee schedule and the product's size and weight. - **"How much does this niche sell at least?"** Search with the search summary on: the sum of the leaders' "bought in past month" badges, and that times their price. - **"Look up products from a list of barcodes."** UPC, EAN or ISBN-13: each is matched to its Amazon product. - **"Enrich another dataset."** Point it at a dataset whose rows hold ASINs or product URLs. ### What makes the data right - **Each marketplace is read from that country.** Amazon shows a page for the delivery country of the visitor's address, and a signed-out visitor cannot change it: from abroad, offers that do not ship there disappear and the Buy Box can look suppressed. This actor reads amazon.de from Germany, amazon.co.jp from Japan and so on, and every row gives the delivery location Amazon used. A page shown for another country is read again on a fresh address; if Amazon keeps showing another country's view, the row says `localView: false` and is left out of change tracking. - **The whole page, every time.** Amazon sometimes serves only the top half of a product page (no details, rank or review breakdown). The actor notices and fetches the missing half, so those fields are filled rather than silently empty. - **A suppressed Buy Box is reported as such** (`buyBoxSuppressed: true`), not as a missing price; the offers still list who sells it and for how much. - **Only delivered products are billed.** A product that could not be read is listed in the run summary with the reason, never charged. - **Runs do not fail for one bad entry.** An unknown ASIN, a non-product URL or a malformed barcode is skipped with a warning; an empty input runs the form's example. ### Input | Field | What it does | | ------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | `asins` | ASINs (B0…, or ISBN-10 for books) or product URLs, one per line. A URL uses its own marketplace | | `productUrls`, `startUrls` | Product URLs from any marketplace (string or `{ "url": … }`) | | `searches`, `maxResultsPerSearch`, `includeSponsored` | Search terms; how many products to read from each (pages are followed); include ads or not | | `barcodes` | UPC, EAN or ISBN-13, each matched to its product | | `datasetId`, `datasetField` | Another dataset whose rows hold ASINs or product URLs | | `marketplace` | For ASINs, searches, barcodes and dataset rows: US, GB (or UK), DE, FR, IT, ES, CA, MX, BR, JP, IN, AU, NL, SE, PL, BE, TR, AE, SA, SG, EG, IE | | `includeOffers`, `maxOffers` | Every seller's offer from the all-offers panel | | `includeReviews` | Keep the featured reviews the product page shows | | `includeSearchSummary` | One free summary row per search: the monthly sales floor and median Amazon fees of the products read | | `changesOnly`, `monitorName`, `changeTypes` | Return only products that changed since the last run with the same monitor name | | `minPriceChangePercent`, `minRankChangePercent` | Ignore small moves | | `maxItems`, `fields`, `maxConcurrency`, `fullPageRetries`, `proxyConfiguration` | Limits, field selection and tuning | #### Example inputs Your products with every seller, checked daily for changes: ```json { "asins": ["B0DTK7VDTH", "https://www.amazon.de/dp/B00UTBFWNU"], "includeOffers": true, "changesOnly": true, "monitorName": "my-catalogue" } ``` The top 50 organic results of a search in the UK: ```json { "searches": ["coffee grinder"], "marketplace": "GB", "maxResultsPerSearch": 50 } ``` Barcodes to Amazon products: ```json { "barcodes": ["0012345678905", "4006381333931"], "marketplace": "DE" } ``` ### Output One row per product. The main fields: ```json { "recordType": "product", "marketplace": "US", "asin": "B0DTK7VDTH", "url": "https://www.amazon.com/dp/B0DTK7VDTH", "source": "search", "query": "gaming chair", "position": 3, "title": "GTPLAYER Gaming Chair with Footrest…", "brand": "GTPLAYER", "price": 79.99, "listPrice": 139.99, "currency": "USD", "savingsPercent": 43, "buyBoxSuppressed": false, "buyBoxSeller": "Verona Sky", "buyBoxSellerId": "A2FOCRURH1KCXI", "soldByAmazon": false, "fulfilledByAmazon": false, "inStock": true, "rating": 4.4, "reviewCount": 6120, "starBreakdown": { "5": 72, "4": 14, "3": 7, "2": 3, "1": 4 }, "rank": 667, "rankCategory": "Home & Kitchen", "bestSellersRanks": [ { "rank": 667, "category": "Home & Kitchen" }, { "rank": 1, "category": "Video Game Chairs" } ], "boughtPastMonth": "6K+ bought in past month", "boughtPastMonthMin": 6000, "parentAsin": "B0CWK8XMGH", "variations": [{ "asin": "B0HHS98VTK", "dimensions": { "color_name": "Snow White" } }], "categories": ["Home & Kitchen", "Furniture", "Gaming Chairs", "Video Game Chairs"], "image": "https://m.media-amazon.com/images/I/….jpg", "deliveryLocation": "Update location", "offers": [ { "position": 0, "buyBox": true, "price": 79.99, "condition": "New", "seller": "Verona Sky", "sellerId": "A2FOCRURH1KCXI", "fulfilledByAmazon": false, "sellerRating": 4, "sellerRatingCount": 5326, "sellerPositivePercent": 69, "delivery": "FREE delivery October 13 - 15" } ], "offersTotal": 1, "lowestOfferPrice": 79.99, "changes": [{ "type": "price", "field": "price", "from": 89.99, "to": 79.99, "percent": -11.1 }], "firstSeen": false } ``` **Amazon fees** (`fees`, every product row; amazon.com only), a real row: ```json { "asin": "B07C1YFV6D", "price": 20.51, "fees": { "supported": true, "currency": "USD", "price": 20.51, "referralCategory": "Grocery and Gourmet", "referralFee": 3.08, "referralFeeRange": null, "closingFee": 0, "fbaFee": 6.37, "fbaFeeRange": null, "sizeTier": "Large standard", "shippingWeightLb": 1.88, "totalFees": 9.45, "totalFeesRange": null, "afterFees": 11.06, "afterFeesRange": null, "feePercentOfPrice": 46.1, "feePercentOfPriceRange": null, "period": "peak", "measured": { "sidesIn": [7.88, 6.25, 4.25], "weightLb": 1.88, "dimensionalWeightLb": 1.51, "sidesFrom": "Product Dimensions", "weightFrom": "Product Dimensions" }, "missing": [], "confidence": "medium", "basis": "Referral fee: Amazon's published Grocery and Gourmet rates on the featured price (…). FBA fee: the 2026 US peak rate card for a large standard unit at 1.88 lb (…), with the 3.5% fuel and logistics surcharge, if the product is fulfilled by Amazon. (…)", "scheduleVersion": "amazon-us-2026 (fetched 2026-10-23)" } } ``` - **Referral fee**: Amazon's published rate for the category, matched from the product's browse path (tiered categories and the $0.30 minimum included; the $1.80 closing fee on books, music, video, software, video games, consoles and video game accessories in `closingFee`). Without a browse path, the Best Sellers Rank category stands in as a near match (confidence medium at most). - **A level that is not a fee category of its own**: some category levels hold products charged at different rates, so a path that stops there could be more than one fee category: - Electronics, Computers & Accessories, Cell Phones & Accessories, Camera & Photo, and their "… & Accessories" levels: a device, or the electronics accessories rate. - Amazon Devices & Accessories: a device, or the 45% device accessories rate. - Video Games or a platform: a console (8%), or games and accessories (15%). - Clothing, Shoes & Jewelry down to "Women" or "Men": clothing, shoes, jewelry, watches or bags. - Tools & Home Improvement, or Power & Hand Tools: a base power tool (12%) or other tools. - Automotive, or Tires & Wheels: tyres (10%) or other parts (12%). - Home & Kitchen (furniture over $200) and Patio, Lawn & Garden (mowers, patio furniture). When the page's path (or its Best Sellers Rank category) stops at such a level: - `referralCategory` is null; - `referralFeeRange` gives the lowest and highest fee over those categories, with the categories, and `referralFee` is null; - the total, after-fees and percentage ranges carry the range through; - `confidence` is low, and `basis` starts "category not specific enough". If every category gives the same fee at that price, the fee is exact, as a near match. Where clothing and shoes, jewelry, watches or bags are all possible, the FBA fee is a range over the apparel and the standard rate cards. - `measured.dimensionalWeightLb` is the dimensional weight the size tier used: length × width × height ÷ 139, with width and height of at least 2 in for bulky and extra-large tiers. - **FBA fee**: Amazon's published 2026 US rate card (non-peak, or holiday peak from 15 October to 14 January; apparel rates for clothing), for the size tier and shipping weight the page's dimensions and weight give, with the 3.5% fuel and logistics surcharge. `afterFees` is the price minus all of it: what a sale pays out before product cost, freight and ads. - **When the page is not enough, it says so**: no dimensions or weight gives `fbaFee: null` and lists them in `missing`. A page with two sides and no height, or with the item's size where that size is bulky (a yoga mat laid flat, assembled furniture), gives `fbaFeeRange` (and the total, after-fees and percentage ranges) instead, with the assumption in `assumes`. When both ends of that range cost the same (a small, thin item is in the same tier flat or tall), the exact `fbaFee` and totals come instead, with the assumption kept in `basis`. - `confidence`: `high` for a package size and an exact category match, one step down for each doubt (item size or an FBA range, a near category match); `low` when the category is not specific enough. - Not included: dangerous goods, lithium battery, overmax and low-inventory fees, storage, inbound placement and returns. Other marketplaces give `supported: false` with the reason: Amazon's UK and EU FBA rate cards are not modelled yet. **`search-summary`**, one per search with `includeSearchSummary` (free, not counted in Max items), a real row: ```json { "recordType": "search-summary", "marketplace": "US", "query": "yoga mat", "productsFound": 10, "productsRead": 10, "complete": true, "searchCutShort": null, "currency": "USD", "priceMedian": 24.98, "salesFloor": { "unitsPerMonthMin": 33600, "revenuePerMonthMin": 858344, "listingsCounted": 10, "listingsWithBadge": 9, "currency": "USD", "basis": "The sum of Amazon's \"bought in past month\" badges over the products read for this search (…), each counted at the bottom of its bucket (\"1K+\" = 1,000), and that floor times each one's price. A floor, not an estimate of actual sales: (…)" }, "fees": { "currency": "USD", "listingsWithReferralFee": 10, "listingsWithFbaFee": 0, "medianReferralFee": 3.75, "medianFbaFee": null, "medianTotalFees": null, "medianFeePercentOfPrice": null, "medianReferralFeeRange": { "low": 3.75, "high": 3.75, "listings": 10 }, "medianFbaFeeRange": { "low": 6.51, "high": 39.72, "listings": 10 }, "medianTotalFeesRange": { "low": 10.26, "high": 43.29, "listings": 10 }, "medianFeePercentOfPriceRange": { "low": 41.8, "high": 177.25, "listings": 10 }, "basis": "From the products' own fee estimates (…)" } } ``` The fee medians: `medianReferralFee`, `medianFbaFee`, `medianTotalFees` and `medianFeePercentOfPrice` are over the products whose fee is exact. Each `…Range` is over the products with that fee exact or as a range, an exact fee counting as both ends: `low` is the median of the low ends, `high` the median of the high ends. In this row every mat's page gives its unrolled size, so the FBA fee is a range from a rolled-up box to a box the mat's size. Each search counts its own results, including ones another search or your ASINs also list (read and charged once). `productsRead` counts the results delivered or checked; a result that could not be read or that a limit stopped is left out, and `complete` is then false. A search that failed part-way is not complete either, and `searchCutShort` says after how many results and why. A product shown again on a later results page counts once. `salesFloor` is at least what the leaders sell: a product without a badge counts 0, and "10K+" can be far more than 10,000. It is never an estimate of actual sales. Also: `images`, `features`, `description`, `specs` (every row of the details tables), `availability`, `unitPrice`, `coupon`, `deal`, `featuredReviews` (title, rating, date, verified purchase, text, helpful votes, variant; no reviewer names), `dateFirstAvailable` where Amazon shows it, `offerCount`, `localView`, `missingSections`, `barcodeVerified` (for barcode lookups: whether the page lists that barcode; a product listing a different one is not delivered), `scrapedAt`. Dataset views: **Products**, **Offers** (one row per seller), **Changes** and **Search summaries**. Search summary rows share the dataset with product rows, and dataset views cannot filter rows, so the Products view starts with the row type (`recordType`). A dataset with search summaries given back as `datasetId` skips them. `RUN_SUMMARY` in the key-value store gives the outcome (`COMPLETE`, `PARTIAL`, `NO_CHANGES`, `EMPTY`, `FAILED`), counts, charges and every product that could not be read, with the reason. ### Pricing | Event | Free and Bronze | Silver | Gold and above | | --------------------------------------------------- | --------------- | ------ | -------------- | | Product (a delivered row) | $3.00 | $2.70 | $2.40 | | Every seller's offer (add-on, with `includeOffers`) | $1.00 | $0.90 | $0.80 | | Product read outside the US (add-on) | $3.00 | $2.70 | $2.40 | | Product checked, unchanged (Changes only) | $0.50 | $0.45 | $0.40 | Per 1,000 products. Each run also has a $0.00005 start fee. Outside the US, pages are read through addresses in that country so you get local prices, sellers and Buy Box; that traffic is what the add-on covers. A daily check of 100 US products with Changes only is 3,000 checks a month: $1.50, plus the products that changed. ### Limits - **Reviews**: the featured reviews on the product page only (Amazon shows full review lists to signed-in shoppers, and this actor never signs in). The star breakdown and review count cover all reviews. - **Delivery location** is the marketplace's country as a whole, not a postcode: delivery dates and some regional offers can differ for a specific address. - **Searches** follow Amazon's own ranking, as far as Amazon pages through the results for that term. - **Prices for Subscribe & Save, business pricing and Prime-only deals** are not separate fields. - **Nothing found**: when no product could be read because none exists (an ASIN Amazon does not have, a barcode with no match, input that names no product), the run still succeeds, with one free `recordType: "unreadable"` row per item giving the `reason`; nothing is charged. A run near its time limit stops starting products, delivers what it read and lists the rest the same way. ### Changelog - **0.1.x, reliability** (2026-10-24): runs that find nothing (missing ASINs, unmatched barcodes, input naming no product) end SUCCEEDED with a free `unreadable` row per item saying why, instead of FAILED; a run stops starting products before its time limit and ends with what it read, never TIMED-OUT. A run whose every product Amazon refused still fails. Prices and events unchanged. - **0.1.x, fix** (2026-10-23): a two-sides FBA range whose ends are equal is now the exact `fbaFee`, with totals and after-fees (it was `fbaFeeRange {low: 2.71, high: 2.71}` with `fbaFee: null`); the assumption stays in `basis`, the confidence is unchanged. - **0.1.x** (2026-10-23): Amazon fees on every US product row (`fees`: referral and FBA fee from Amazon's published 2026 schedule, the size tier, what is left after fees, and what the page lacked); optional free search summary rows with the leaders' monthly sales floor (`includeSearchSummary`). Prices and events unchanged. - **0.1** (October 2026): products by ASIN, URL, search, barcode or dataset in 22 marketplaces, read from each country; every seller's offer; Best Sellers Rank at every level; half pages completed; monitoring with changes; Buy Box suppression. # Actor input Schema ## `asins` (type: `array`): One per line: an ASIN (B0…, or ISBN-10 for books) or any Amazon product URL (…/dp/ASIN). A URL uses its own marketplace; an ASIN uses the marketplace below. A barcode here is looked up like the Barcodes field. ## `productUrls` (type: `array`): Optional. Amazon product URLs, from any marketplace. Same as putting them in ASINs. ## `searches` (type: `array`): Optional. Search terms, one per line; the actor reads the products each search returns, in Amazon's order, up to the limit below. ## `maxResultsPerSearch` (type: `integer`): How many products to read from each search (Amazon shows about 48 per page; the actor follows the pages). ## `includeSponsored` (type: `boolean`): Also read sponsored (ad) results of searches. Off: organic results only. ## `barcodes` (type: `array`): Optional. UPC, EAN or ISBN-13, one per line. Each is looked up on Amazon and its product read. ## `datasetId` (type: `string`): Optional. Another dataset (for example a previous run or another actor's results) whose rows hold ASINs or product URLs. ## `datasetField` (type: `string`): The field holding the ASIN or product URL in that dataset. "asin", "url" and "productUrl" are also tried. ## `marketplace` (type: `string`): For ASINs, searches, barcodes and dataset rows: a country code or domain. US, GB (or UK), DE, FR, IT, ES, CA, MX, BR, JP, IN, AU, NL, SE, PL, BE, TR, AE, SA, SG, EG, IE. ## `includeOffers` (type: `boolean`): Also read the all-offers panel: every seller with price, condition, seller rating, FBA, delivery and Buy Box position, plus the lowest offer. Adds $1 per 1,000 products. ## `maxOffers` (type: `integer`): How many offers to read per product (about 10 per panel page). ## `includeReviews` (type: `boolean`): Keep the reviews the product page itself shows (up to about 13, where the page includes them). Full review lists need a sign-in, which this actor never uses. ## `includeSearchSummary` (type: `boolean`): Add one summary row per search (recordType search-summary): the monthly sales floor of the products read (the sum of their "bought in past month" badges, and that times their price) and their median Amazon fees. Free: summary rows are not charged and do not count toward Max items. ## `changesOnly` (type: `boolean`): Return only products that changed since the last run with the same monitor name (price, Buy Box, stock, rank, rating, sellers). Unchanged products cost $0.50 per 1,000. Every product row always lists its changes; the first run is the baseline. Schedule it daily or hourly. ## `monitorName` (type: `string`): Runs with the same name compare against each other. Use one name per product list you track. ## `changeTypes` (type: `array`): Which changes count. ## `minPriceChangePercent` (type: `integer`): Ignore price moves smaller than this percentage. 0 reports every change. ## `minRankChangePercent` (type: `integer`): Ignore rank moves smaller than this percentage (rank 1,000 → 1,080 is 8%). ## `maxItems` (type: `integer`): Optional. Stop after this many product rows. ## `fields` (type: `array`): Optional. Keep only these fields, for example \["asin", "title", "price", "buyBoxSeller", "rank"]. ## `maxConcurrency` (type: `integer`): Products read in parallel per marketplace. Amazon answers bursts with 503s, so keep this low. ## `fullPageRetries` (type: `integer`): Amazon sometimes serves a product page without its lower half (details, Best Sellers Rank, review breakdown). The page is read again on a fresh session this many times, keeping the fullest. Each retry is another page load. ## `proxyConfiguration` (type: `object`): Optional. The actor picks proxies itself (direct, then datacenter, then residential only when Amazon blocks the others). ## `startUrls` (type: `array`): Optional. Accepted for compatibility with other Amazon actors: product URLs, same as Product URLs. ## Actor input object example ```json { "asins": [ "B004Q5M7O2" ], "maxResultsPerSearch": 20, "includeSponsored": false, "datasetField": "asin", "marketplace": "US", "includeOffers": false, "maxOffers": 10, "includeReviews": true, "includeSearchSummary": false, "changesOnly": false, "monitorName": "default", "changeTypes": [ "price", "buy-box", "stock", "rank", "rating", "sellers" ], "minPriceChangePercent": 0, "minRankChangePercent": 10, "maxConcurrency": 3, "fullPageRetries": 1 } ``` # Actor output Schema ## `results` (type: `string`): One row per product, with offers and changes when asked for. ## `products` (type: `string`): No description ## `offers` (type: `string`): No description ## `changes` (type: `string`): No description ## `summary` (type: `string`): Outcome (COMPLETE, PARTIAL, NO_CHANGES, EMPTY, FAILED), counts, charges and products that could not be read. # 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 = { "asins": [ "B004Q5M7O2" ] }; // Run the Actor and wait for it to finish const run = await client.actor("cleanpull/amazon-product-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 = { "asins": ["B004Q5M7O2"] } # Run the Actor and wait for it to finish run = client.actor("cleanpull/amazon-product-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 '{ "asins": [ "B004Q5M7O2" ] }' | apify call cleanpull/amazon-product-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,cleanpull/amazon-product-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/ItbeclrdnEXiEnS4s/builds/lbzdyEmFHKSM9rkEB/openapi.json