# Americanas Brazil - Products, Prices, Sellers & Reviews (`abotapi/americanas-com-br-scraper`) Actor

Scrape Americanas Brazil (americanas.com.br) by keyword, department or pasted link. Returns SKU, title, brand, seller (store or marketplace), price, PIX price, discount, instalments in BRL, stock, images, variants, specs and reviews. Incremental mode tracks changes.

- **URL**: https://apify.com/abotapi/americanas-com-br-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 product results

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

## Americanas Brazil Marketplace Scraper

Scrape **americanas.com.br**, one of Brazil's largest general marketplaces and department
stores, and get one clean row per product: identity, seller, the full Brazilian price picture
(current price, pre-discount price, discount, PIX cash price and instalment terms in BRL),
stock, media, every colour / size / model variant, the description, the specification table,
the warranty, and customer reviews.

Two ways to say what you want, both returning as many results as you ask for:

- **Search** by keyword, department, brand, price band and seller.
- **URL** by pasting product pages, department pages or search pages straight from the store.

***

### What you get per product

| Group | Fields |
|---|---|
| Identity | `productId`, `skuId`, `name`, `brand`, `brandId`, `ean`, `referenceId`, `slug`, `url` |
| Category | `categories`, `breadcrumb`, `categoryPath`, `categoryName`, `department` |
| Seller | `sellerId`, `sellerName`, `sellerType` (`first_party` or `marketplace`), `sellerCount`, `otherSellers[]`, `sellerReputation` |
| Price | `price`, `listPrice`, `originalPrice`, `discountAmount`, `discountPercent`, `onSale`, `currency` (always `BRL`) |
| PIX cash price | `pixPrice`, `pixDiscountAmount`, `pixDiscountPercent` |
| Instalments | `maxInterestFreeInstallments`, `interestFreeInstallmentValue`, `maxInstallments`, `installmentPlans[]` (one row per payment method and instalment count, with the interest rate and total) |
| Stock | `inStock`, `availableQuantity`, `priceValidUntil` |
| Media | `image`, `images[]`, `videos[]` |
| Variants | `variants[]` (per SKU: `skuId`, `options` such as colour / size / voltage, `price`, `pixPrice`, `inStock`, `availableQuantity`, `sellerName`, `images`), `variantCount` |
| Detail | `description`, `shortDescription`, `specifications` (flat name to value), `specificationGroups[]`, `warranty`, `itemCondition`, `releaseDate` |
| Delivery (opt in) | `shippingCost`, `deliveryEstimate`, `pickupAvailable`, `delivery.options[]` |
| Reviews (opt in) | `rating`, `reviewCount`, `recommendedPercent`, `ratingBreakdown` (all five star buckets), `reviews[]` |
| Bookkeeping | `searchMode`, `scrapedAt`, and in incremental mode `changeType`, `changedFields`, `firstSeenAt`, `lastSeenAt` |

#### The description, specifications, variants, discount, PIX price and instalments are free

They arrive with the listing, so this actor returns them on **every** row without any extra
request and without any extra charge. Only two things cost an extra lookup per product, and both
are off by default:

- **Fetch delivery details** at a Brazilian postal code (CEP): shipping cost, delivery time
  and pickup availability. The default CEP is central Sao Paulo (`01310100`); replace it with
  your destination when you need destination-specific delivery results.
- **Fetch customer reviews**: ratings are looked up for a whole result page in one go at no
  per-product cost, and only a product that actually has reviews costs a request of its own.

A product that receives at least one of those lookups is billed a single **Detail enrichment**
event. A catalogue-only row is never billed one.

***

### Brazil only, so there is no country input

Americanas is a Brazilian retailer serving Brazil, and this was verified live rather than
assumed. Four independent signals, all observed on the live site:

1. The storefront declares itself Brazilian: `lang="pt-BR"` and `locale: "pt-BR"`.
2. Every price on every route is in Brazilian reais, and there is no currency or market
   parameter that changes it.
