# Amazon Product Scraper API - Prices, ASINs & Sellers (`molded_mountainpass/amazon-product-scraper`) Actor

Amazon scraper that extracts product data without using the Amazon API. Scrape prices, ASINs, ratings, review insights, bestseller ranks, sellers and variants from any search, category or product URL across 24 Amazon marketplaces. Download as JSON, CSV, Excel or XML.

- **URL**: https://apify.com/molded_mountainpass/amazon-product-scraper.md
- **Developed by:** [Divya Raj](https://apify.com/molded_mountainpass) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 product scrapeds

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

## Amazon Product Scraper API — prices, ASINs, reviews and sellers

**Scrape Amazon product data without using the Amazon API.** Give this Amazon scraper any **search, category or product URL** and it returns prices, ASINs, ratings, review insights, bestseller ranks, sellers and variants — across **24 Amazon marketplaces** — as JSON, CSV, Excel or XML.

No login. No cookies. No Amazon Product Advertising API key. Call it from Python, JavaScript or plain HTTP through the Apify API, or send the results straight into n8n, Make, Zapier or Google Sheets.

**55 fields per product**, including list prices, star breakdowns, Amazon's own AI review summary, bestseller ranks, sellers with their registered business details, every variant with its own price, A+ content, and delivery dates for any postcode.

***

### What you can use it for

| Use case | What to pull |
|---|---|
| **Price monitoring & repricing** | `price`, `listPrice`, `shippingPrice`, `offers`, per-variant prices |
| **Competitor & market research** | A whole category or search term, with `categoryPageData.productPosition` and `isSponsored` |
| **Product research for sellers** | `bestsellerRanks`, `monthlyPurchaseVolume`, `reviewsCount`, `starsBreakdown` |
| **Review intelligence** | `aiReviewsSummary` — Amazon's own sentiment per aspect, with the quoted reviews behind it |
| **Supplier and brand audits** | `seller` with business name, registered address and per-period ratings |
| **Catalogue & feed building** | `attributes`, `productOverview`, `features`, `galleryThumbnails`, `highResolutionImages` |
| **Availability & logistics** | `inStock`, `inStockText`, `delivery`, `fastestDelivery` for any postcode |

***

### How to use it

1. Paste one or more Amazon URLs into **Start URLs**.
2. Set **Max results per start URL**.
3. Run it. Each product becomes one dataset row.

Three kinds of URL work:

| URL shape | Example |
|---|---|
| Search | `https://www.amazon.com/s?k=keyboard` |
| Category | `https://www.amazon.com/s?i=electronics&bbn=16225007011&rh=n%3A16225007011` |
| Product | `https://www.amazon.com/dp/B09X7MPX8L` |

#### Amazon marketplaces supported

`.com` · `.co.uk` · `.de` · `.fr` · `.it` · `.es` · `.nl` · `.se` · `.pl` · `.com.be` · `.ie` · `.com.tr` · `.ae` · `.sa` · `.eg` · `.in` · `.sg` · `.co.jp` · `.com.au` · `.ca` · `.com.mx` · `.com.br` · `.cl` · `.co.za`

Every one of those 24 was checked on a live run: the right currency, the marketplace's own language, its country in `loadedCountryCode`, and a localised delivery address. Each page is pinned to its marketplace's language and currency by cookie, so a German product reads in German and euros whatever country the proxy exits from, and the proxy country follows each URL automatically.

`amazon.cn` is not supported — Amazon closed its China marketplace in 2019 and the domain no longer carries a product catalogue.

***

### Output

One row per product. Abbreviated — the full record carries 55 fields:

```json
{
    "title": "AULA F75 Pro Wireless Mechanical Keyboard",
    "url": "https://www.amazon.com/dp/B0D14N2QZF",
    "asin": "B0D14N2QZF",
    "brand": "AULA",
    "price": { "value": 68.99, "currency": "$" },
    "listPrice": { "value": 79.99, "currency": "$" },
    "inStock": true,
    "inStockText": "In Stock Only 2 left in stock - order soon.",
    "stars": 4.4,
    "starsBreakdown": { "5star": 0.75, "4star": 0.12, "3star": 0.05, "2star": 0.02, "1star": 0.06 },
    "reviewsCount": 111682,
    "monthlyPurchaseVolume": "5K+ bought in past month",
    "breadCrumbs": "Video Games > PC > Accessories > Gaming Keyboards",
    "bestsellerRanks": [
        { "rank": 56, "category": "Video Games", "url": "https://www.amazon.com/gp/bestsellers/videogames/ref=pd_zg_ts_videogames" }
    ],
    "galleryThumbnails": ["https://m.media-amazon.com/images/I/31kI-vgQwYL._AC_US.jpg"],
    "highResolutionImages": ["https://m.media-amazon.com/images/I/61a14rKCeCL._AC_SL1500_.jpg"],
    "videosCount": 16,
    "variantAsins": ["B0D83DMWFC", "B0DS7JXKYD"],
    "variantDetails": [
        { "asin": "B0D83DMWFC", "name": "F75 Pro-Gradient Purple", "price": { "value": 69.99, "currency": "$" } }
    ],
    "variantAttributes": [{ "key": "Color", "value": "F75 Pro-Black" }],
    "attributes": [{ "key": "Connectivity Technology", "value": "Bluetooth, USB" }],
    "productOverview": [{ "key": "Brand", "value": "AULA" }],
    "aiReviewsSummary": {
        "text": "Customers find the keyboard to be of good quality…",
        "keywords": [
            {
                "name": "Quality",
                "sentiment": "positive",
                "text": "Customers find it well built.",
                "customersMentionedCount": { "total": 412, "positive": 353, "negative": 59 },
                "partialReviews": [{ "text": "great keyboard except for the gaps", "highlightedPart": "great keyboard" }]
            }
        ]
    },
    "seller": {
        "id": "A9TV4QL8DFMM5",
        "name": "AULA MALL",
        "businessName": "Shenzhen Suoai Electronics Technology co.,Ltd",
        "address": ["518103", "CN"],
        "ratingLifetime": { "starsOutOf5": 4.9, "ratingCount": 1626, "percentage5Star": 93 }
    },
    "offers": [
        { "position": 1, "isPinnedOffer": true, "condition": "New", "price": { "value": 68.99, "currency": "$" }, "shipsFrom": "Amazon" }
    ],
    "aPlusContent": { "title": "From the manufacturer", "rawText": "…", "modules": [] },
    "brandStory": { "title": "From the brand", "image": { "name": "BS", "url": "…" }, "items": [] },
    "delivery": "Tuesday, November 17",
    "fastestDelivery": "Tomorrow, November 13",
    "locationText": "Deliver to New York 10001",
    "loadedCountryCode": "US",
    "categoryPageData": { "pageNumber": 1, "productPosition": 3, "isSponsored": false },
    "input": "https://www.amazon.com/s?k=keyboard"
}
```

Fields Amazon does not render for a product come back as `null`, never missing, so the shape stays stable across marketplaces and categories. Book, grocery and apparel fields (`author`, `bookDescription`, `condition`, `support`, `manufacturerAttributes`, `priceRange`, `importantInformation`, `sustainabilityFeatures`) fill in on the categories that have them.

***

### Input

| Field | Type | Default | Purpose |
|---|---|---|---|
| `categoryOrProductUrls` | array | — | **Required.** Search, category or product URLs. |
| `maxItemsPerStartUrl` | integer | `100` | Result cap, per start URL. |
| `maxSearchPagesPerStartUrl` | integer | `9999` | Page cap, per start URL. |
| `scrapeProductDetails` | boolean | `true` | Off = grid data only. Far faster and far cheaper. |
| `maxOffers` | integer | `0` | Offers per product. See the note below. |
| `scrapeSellers` | boolean | `false` | Merchant profiles: business name, registered address, storefront, ratings per period. |
| `maxProductVariantsAsSeparateResults` | integer | `0` | Emit variants as their own rows, each a full record. |
| `scrapeProductVariantPrices` | boolean | `false` | Price every variant. |
| `language` | string | — | Amazon UI language; overrides the marketplace default. |
| `proxyCountry` | string | auto | Follows the URL's marketplace unless you set it. |
| `countryCode` / `zipCode` | string | — | Delivery location. Prices, stock and delivery dates follow it. |
| `locationDeliverableRoutes` | array | all | Which page types the delivery location applies to. |
| `proxyConfiguration` | object | Apify proxy | Standard Apify proxy settings. |
| `useCaptchaSolver` | boolean | `false` | Accepted, deliberately not implemented — see below. |

#### Delivery location

Amazon prices and stocks differently by address. Set `zipCode` (and `countryCode`) and the scraper performs the same address change the site's own location widget does, once per session:

```
zipCode: "10001"  →  locationText: "Deliver to New York 10001"
                     fastestDelivery: "Today 7 PM - 11 PM"
```

#### What `maxOffers` returns today

The featured offer — the buy box — is built from the product page itself, so `maxOffers: 1` costs no extra request. Offers beyond it live in a panel Amazon now loads from an endpoint that answers 404 to a direct request; nine URL shapes were tried with the page's own headers and session cookies. Until that is solved, a product with several sellers returns the featured offer only. This is stated here rather than discovered after a run.

#### Why `useCaptchaSolver` does nothing

Amazon's own documentation for this option notes it works only on `.com`, and that solving a captcha makes Amazon stop rendering `attributes`, `manufacturerAttributes` and `bestsellerRanks`. Requests here start on datacenter proxies and only a retry goes through residential, which brought the captcha rate on a 50-product crawl to zero. The option would buy nothing and cost three fields.

***

### Speed and cost

Measured on 50-product crawls of `amazon.com`:

| Proxy strategy | Time | Captchas | Platform cost / 1,000 products |
|---|---|---|---|
| Datacenter only | 110 s | 29% of requests | $0.36 |
| Residential only | 48 s | none | $3.24 |
| **Datacenter first, residential on retry — the default** | **55 s** | **none** | **$0.68** |

The cheapest lever is **`scrapeProductDetails: false`**. A search page yields 16–48 products in one request, so the grid fields — title, ASIN, price, rating, review count, thumbnail, position — cost a fraction of a request each. Leaving details on costs one request per product.

`scrapeSellers`, `scrapeProductVariantPrices` and `maxProductVariantsAsSeparateResults` each add requests per product, which is why all three are off by default.

#### What you pay for

Charging is per unit of work, so you pay for what a run actually did and nothing is bundled into a price you cannot opt out of:

| You are charged for | When |
|---|---|
| **A product scraped** | One full 55-field record from a detail page |
| **A product from a listing** | One grid row, when `scrapeProductDetails` is off — a fraction of the above |
| **A seller profile** | Only with `scrapeSellers`, and once per seller however many of their products appear |
| **A variant priced** | Only with `scrapeProductVariantPrices`, once per variant |
| **A page rendered in a browser** | Only on the marketplaces that need it, and the session is reused so later runs rarely do |

Error rows are never charged. Current prices are on the Actor's page above.

***

### Error rows

An input that cannot be scraped produces an error row rather than vanishing, so you can reconcile inputs against outputs. Normal rows never carry an `error` field.

```json
{
    "error": "product_not_found",
    "errorDescription": "Loaded a 404 page. The product does not exist.",
    "input": "https://www.amazon.com/dp/B0XXXXXXXX",
    "url": "https://www.amazon.com/dp/B0XXXXXXXX"
}
```

| `error` | Meaning |
|---|---|
| `invalid_url` | A start URL was malformed or not recognised |
| `invalid_input` | Bad configuration; the run is terminated too |
| `product_not_found` | Product URL returned 404, or could not be retrieved |
| `shortened_url_invalid` | An Amazon short link could not be resolved |
| `bestsellers_category_not_found` | Bestsellers category page not found |
| `no_relevant_reviews_found` | Reviews exist but none match the filters |
| `no_results_found` | The input returned no results, or could not be retrieved |

A page that could not be retrieved keeps the code matching its page type and explains itself in `errorDescription`, so it is never mistaken for a verdict about the product.

***

### Accuracy notes

- Price can be missing when no seller ships to the delivery country; setting `proxyCountry` usually fixes it.
- Amazon prices differ by US state and by proxy location. Two runs minutes apart from different exits will differ on `price`, `delivery`, `fastestDelivery` and `locationText`. That is Amazon, not the scraper.
- Amazon caps some search terms at **7 pages**. To go deeper, combine a category with the term rather than searching alone — instead of `Diamond rings`, open the `Jewelry` category and add the term.
- Result counts fluctuate run to run; Amazon applies its own internal caps. Run a small test scrape to size your use case.

***

### Integrations

Results land in an Apify dataset, so they can be pulled as JSON, CSV, Excel or XML over the API, or pushed straight into **n8n, Make, Zapier, Airbyte, Google Sheets, Google Drive, Slack, GitHub** and anything else that speaks webhooks.

### Is scraping Amazon legal?

Scraping publicly available data such as product titles, descriptions, prices and ratings is legal. This Actor collects no personal data and requires no login. If you plan to republish what you collect, check the copyright position for your jurisdiction.

***

### FAQ

**Is there a free Amazon scraper?**
Apify's free tier covers a trial run, so you can test this one before paying anything. Beyond that you pay per product scraped — the price is on the Actor page above, and error rows are never charged.

**Can I use it from Python?**
Yes. Start a run with the `apify-client` package for Python or JavaScript, or with a plain HTTP POST to the Apify API, then read the dataset as JSON or CSV. Nothing here is tied to a language.

**Is this the Amazon Product Advertising API?**
No, and it needs no key for it. It reads the same public pages a browser does, so it returns fields the official API does not expose — bestseller ranks, the AI review summary, per-variant prices and seller business details.

**Does it work on `amazon.co.uk`, `amazon.de`, `amazon.in`?**
Yes, and on 21 more. Each marketplace returns its own language, currency and delivery dates. The list is above.

**Can it scrape a whole category?**
Yes. Give it the category URL and raise `maxItemsPerStartUrl`. Amazon's own 7-page cap applies to bare search terms, not to categories.

**Can I get prices for a specific city or postcode?**
Yes — set `zipCode`. Prices, availability and delivery dates are then the ones that address sees.

**Does it need a browser?**
Only two marketplaces need one. `amazon.fr` and `amazon.in` answer a plain request with a JavaScript challenge, so those are rendered, and the session that establishes is reused afterwards — later runs reach both over plain HTTP and no browser starts. Everything else is plain HTTP, which is why it is cheap.

**How fresh is the data?**
It is read from Amazon at the moment of the run. Nothing is cached.

**Can I scrape reviews?**
Review *insights* are included — `aiReviewsSummary` carries Amazon's own per-aspect sentiment, mention counts and the quoted reviews behind each aspect, plus `starsBreakdown` and `reviewsLink`. Full review-by-review scraping is not in scope.

***

### Development

```bash
npm install
npm test
```

Runs on `CheerioCrawler` — plain HTTP plus gzip. Amazon's product markup is server-rendered, so for all but two marketplaces a headless browser would add cost without adding data. A Playwright pass handles the rest, and only the requests that failed without it.

# Actor input Schema

## `categoryOrProductUrls` (type: `array`):

Use a link to the Amazon category you want to scrape, e.g. video games - https://www.amazon.com/s?bbn=16225016011\&rh=n%3A20972781011, https://www.amazon.com/dp/B0B3BVWJ6Y.
You can also filter within the category with almost any filter available, i.e. price, manufacturer, rating, etc.
By using a different URL you can also choose a different Amazon country, e.g. Germany: https://www.amazon.de/. You don't need to set a proxy country to do that.

## `maxItemsPerStartUrl` (type: `integer`):

Enter the maximum number of results you want to scrape per each star URL. This will let the scraper know when to stop.

## `language` (type: `string`):

Language to use on Amazon.

**Disclaimer**: each Amazon domain has a different set of supported languages. If you choose a language that is not supported by the domain, the scraper will use the default language of the domain.

## `proxyCountry` (type: `string`):

You can set proxy country to **avoid geo-blocking** and **access region-specific content**. Amazon shows you the products that can be shipped to your address based on the proxy you use.

*By default*, the scraper **automatically selects** the **proxy country** based on the used Amazon website domain, ensuring low blocking rates and results relevant to the base domain.

## `maxSearchPagesPerStartUrl` (type: `integer`):

Enter the maximum number of search pages to scrape for each start URL. E.g. only scrape the first 5 pages.

This field can also be used with the `maxItemsPerStartUrl` option, the scraper will stop after either one of these limits is reached.

## `maxProductVariantsAsSeparateResults` (type: `integer`):

Enter the maximum number of product variants you want to scrape per each product, outputted as separate results.

**Please beware** that **you can already get** most of the **variant details** changes, in the **`variantDetails` field**, which is outputted by default.

Note that this **will increase the number of requests** and **extend the scraping time**.

## `maxOffers` (type: `integer`):

Enter the maximum number of offers you want to scrape per each product. This will let the scraper know when to stop.

Note that this **will increase the number of requests** and **extend the scraping time**.

## `scrapeSellers` (type: `boolean`):

Enable this option to extract further information about sellers of the product. Scrapes the featured offer seller (main seller).

This option goes hand in hand with the `maxOffers` option bby scraping the seller of each offer. If you set `maxOffers` to 0, only the featured offer seller will be scraped.

Note that this **will increase the number of requests** and **extend the scraping time**.

## `useCaptchaSolver` (type: `boolean`):

If enabled the scraper will automatically solve captchas thrown by Amazon. This will decrease the amount of request retries and increase the speed of the scraper.<br><br>***IMPORTANT*** - This option works well only for the `'.com'` Amazon domain, but even for that one Amazon doesn't show a few product fields after solving a captcha (specifically: 'attributes', 'manufacturer attributes', and 'bestseller ranks')

## `scrapeProductVariantPrices` (type: `boolean`):

Enable this option to extract prices of different variations of a product. Useful when you need prices for each variant.

Note that this **will increase the number of requests** and **extend the scraping time**.

## `scrapeProductDetails` (type: `boolean`):

If enabled, the scraper will extract each found product from the category page in detail (this is the default behavior).

If disabled, the scraper will only extract the quick product information from the category page. Useful for faster and more lightweight searches for products.

## `countryCode` (type: `string`):

The country code to use as the delivery location.

## `zipCode` (type: `string`):

The zip code to use as the delivery location. This is useful for more precise location settings, especially in larger countries.

## `locationDeliverableRoutes` (type: `array`):

The list of routes/page types, for which the deliverable location settings should be applied.

- This is useful for speeding up the scraping process by not applying the location settings to all pages, for which you don't need the localized data for.
- For example, you can set it to `['SEARCH', 'PRODUCT']` to apply the location settings only to search and product pages.
- By default, all pages are included.

## `proxyConfiguration` (type: `object`):

Proxy used for every request. Residential is the safe default; a datacenter group costs far less and is retried through residential when Amazon blocks it. The country follows each URL's marketplace unless you set one.

## Actor input object example

```json
{
  "categoryOrProductUrls": [
    {
      "url": "https://www.amazon.com/s?k=keyboard"
    }
  ],
  "maxItemsPerStartUrl": 100,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
  "maxSearchPagesPerStartUrl": 9999,
  "maxProductVariantsAsSeparateResults": 0,
  "maxOffers": 0,
  "scrapeSellers": false,
  "useCaptchaSolver": false,
  "scrapeProductVariantPrices": false,
  "scrapeProductDetails": true,
  "locationDeliverableRoutes": [
    "PRODUCT",
    "SEARCH",
    "OFFERS"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset with every product scraped by this run.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "categoryOrProductUrls": [
        {
            "url": "https://www.amazon.com/s?k=keyboard"
        }
    ],
    "maxItemsPerStartUrl": 100,
    "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
    "maxSearchPagesPerStartUrl": 9999,
    "maxProductVariantsAsSeparateResults": 0,
    "maxOffers": 0,
    "locationDeliverableRoutes": [
        "PRODUCT",
        "SEARCH",
        "OFFERS"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("molded_mountainpass/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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "categoryOrProductUrls": [{ "url": "https://www.amazon.com/s?k=keyboard" }],
    "maxItemsPerStartUrl": 100,
    "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
    "maxSearchPagesPerStartUrl": 9999,
    "maxProductVariantsAsSeparateResults": 0,
    "maxOffers": 0,
    "locationDeliverableRoutes": [
        "PRODUCT",
        "SEARCH",
        "OFFERS",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("molded_mountainpass/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 '{
  "categoryOrProductUrls": [
    {
      "url": "https://www.amazon.com/s?k=keyboard"
    }
  ],
  "maxItemsPerStartUrl": 100,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
  "maxSearchPagesPerStartUrl": 9999,
  "maxProductVariantsAsSeparateResults": 0,
  "maxOffers": 0,
  "locationDeliverableRoutes": [
    "PRODUCT",
    "SEARCH",
    "OFFERS"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call molded_mountainpass/amazon-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,molded_mountainpass/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 <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bEKhOosHBGElh1YFr/builds/798qB94lnNJDWnQ65/openapi.json
