# Amazon Reviews Scraper — Customer Reviews & Ratings (`kestrel/amazon-reviews-scraper`) Actor Customer reviews and rating data for any Amazon product, in any marketplace: star rating, review title and body, reviewer, country, date, verified-purchase flag and helpful votes, plus the product's overall rating and total rating count. Give ASINs or product URLs. Pay per review. - **URL**: https://apify.com/kestrel/amazon-reviews-scraper.md - **Developed by:** [Tedj MEABIOU](https://apify.com/kestrel) (community) - **Categories:** E-commerce, Automation, Lead generation - **Stats:** 2 total users, 1 monthly users, 87.5% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing Pay per event 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? 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 ## Amazon Reviews Scraper — Customer Reviews & Ratings An **amazon reviews scraper** that returns **amazon customer reviews** and **amazon product reviews** for any product, in any marketplace, as structured rows: star rating, review body, reviewer, the country the review came from, date, Verified Purchase flag, helpful votes and the variation bought — plus a product row carrying **amazon ratings** and the total rating count. It turns **amazon product reviews** into **amazon review data** you can query, with **amazon ratings** attached to every product. Give it ASINs or product URLs. No login, no **amazon review api** key, no browser. It bills per row, and three filters cut what you pay for *before* you are billed. Read the **Scope** section before you buy: this reads the reviews Amazon shows publicly, not its full archive. Last verified working: 2026-08-29. ### What does the Amazon reviews scraper do? You give it products. It gives you their **amazon product reviews** as rows you can sort, filter and export. - **`review` rows** — `rating` (1–5), `title`, `text`, `author`, `country`, `date_text`, `verified`, `helpful_votes`, `variant`, and a permalink to the review. - **`product` rows** — `title`, `brand`, `rating`, `ratings_count`, `reviews_visible`, `availability`, `image`, `features`, `price` and `currency`. - **`status` rows** — free: per product, what was delivered, how many were filtered, and why anything failed. Amazon mixes **international reviews** into a product page, so `country` lets you separate domestic from imported opinion — a UK page returned reviews from three countries in testing. ### Amazon reviews by ASIN, URL or marketplace - **`asins`** takes either form: a bare **amazon asin** like `B0BSHF7WHW`, or a full product URL from any marketplace. - A URL's marketplace is used automatically. `https://www.amazon.co.uk/dp/B09G9FPHY6` is scraped from the UK site and priced in GBP without you setting anything. - **`domain`** sets the marketplace for bare ASINs. Twenty are supported: `com`, `co.uk`, `de`, `fr`, `it`, `es`, `ca`, `com.au`, `co.jp`, `in`, `com.mx`, `com.br`, `nl`, `se`, `pl`, `sa`, `ae`, `sg`, `com.tr`, `com.be`. The same ASIN on two marketplaces is two products, because the reviews genuinely differ. An ASIN and its own URL are one product, fetched and billed once — so **amazon reviews by marketplace** comparisons are explicit rather than accidental. ### Amazon negative reviews without paying for the five-star ones Three filters run **before** billing: - **`minRating`** keeps only reviews at or below a star rating. `2` is the classic complaints feed. - **`verifiedOnly`** keeps only **verified purchase reviews**, which is the fastest way to strip noise. - **`requireText`** drops rating-only reviews with no written body. Filtered rows are never charged. In a verified run, a product with 8 visible reviews delivered **0 rows** under `minRating: 3` — all its reviews were above the ceiling — and the run cost a fraction of a cent instead of billing for eight rows nobody asked for. That is what makes **amazon negative reviews** monitoring across a catalogue affordable. ### Amazon review data for sellers, brands and analysts - **Review monitoring.** Schedule a run over your ASINs and your competitors' and track rating and review volume over time — every row is timestamped. - **Amazon competitor reviews.** Pull the visible review set for a rival's catalogue and read what their customers actually complain about. - **Voice of customer.** Rated, dated review text with the reviewer's country and the variation bought is the right shape for **amazon review sentiment analysis** or topic modelling. - **Listing audits.** `verified` and `helpful_votes` separate genuine purchase feedback from noise. - **Amazon seller research.** `ratings_count` and `rating` on the product row give you **amazon product rating data** for a whole ASIN list in one run. ### Input | Field | What it does | | --- | --- | | `asins` | ASINs (`B0BSHF7WHW`) or product URLs from any marketplace. A URL's marketplace is used automatically. | | `domain` | Marketplace for bare ASINs. Twenty supported, listed above. | | `minRating` | `0` = everything. `1`–`5` = only reviews at or below that rating. Never charged for what it drops. | | `verifiedOnly` | Keep only Verified Purchase reviews. | | `requireText` | Drop rating-only reviews with no written body. | | `maxReviewsPerProduct` | `0` = every review visible on the page. `N` = the first N. | | `includeProductRow` | Emit the per-product rating summary row. | | `sessions`, `perIp` | Parallel proxy sessions and the pace of each. Leave alone unless a run is throttled. | | `proxyConfiguration` | Apify Proxy. Required — Amazon captchas datacentre traffic that is not rotated. Datacentre is a fine starting point: the run escalates to residential by itself when Amazon pushes back. | #### Example: a complaints feed across a catalogue ```json { "asins": ["B0BSHF7WHW", "B09B8V1LZ3"], "minRating": 2, "requireText": true, "verifiedOnly": true } ``` #### Example: the same product in two marketplaces ```json { "asins": ["B0BSHF7WHW", "https://www.amazon.co.uk/dp/B09G9FPHY6"], "maxReviewsPerProduct": 0 } ``` #### Example: rating summaries only, no review rows ```json { "asins": ["B0BSHF7WHW", "B08N5M7S6K"], "maxReviewsPerProduct": 0, "minRating": 1, "requireText": true } ``` ### Output ```json { "type": "review", "asin": "B0BSHF7WHW", "domain": "com", "marketplace": "US", "product_title": "Apple 2023 MacBook Pro Laptop", "review_id": "RCA7TI5EBH5VK", "rating": 5.0, "title": null, "text": "I upgraded from the i9 Intel MacBook Pro from 2019, and this laptop seriously blows that away.", "author": "Michael M", "country": "the United States", "date_text": "July 22, 2023", "verified": true, "helpful_votes": 65, "variant": null, "url": "https://www.amazon.com/gp/customer-reviews/RCA7TI5EBH5VK" } ``` The `product` row carries the rating summary: ```json { "type": "product", "asin": "B0BSHF7WHW", "domain": "com", "marketplace": "US", "title": "Apple 2023 MacBook Pro Laptop", "brand": null, "rating": 4.7, "ratings_count": 387, "reviews_visible": 13, "price": null, "price_display": null, "currency": "USD", "availability": null, "image": "https://m.media-amazon.com/images/I/example.jpg", "features": ["Apple M2 Pro chip"], "url": "https://www.amazon.com/dp/B0BSHF7WHW?th=1&psc=1" } ``` `status` rows carry `target`, `asin`, `domain`, `status`, `reviews`, `filtered`, `duplicates`, `error` and `fetched_at`. ### How much does it cost? Pay per event: one per **delivered** review row and one per product row. Free: `status` rows, every review removed by a filter, products with no visible reviews, and failed products. An ASIN and its URL are one product, fetched and billed once per run. Verified runs behind this listing cost $0.0002–$0.0024 each in platform compute. Exact per-row pricing is on this page's pricing tab. ### Amazon reviews scraper in Python, JavaScript, curl, n8n, Make or an AI agent In **Python**: ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("kestrel/amazon-reviews-scraper").call(run_input={ "asins": ["B0BSHF7WHW"], "minRating": 2, "verifiedOnly": True, "requireText": True, }) for row in client.dataset(run["defaultDatasetId"]).iterate_items(): if row["type"] == "review": print(row["rating"], row["country"], row["text"][:80]) ``` In **JavaScript** (Node): ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: '' }); const run = await client.actor('kestrel/amazon-reviews-scraper').call({ asins: ['B0BSHF7WHW', 'https://www.amazon.co.uk/dp/B09G9FPHY6'], }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items.filter((i) => i.type === 'product').map((p) => [p.marketplace, p.rating, p.ratings_count])); ``` With **curl**, synchronously: ```bash curl -X POST "https://api.apify.com/v2/acts/kestrel~amazon-reviews-scraper/run-sync-get-dataset-items?token=" \ -H 'Content-Type: application/json' \ -d '{"asins":["B0BSHF7WHW"],"minRating":2}' ``` For **n8n**, **Make** and Zapier, add the actor as a step through Apify's integration and map `rating`, `text` and `date_text` into an alert — "new one-star review on any of my ASINs" is two nodes. For **AI agents**, the actor is callable over Apify's MCP server. To get **amazon reviews csv**, run it and use the dataset's Export button, or append `?format=csv` to the dataset items API. ### Scope — read this before you buy This reads the reviews Amazon publishes on the **public product page**, which is roughly **8–13 reviews per product**, ordered by Amazon's own mix of recent and most-helpful. Amazon requires a signed-in session for its full review archive, and this actor deliberately does not attempt that — no account sharing, no cookie injection, no session resale. If you need every review a product has ever had, this is not the tool, and no honest listing should tell you otherwise. What you *do* get for every ASIN is the complete rating summary (`rating`, `ratings_count`) plus that visible sample, which is enough for rating trends, complaint detection and competitor tracking across a large catalogue. Likewise, **`price` is best-effort**. Amazon frequently withholds price markup from unauthenticated clients — on a 1.8 MB product page in testing there was no price element at all. When Amazon serves one, you get it; treat the field as a bonus, not a price-tracking feature. If you want prices and rank, use the companion Amazon Search & Best Sellers actor, which reads them from result pages where Amazon does render them. ### Is it legal to scrape Amazon reviews? This reads publicly visible product pages with no login and no account. Reviews are published deliberately for anyone to read, and *hiQ v. LinkedIn* is the usual US reference point for scraping public data. Two caveats worth taking seriously. Reviews contain **personal data** — a display name, a country, someone's words — so under GDPR you are a controller once you store them: have a lawful basis, retain only as long as you need, and do not republish reviewer identities. This actor exposes no email, phone or full legal name, and has no input that would produce one. Separately, Amazon's Conditions of Use discourage automated access, making this a terms question rather than a criminal one, with the risk on whoever operates the run. None of this is legal advice; if your use is commercial or large, ask a lawyer. ### Limits and honest notes - **8–13 reviews per product**, as covered in Scope. `reviews_visible` on the product row tells you exactly how many were on the page. - **`title` is often null.** The compact review blocks Amazon renders on product pages frequently omit a headline; the body is always there. - **Amazon serves a captcha to repeat callers.** The run detects it and rotates to a fresh IP rather than parsing the captcha page as an empty product. - **Cheap proxies first, residential only when Amazon pushes back.** A run starts on the proxies you chose — datacentre is the cheapest — and rotates to a fresh IP on a captcha or a 503. When the same page is refused twice in a row that is the IP range being blocked, not the page, so the run stops trusting that pool: its sessions re-open on a residential proxy and stay there for the rest of the run. Nothing to configure, no run has to fail to teach it, and a run that is never refused never leaves the cheap pool — so a run costs the least that still succeeds. The run's SUMMARY reports it as `http.escalated`. - **`country` is where the review was written**, not where the reviewer lives — Amazon phrases it "Reviewed in …". - **Rating is a float 1–5.** Amazon renders "5.0 out of 5 stars"; the row carries `5.0`. - **`brand` and `availability` are frequently null** on pages where Amazon does not render them. ### FAQ #### Does it need an Amazon API key or login? No. There is no public **amazon review api** for product reviews, and Amazon's Product Advertising API requires an affiliate account with sales requirements and does not return review text. This uses neither — it reads the public product page. #### Can I download Amazon reviews as CSV or Excel? Yes. Every run writes an Apify dataset, exportable to CSV, Excel, JSON or XML from the Console or over the API with `?format=csv`. That is the quick path to **download amazon reviews** for an ASIN list. #### How do I get only Amazon negative reviews? Set `minRating` to your ceiling (`2` for one- and two-star) and add `requireText: true` so you only pay for reviews with actual words. `verifiedOnly: true` strips unverified noise. Everything above the ceiling is dropped **before** billing. #### How many reviews will I get per product? Roughly 8–13 — the set Amazon shows publicly. This is a real limit, not a setting, and it is the honest answer that some listings in this category avoid giving. `reviews_visible` on each product row reports the exact number. #### Can I scrape Amazon reviews by ASIN in bulk? Yes. Put as many ASINs in `asins` as you like; each is fetched once and billed once. **Bulk amazon reviews** are billed per delivered row, so cost scales with data rather than time, and the filters cut it directly. #### Which marketplaces are supported? Twenty, listed in the input section. A product URL selects its own marketplace automatically; bare ASINs use `domain`. The same ASIN in two marketplaces is treated as two products because the reviews and ratings genuinely differ. #### Does it return prices? Best-effort only — see Scope. Amazon commonly withholds price markup from unauthenticated clients. For prices and keyword rank, use the companion Amazon Search & Best Sellers actor. #### Can I get the star-rating breakdown? The product row carries `rating` and `ratings_count` for every ASIN. The 5/4/3/2/1 percentage split is included when Amazon renders it on the page, which is not always. #### Can I scrape Amazon reviews without an API? That is what this is — **amazon reviews without api** access, no key to apply for and no affiliate account. You call an Apify actor and read rows back. #### Is there a free tier? Products with no visible reviews, filtered reviews, `status` rows and failed products are always free, so a run that finds nothing costs nothing beyond a fraction of a cent of platform compute. Apify's free plan includes monthly credit you can spend here. ### Product review data that keeps its structure Three fields decide whether a review corpus is analysable or just text, and this actor keeps all three separate. - **Rating apart from words.** `rating` and `text` are distinct, so a four-star review with an angry paragraph reads differently from a four-star review saying "fine". Weight them independently. - **Verified apart from unverified.** `verified` is a boolean on every row. Filtering to Verified Purchase before analysis removes a large share of the noise that makes **product review data** unreliable. - **Helpfulness as a signal.** `helpful_votes` is the crowd's own weighting. Sorting by it surfaces the reviews that actually shape a buying decision, which is rarely the newest one. Add `country` and `variant` and you can answer questions the Amazon interface will not: does the 128 GB variant generate more complaints than the 256, and are the complaints coming from one market? #### Amazon ratings across a catalogue Every product row carries `rating` and `ratings_count`, so a single run over an ASIN list gives you **amazon ratings** for the whole catalogue in one table. Schedule it weekly and `ratings_count` becomes review velocity — how fast each product is accumulating opinion — while `rating` shows whether that opinion is improving or slipping. Because `includeProductRow` can be left on with `maxReviewsPerProduct: 0` and a strict filter, you can run a cheap catalogue-wide rating sweep that delivers product rows and almost no review rows. #### Comparing marketplaces properly The same ASIN often sells in a dozen Amazon marketplaces, and its reception differs by market. Passing both `B0BSHF7WHW` and `https://www.amazon.co.uk/dp/B09G9FPHY6` produces two product rows with their own ratings, currencies and review sets, because they genuinely are two different audiences. That is why the run treats an ASIN plus a marketplace as the identity, rather than the ASIN alone. Mixing a bare ASIN with its own URL still collapses to one product — the de-duplication is on identity, not on string. #### What this deliberately does not do No login, no cookie injection, no session resale, and no attempt at Amazon's signed-in review archive. No seller contact details, no buyer emails. The public product page is the boundary, and there is no input that crosses it. ### Ready-made runs Each link opens this actor with the input already filled in — press Start and it runs. Every one is capped, so what it bills is on the page before you run it. What each returns is spelled out at [mtedj.github.io/kestrel-actors-examples/recipes.html](https://mtedj.github.io/kestrel-actors-examples/recipes.html). - [Negative Reviews by ASIN (1-3 Stars)](https://apify.com/kestrel/amazon-reviews-scraper/examples/amazon-negative-reviews-by-asin) - [Verified Purchase Reviews Only](https://apify.com/kestrel/amazon-reviews-scraper/examples/verified-purchase-reviews-only) - [Reviews by Marketplace: UK, DE, FR](https://apify.com/kestrel/amazon-reviews-scraper/examples/amazon-reviews-by-marketplace) - [Voice of Customer Across 25 ASINs](https://apify.com/kestrel/amazon-reviews-scraper/examples/voice-of-customer-across-25-asins) - [Product Reviews at One Star Only](https://apify.com/kestrel/amazon-reviews-scraper/examples/amazon-product-reviews-at-one-star) - [Customer Reviews on .de](https://apify.com/kestrel/amazon-reviews-scraper/examples/amazon-customer-reviews-on-amazon-de) - [Ratings and Reviews on .co.jp](https://apify.com/kestrel/amazon-reviews-scraper/examples/amazon-ratings-and-reviews-on-amazon-co-jp) - [Review Monitoring for Your Own ASINs](https://apify.com/kestrel/amazon-reviews-scraper/examples/review-monitoring-for-your-own-asins) - [Reviews Without API Approval](https://apify.com/kestrel/amazon-reviews-scraper/examples/amazon-reviews-without-api-approval) - [Product Rating Data by ASIN](https://apify.com/kestrel/amazon-reviews-scraper/examples/amazon-product-rating-data-by-asin) - [Scrape Reviews on .co.uk](https://apify.com/kestrel/amazon-reviews-scraper/examples/scrape-amazon-reviews-on-amazon-co-uk) ### Related scrapers Reviews tell you what customers said. Search and charts tell you what ranks and what sells — feed the ASINs from one into the other: - **[AliExpress Reviews Scraper](https://apify.com/kestrel/aliexpress-reviews-scraper)** — buyer feedback with photos, variant chosen and buyer country, for product research and dropshipping. - **[Trustpilot Reviews Scraper](https://apify.com/kestrel/trustpilot-reviews-scraper)** — company reviews and TrustScore from Trustpilot, past the 200-review wall an anonymous reader normally hits. - **[Amazon Product Scraper](https://apify.com/kestrel/amazon-product-scraper)** — the product itself: buybox price, list price, stock, gallery, bullets and details, without the review rows. - **[App Store Reviews Scraper](https://apify.com/kestrel/app-store-reviews-scraper)** — Apple App Store reviews for any app across every storefront in one run, with the same pre-billing rating filters. - **[Amazon Best Sellers Scraper](https://apify.com/kestrel/amazon-best-sellers-scraper)** — the Top 100 of any category by best seller rank; its `asin` column is the natural input for a reviews run. - **[Amazon Search Scraper](https://apify.com/kestrel/amazon-search-scraper)** — Amazon search results, Best Sellers and keyword rank. - **[Google Hotels Prices Scraper](https://apify.com/kestrel/google-hotels-prices)** — hotel prices and every booking site’s rate for a stay. All of them bill per delivered row, never charge for rows a filter or a spending limit removed, and write an Apify dataset you can export to CSV, Excel or JSON. # Actor input Schema ## `asins` (type: `array`): Amazon ASINs (B0BSHF7WHW) or product URLs from any marketplace (https://www.amazon.co.uk/dp/B09G9FPHY6). A URL's marketplace is used automatically; bare ASINs use the marketplace below. ## `domain` (type: `string`): Amazon marketplace for bare ASINs: com, co.uk, de, fr, it, es, ca, com.au, co.jp, in, com.mx, com.br, nl, se, pl, sa, ae, sg, com.tr, com.be. ## `minRating` (type: `integer`): 0 = keep every review. 1-5 = keep only reviews at or below that star rating, so a complaints feed costs nothing for the happy ones. Filtered reviews are never charged. ## `verifiedOnly` (type: `boolean`): Keep only reviews Amazon marks as a Verified Purchase. ## `requireText` (type: `boolean`): Drop rating-only reviews that have no written body. ## `maxReviewsPerProduct` (type: `integer`): 0 = every review visible on the product page. Amazon publishes at most 13 per product without a signed-in session (fewer outside amazon.com), so that is the ceiling here. N = the first N. ## `includeProductRow` (type: `boolean`): Emit one row per product with its title, brand, overall rating, total rating count, availability, image and feature bullets. ## `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. Amazon tolerates about 0.5/s per IP; faster causes captchas, not speed. ## `proxyConfiguration` (type: `object`): Apify Proxy is required: Amazon captchas datacentre traffic that is not rotated. RESIDENTIAL works best. ## Actor input object example ```json { "asins": [ "B0BSHF7WHW" ], "domain": "com", "minRating": 0, "verifiedOnly": false, "requireText": false, "maxReviewsPerProduct": 0, "includeProductRow": true, "sessions": 4, "perIp": 0.5, "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `dataset` (type: `string`): Customer review rows and product rating-summary rows, plus status rows. Charged rows are billed as delivered; status rows are always free. ## `summary` (type: `string`): One JSON record with the counts this run delivered and charged, its error and duplicate 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 = { "asins": [ "B0BSHF7WHW" ] }; // Run the Actor and wait for it to finish const run = await client.actor("kestrel/amazon-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 = { "asins": ["B0BSHF7WHW"] } # Run the Actor and wait for it to finish run = client.actor("kestrel/amazon-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 '{ "asins": [ "B0BSHF7WHW" ] }' | apify call kestrel/amazon-reviews-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,kestrel/amazon-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/MAnMiI3B5nqSoCQEj/builds/VHa0ayeYiXzOCOGxr/openapi.json