3. The store's own delivery quote replies `shipsTo: ["BRA"]` for its products.
4. Asking for a delivery quote to a United States address returns zero delivery options and
   the store's own error, "this item cannot be delivered to the selected coordinates".

A `country` input would therefore be a knob with exactly one working value, so there is none.
Use a Brazilian CEP for the delivery lookup.

***

### Marketplace or the store's own stock

Americanas sells its own stock next to thousands of marketplace sellers, and the two behave
very differently on price, delivery and returns. Every row says which it is:

- `sellerType: "first_party"` means Americanas itself is the seller.
- `sellerType: "marketplace"` means an independent seller on the Americanas marketplace, named
  in `sellerName`.
- `otherSellers[]` lists every other offer on the same SKU, with its own price and stock, so
  you can compare the winning offer against the rest.

The **Sold by** filter can narrow to either side. "Store itself only" is applied by the store
as a native filter. "Marketplace sellers only" is applied to the results, because the store
publishes no filter that excludes its own stock.

`sellerReputation` is always `null`. The store publishes no seller rating or reputation score
anywhere in its catalogue, product or checkout data. The field is emitted as an explicit null
so the gap is visible rather than looking like a dropped field.

***

### Reviews

Reviews are a real, fully available feature on this store, verified live on reviewed products.
Turn on **Fetch customer reviews** to get:

- `rating`, `reviewCount`, `recommendedPercent`;
- `ratingBreakdown`, always all five star buckets, so a bucket with no reviews reads `0`
  rather than going missing;
- `reviews[]` with `author`, `date`, `rating`, `title`, `text`, `verifiedPurchase`,
  `recommended`, `helpfulCount`, `unhelpfulCount` and `images[]`.

A product with no reviews returns `reviews: []`, `reviewsAvailable: false` and a `reviewCount`
of `0` rather than invented values, and costs no extra request. Use **Max reviews per product**
to cap the rows; the rating, count and breakdown stay complete regardless of that cap.

***

### Which filters the store applies, and which this actor applies

Applied by the store, so they narrow the result count at the source and cost nothing extra:

| Filter | How |
|---|---|
| Department | Resolved against the store's own published department list, then filtered at the source |
| Brand | Resolved against the store's own published brand list, then filtered at the source |
| Minimum / maximum price | The store's own price band |
| Sold by: store itself | The store's own seller filter |
| Sort by | All nine orderings are the store's own |

Two details worth knowing about those, both measured on the live store rather than assumed:

- **Picking several departments is a union, and it is walked one department at a time.** The
  store's catalogue route cannot combine two departments in a single request: asked for both, it
  silently answers with only one of them. So this actor walks each department you picked as its own
  pass and merges the results, sharing **Max products** across them. Brands do combine natively, so
  several brands stay a single request.
- **Price sorting is the store's own, and the store ranks a product by its cheapest variant.** A
  product sold in many variants can therefore appear earlier in a price sorted run than its headline
  `price` suggests, because `price` is the price of the variant the row describes. The full list is
  in `variants[]`.

Applied to the results, because the store publishes no filter for them:

| Filter | Why |
|---|---|
| Sold by: marketplace only | The store offers no way to exclude its own stock |
| Minimum interest free instalments | Not a published filter |
| Only products that can be ordered | The store returns sold out listings alongside available ones on this route |
| Only reduced price products | Not a published filter |

If a brand or department you asked for does not exist on the store, it is reported by name and
skipped. If **none** of them exist, the run stops with that message instead of quietly handing
back the unfiltered catalogue. If the store cannot be reached to check them at all, the run stops
and says so: an unanswered check is a connection problem, and it is never reported as "that
department does not exist".

#### A note on keywords

Some very common Portuguese keywords ("notebook", "cafeteira", "mouse") are configured on the
storefront to jump to a curated landing page instead of running a search. This actor reads the
catalogue directly and is not affected: a keyword search returns catalogue results for the
words you typed, every time.

***

### Modes

#### Search mode

Give one or more keywords, or leave keywords empty and pick a department to browse it whole.
Each keyword is searched separately, and **Max products** is shared across all of them.

#### URL mode

Paste any mix of:

- a product page, ending in `/p`;
- a department page, for example `/computadores-e-informatica/notebook`;
- a search page, for example `/busca/cafeteira`.

A link that already names a page (`?page=2`) starts there rather than restarting at page 1.
Pasted product links are always fetched first, so a large department can never fill your item
cap and drop the products you actually named. The filters above still narrow what a department
or search link returns.

***

### Input parameters

Every input the actor accepts, in the order the input form shows them. The three MCP connector
inputs are documented in their own section further down.

#### Start here: pick your mode

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` searches the catalogue by keyword and filters. `url` scrapes pasted links: product pages, department pages and search result pages are all accepted. |
| `queries` | array | (empty) | Search mode only. One or more keywords, for example `notebook dell`, `cafeteira` or `tenis nike`. Each keyword is searched separately and `maxItems` is shared across all of them. Leave empty to browse by department, brand or price alone. |
| `urls` | array | (empty) | URL mode only. Mix freely: product pages ending in `/p`, department pages such as `/computadores-e-informatica/notebook`, and search pages such as `/busca/notebook-dell`. A link that already names a page (`?page=2`) starts there. |

#### Filters (apply to a keyword search AND to a pasted department or search link)

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `categories` | array | (empty) | Keep only products in these store departments. Resolved against the store's own published department list and applied at the source. Selecting several returns products from any of them, walked one department at a time because the store cannot combine two in one request. |
| `brands` | array | (empty) | Keep only products from these brands, typed as the store writes them (`Lenovo`, `Samsung`). Accents and capitals do not matter. Resolved against the store's own brand list and applied at the source. A brand the store does not publish is reported by name and skipped; if none of your brands exist, the run stops rather than returning unfiltered results. |
| `sellerType` | string | `any` | `any`, `first_party` (store's own stock, applied by the store) or `marketplace` (independent sellers, applied to the results because the store publishes no filter that excludes its own stock). |
| `minPrice` | integer | (none) | Keep only products priced at or above this amount in BRL. Applied by the store. |
| `maxPrice` | integer | (none) | Keep only products priced at or below this amount in BRL. Applied by the store. |
| `minInterestFreeInstallments` | integer | `0` | Keep only products payable in at least this many interest free instalments (parcelas sem juros), 0 to 24. Applied to the results. `0` means no requirement. |
| `inStockOnly` | boolean | `false` | Keep only products the store will currently accept an order for. Applied to the results, because the store returns sold out listings alongside available ones. |
| `onSaleOnly` | boolean | `false` | Keep only products whose current price is below their advertised original price. Applied to the results. The PIX cash discount does not count here; it is returned separately in `pixPrice`. |
| `sortBy` | string | `relevance` | One of `relevance`, `price_asc`, `price_desc`, `best_selling`, `best_rated`, `newest`, `biggest_discount`, `name_asc`, `name_desc`. All nine are the store's own orderings, applied at the source. |

#### Output, limits and extra lookups

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `fetchDetails` | boolean | `false` | Read the delivery estimate, shipping cost and pickup availability for each product at the postal code below. One extra request per product, billed as one Detail enrichment event per product returned. |
| `deliveryPostalCode` | string | `01310100` | Destination for delivery enrichment. The default is central Sao Paulo; replace it with your own 8 digit Brazilian postal code (CEP) for destination-specific shipping cost and delivery time. |
| `fetchReviews` | boolean | `false` | Add each product's rating, review count, per star breakdown and individual reviews. Ratings are looked up for a whole result page in one request; only a product that actually has reviews costs a request of its own, and only those products are billed a Detail enrichment event. |
| `maxReviewsPerProduct` | integer | `20` | Cap on individual reviews returned per product. The rating, count and per star breakdown stay complete regardless. `0` returns all reviews a product has. |
| `maxItems` | integer | `20` | Maximum products returned across the whole run. `0` means unlimited. |
| `maxPages` | integer | `0` | Maximum result pages read per keyword, department or link. `0` means no limit, which is the default. |

#### Resume and recurring updates

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `resumeFromRunId` | string | (none) | Continue ONE interrupted run. Paste that run's id or dataset id and this run skips, and does not bill for, everything already collected there. |
| `incrementalMode` | boolean | `false` | Turn on for daily or recurring monitoring of the same search. The first run returns everything as `NEW`; later runs return only `NEW`, `UPDATED` and `REAPPEARED`. |
| `stateKey` | string | (none) | Incremental mode only. Name a monitoring campaign to keep its state stable, or to deliberately share state across runs. Left empty, the key is derived from the mode, keywords, links, filters and lookup settings, so two different setups never mix state. |
| `emitUnchanged` | boolean | `false` | Incremental mode only. Also return products that have not changed, marked `UNCHANGED`. This returns, and bills, extra rows. |
| `emitExpired` | boolean | `false` | Incremental mode only. Also return products that were present before and are no longer found, marked `EXPIRED`. Only produced after a complete scan, so never when `maxItems` capped the run or `resumeFromRunId` was used. This returns, and bills, extra rows. |

#### Connection

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `proxy` | object | Apify Proxy, standard pool | The standard pool is the default and is sufficient for this store. A residential pool is available but is not needed here. |

***

### Recurring runs: resume and incremental mode

These are two different features and they solve two different problems.

**Resume from a previous run** continues ONE interrupted run. Paste that run's id or dataset
id and this run skips everything it already collected.

**Incremental mode** is for a schedule. Run the same search daily and get only what changed.
The first run returns everything as `NEW`; later runs return `NEW`, `UPDATED` and `REAPPEARED`,
with `changedFields` naming exactly what moved. `UNCHANGED` rows are suppressed (and not
billed) unless you ask for them. `EXPIRED` rows are only produced once a run has fully scanned
the tracked search, so a run capped by **Max products**, a resumed run, or a run that collected
nothing can never wrongly tombstone live products.

State is kept per search, so two different keyword or filter setups never mix. Use **State key**
to name a campaign, or to deliberately share state between runs.

Four fields are deliberately left out of change detection and are never named in
`changedFields`:

- `scrapedAt` and `priceValidUntil` are clocks. The store stamps `priceValidUntil` about a year
  ahead of the request itself, so it moves on every fetch.
- the nested `delivery` object carries absolute estimated dates that roll forward daily. The
  two values derived from it, `shippingCost` and `deliveryEstimate`, ARE tracked, so a genuine
  shipping change is still detected.
- `reviews`, `installmentPlans` and `specificationGroups` are bulky. A change in any of them is
  still detected through `reviewCount`, `rating`, `ratingBreakdown`,
  `maxInterestFreeInstallments`, `interestFreeInstallmentValue`, `maxInstallments` and
  `specifications`, all of which are tracked.

***

### Cost and limits

- **Max products** defaults to 20 so a first run cannot surprise you. Set it to 0 for no limit.
- **Max result pages** defaults to 0, meaning unlimited: a run stops at your item cap, at the
  end of the results, or when there is nothing new left to return.
- The store answers over the standard connection pool, which every Apify plan includes. That is
  the default and it is the cheapest option. A residential pool is available if you want one,
  but this store does not need it.
- A run that could not read any result page fails loudly with the reason. It never reports
  "succeeded, 0 items" when the real problem was a connection.

***

### Example row (abridged, values illustrative)

```json
{
  "productId": "8365907",
  "skuId": "8844834",
  "name": "Notebook Lenovo IdeaPad Slim 3 Intel Core 3 100U 8GB RAM SSD 256GB 15.3\" Full HD Windows 11",
  "brand": "Lenovo",
  "url": "https://www.americanas.com.br/notebook-lenovo-ideapad-slim-3-.../p",
  "department": "Computadores e Informática",
  "categoryPath": "Computadores e Informática > Notebook",
  "sellerId": "1",
  "sellerName": "AMERICANAS SA",
  "sellerType": "first_party",
  "sellerReputation": null,
  "currency": "BRL",
  "price": 3998.95,
  "originalPrice": 3998.95,
  "discountPercent": null,
  "onSale": false,
  "pixPrice": 3799.0,
  "pixDiscountPercent": 5.0,
  "maxInterestFreeInstallments": 8,
  "maxInstallments": 12,
  "inStock": true,
  "warranty": "12",
  "itemCondition": "Novo",
  "variantCount": 1,
  "rating": 5.0,
  "reviewCount": 2,
  "ratingBreakdown": { "1": 0, "2": 0, "3": 0, "4": 0, "5": 2 },
  "shippingCost": 12.9,
  "deliveryEstimate": "0bd",
  "pickupAvailable": true,
  "searchMode": "search",
  "scrapedAt": "2026-08-27T13:00:00Z"
}
```

***

### Send results into your apps (MCP connectors)

Optionally pipe results into Notion, Linear, Airtable or Apify through a Model Context Protocol
(MCP) connector. Authorize one under Apify, Settings, API and Integrations, then pick it in the
input. Notion gets a page per item; the other connectors get a best effort write or digest. This
is a delivery step after the scrape: the export never changes the dataset, and a connector that
cannot be reached never breaks the run.

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mcpConnectors` | array | (empty) | Which authorized MCP connectors to send results to. Authorize one under Apify, Settings, API and Integrations, then select it here. Leave empty to skip. |
| `notionParentPageUrl` | string | (empty) | Notion connector only. URL or id of the Notion page under which item pages are created. Ignored by the other connectors. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run (1 to 1000). Does not affect the dataset. |

# Actor input Schema

## `mode` (type: `string`):

Choose 'search' to search the catalogue by keyword and filters, or 'url' to scrape pasted links: product pages, department pages and search result pages are all accepted.

## `queries` (type: `array`):

Only used when mode = search, ignored in url mode. One or more keywords, for example 'notebook dell', 'cafeteira' or 'tenis nike'. Leave empty to browse by Department, Brand or price alone.

## `urls` (type: `array`):

Only used when mode = url, ignored in search mode. Mix freely: product pages ending in /p , department pages such as /computadores-e-informatica/notebook , and search pages such as /busca/notebook-dell .

## `categories` (type: `array`):

Optional. Keep only products in these store departments. Combine with a keyword, or use on its own to browse a whole department. Selecting several returns products from any of them. For a narrower category (for example Notebook inside Computers), paste that category page into url mode instead.

## `brands` (type: `array`):

Optional. Keep only products from these brands, typed as the store writes them, for example 'Lenovo' or 'Samsung'. Accents and capitals do not matter. Selecting several returns products from any of them. A brand the store does not publish is reported by name and skipped; if none of your brands exist, the run stops instead of quietly returning unfiltered results.

## `sellerType` (type: `string`):

Optional. Americanas sells its own stock alongside marketplace sellers. 'Store itself' is applied by the store as a native filter. 'Marketplace sellers only' is applied to the results, because the store publishes no filter that excludes its own stock.

## `minPrice` (type: `integer`):

Optional. Keep only products priced at or above this amount, in Brazilian reais. Applied by the store itself, so it narrows the result count at the source.

## `maxPrice` (type: `integer`):

Optional. Keep only products priced at or below this amount, in Brazilian reais. Applied by the store itself, so it narrows the result count at the source.

## `minInterestFreeInstallments` (type: `integer`):

Optional. Keep only products that can be paid in at least this many interest free credit card instalments (parcelas sem juros). Applied to the results, because the store publishes no instalment filter. Use 0 for no instalment requirement.

## `inStockOnly` (type: `boolean`):

Optional. Keep only products the store will currently accept an order for. Applied to the results, because the store returns sold out listings alongside available ones on this route.

## `onSaleOnly` (type: `boolean`):

Optional. Keep only products whose current price is below their advertised original price. Applied to the results. Note that the PIX cash discount is not a price reduction and does not count here; it is returned separately in pixPrice.

## `sortBy` (type: `string`):

The order the store returns results in. All nine are the store's own orderings, applied at the source.

## `fetchDetails` (type: `boolean`):

Read the delivery estimate, shipping cost and pickup availability for each product at the postal code below. One extra request per product, billed as one Detail enrichment event per product returned.

## `deliveryPostalCode` (type: `string`):

Used when Fetch delivery details is on. Defaults to central Sao Paulo (01310100) so the default enriched run works; replace it with your own 8 digit Brazilian CEP for destination-specific shipping cost and delivery time.

## `fetchReviews` (type: `boolean`):

Add each product's rating, review count, per star breakdown and individual reviews (author, date, rating, text, verified purchase, helpful count and any photos). Ratings are looked up for a whole page at once at no per-product cost; only a product that actually has reviews costs an extra request, and only those products are billed a Detail enrichment event. A product with no reviews returns an empty reviews list.

## `maxReviewsPerProduct` (type: `integer`):

Cap on how many individual reviews are returned per product. The rating, review count and per star breakdown are always complete regardless of this cap. Use 0 for all reviews a product has.

## `maxItems` (type: `integer`):

Maximum number of products to return across the whole run. This is the run's cap. Use 0 for unlimited.

## `maxPages` (type: `integer`):

Maximum number of result pages read per keyword, department or link. 0 means no limit, which is the default: the run then stops only at Max products, at the end of the results, or when a page returns nothing new.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large catalogue pull without returning or charging for products already collected there. Use this after an interrupted run. For recurring daily monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns every matching product as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED products. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed). State is kept separately for each search, filter and lookup setup; use State key to name or deliberately share a monitoring campaign. To continue one specific interrupted run instead, use Resume from a previous run above.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the search, filters and lookup settings, so different searches never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return products that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have, so leave it off unless you want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return products that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search, so never when Max products capped it or when Resume was used. This returns, and bills, extra synthetic rows, so leave it off unless you need expiry tracking.

## `proxy` (type: `object`):

Apify Proxy is recommended. The standard pool is the default and is sufficient for this store.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write or digest. Leave empty to skip; never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "notebook dell"
  ],
  "urls": [
    "https://www.americanas.com.br/computadores-e-informatica/notebook",
    "https://www.americanas.com.br/busca/cafeteira"
  ],
  "sellerType": "any",
  "minInterestFreeInstallments": 0,
  "inStockOnly": false,
  "onSaleOnly": false,
  "sortBy": "relevance",
  "fetchDetails": false,
  "deliveryPostalCode": "01310100",
  "fetchReviews": false,
  "maxReviewsPerProduct": 20,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "mode": "search",
    "queries": [
        "notebook dell"
    ],
    "urls": [
        "https://www.americanas.com.br/computadores-e-informatica/notebook",
        "https://www.americanas.com.br/busca/cafeteira"
    ],
    "deliveryPostalCode": "01310100",
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/americanas-com-br-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 = {
    "mode": "search",
    "queries": ["notebook dell"],
    "urls": [
        "https://www.americanas.com.br/computadores-e-informatica/notebook",
        "https://www.americanas.com.br/busca/cafeteira",
    ],
    "deliveryPostalCode": "01310100",
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/americanas-com-br-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 '{
  "mode": "search",
  "queries": [
    "notebook dell"
  ],
  "urls": [
    "https://www.americanas.com.br/computadores-e-informatica/notebook",
    "https://www.americanas.com.br/busca/cafeteira"
  ],
  "deliveryPostalCode": "01310100",
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/americanas-com-br-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/americanas-com-br-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/zyCgf9u9In5L5ZfC5/builds/spDivFaw8ldOQjwc6/openapi.json