# Falabella Scraper - Products, Prices, Sellers & Reviews (`abotapi/falabella-marketplace-scraper`) Actor

Scrape Falabella, Latin America's leading retail marketplace: products with local prices, discounts, ratings and seller info across the Chile, Colombia and Peru storefronts. Search keywords or paste links, and monitor price changes with recurring updates.

- **URL**: https://apify.com/abotapi/falabella-marketplace-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 96.7% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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?

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

## Falabella Marketplace Scraper: Products, Prices & Sellers

Falabella Marketplace Scraper turns Falabella (falabella.com) into a clean product data feed. One actor covers three country storefronts: Chile, Colombia and Peru, each its own catalogue with its own currency. Run keyword searches or paste your own product and listing links, get price, discount, rating and seller data on every row, add full product detail reads on demand, then export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **Three storefronts in one actor.** Chile, Colombia and Peru, each with its own catalogue, currency and connection.
- **Two ways in.** Run keyword searches on one storefront, or paste your own links: product pages, category pages, keyword collections, brand pages or search result pages.
- **Full listing data on every row.** Price, was-price, discount, rating, review count, seller and the card's own badges (official seller, sponsored, best seller, installments, shipping flags).
- **Optional detail reads.** Switch on the description, full specification table, category path, stock state, loyalty points, warranty code and the seller's registered business details, only when you need them.
- **Built for monitoring.** Recurring updates label every record NEW, UPDATED, REAPPEARED or EXPIRED, so a scheduled run returns only what changed.
- **Resume support.** Continue an interrupted run from its run id without paying for the same rows twice.
- **A refused run fails loudly.** A run that is refused everywhere stops with a clear message; a genuinely empty search still succeeds, with zero rows and a visible note.

### Use Cases

- **Price monitoring teams:** track price and discount changes on a set of products or categories over time, with recurring updates flagging exactly what moved.
- **Marketplace analysts:** compare the same categories and keywords across the Chilean, Colombian and Peruvian storefronts.
- **Brand and seller managers:** watch a competitor's catalogue, ratings and seller badges across all three markets.
- **Deal and content sites:** surface discounted, sponsored and best-seller items by category or keyword for a feed or newsletter.
- **Data teams:** assemble structured product catalogues (price, brand, ratings, specifications) for pricing or demand models.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `recordType` | `"product"` |
| `id` | `"300000001"` |
| `skuId` | `"300000002"` |
| `name` | `"Mochila de muestra"` |
| `brand` | `"MARCA MUESTRA"` |
| `url` | Link to the product page |
| `imageUrl` | Main product image |
| `currency` | `"CLP"` (also `"COP"`, `"PEN"` by market) |
| `price` / `priceDisplay` | `22990.0` / `"$ 22.990"` |
| `oldPrice` / `discountPercent` | `27990.0` / `18` |
| `ratingAverage` / `ratingCount` | `4.6` / `128` |
| `sellerId` / `sellerName` | `"S00042"` / `"Tienda de muestra"` |
| `officialSeller` / `sponsored` / `bestSeller` | `true` / `false` / `true` (card badges) |
| `installments` | Interest-free installment offers shown on the card (`null` when none) |
| `shippingOptions` | Shipping flags the card shows, for example home delivery |
| `market` / `marketHost` | `"CL"` / `"www.falabella.com"` |
| `description` / `longDescription` | Short and extended product text (detail reads) |
| `specifications` | Named attribute list, for example color and material (detail reads) |
| `categories` | Category path from the breadcrumb (detail reads) |
| `outOfStock` / `stockUnits` | Stock state and per-variant counts (detail reads) |
| `sellerDetails` / `sellerVerified` | Seller's registered business name, id and verification flag (detail reads) |
| `cmrPoints` / `warrantyId` | Loyalty points and warranty code (detail reads) |
| `changeType` / `changedFields` | `"NEW"` / list of field names that moved (recurring updates) |
| `firstSeenAt` / `lastSeenAt` | First and most recent sighting (recurring updates) |

Every row also carries the search or link it came from and its position in that walk (`sourceType`, `sourceId`, `sourceUrl`, `position`), when it was read (`scrapedAt`), and, on detail reads, the full list of extra product images (`images`).

### How to Use

1. Pick a **mode**: keyword search on one storefront, or your own product and listing links.
2. Choose the **market** for a search, or paste **links**. Each pasted link is read, labelled (country, currency, market host) and connected through the country of its own storefront, so Chile and Colombia links can share one run; the Market setting only applies to keyword searches. If you leave the links untouched in links mode, the run scrapes one example of each supported link shape (see the table below).
3. Turn on **detail reads** if you need the description, specifications, stock and seller details; leave it off for a cheaper run. Pasted product links are always read from their own product page, so they always carry the detail surcharge.
4. Set **Max records** to control run size and cost, then click **Start**.

**Minimal keyword search:**

```json
{
  "mode": "search",
  "market": "cl",
  "queries": ["mochila"],
  "maxItems": 20
}
```

**Ordered search with detail reads:**

```json
{
  "mode": "search",
  "market": "co",
  "queries": ["zapatillas"],
  "sort": "price-asc",
  "fetchDetails": true,
  "maxItems": 50
}
```

**Your own links:**

```json
{
  "mode": "urls",
  "urls": ["https://www.falabella.com/falabella-cl/product/300000001/producto-de-muestra"],
  "maxItems": 10
}
```

#### Supported link shapes

| Link shape | Example | Notes |
|---|---|---|
| Category page | `https://www.falabella.com/falabella-cl/category/CATG10137/Zapateros-y-Organizadores-de-Zapatos` | Walked forward from page 1 |
| Category page, paginated | `.../Zapateros-y-Organizadores-de-Zapatos?page=2` | The walk starts at the page in the link |
| Keyword search with ordering | `https://www.falabella.com/falabella-cl/search?Ntt=zapatilla&sortBy=derived.price.search%2Casc` | The pasted ordering is kept |
| Keyword search, Colombia | `https://www.falabella.com.co/falabella-co/search?Ntt=televisor` | Labelled COP, connected through Colombia |
| Keyword collection | `https://www.falabella.com/falabella-cl/collection/iphone-15` | Walked forward |
| Search that the site redirects to a collection | `https://www.falabella.com/falabella-cl/search?Ntt=iphone` | The redirect is followed |
| Product page | `https://www.falabella.com/falabella-cl/product/<id>/<slug>` | Not verified: product pages are often answered with a verification page; the run logs a warning per link |
| Peru search | `https://www.falabella.com.pe/falabella-pe/search?Ntt=televisor` | Not verified; the run logs a warning per link |

In keyword search mode, `term` is accepted as an alias of `queries`.

**Daily price monitoring:**

```json
{
  "mode": "search",
  "market": "pe",
  "queries": ["camiseta"],
  "incrementalMode": true,
  "stateKey": "camiseta-daily",
  "maxItems": 200
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/falabella-marketplace-scraper").call(
    run_input={"mode": "search", "market": "cl", "queries": ["mochila"], "maxItems": 20}
)
for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product["name"], product["price"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/falabella-marketplace-scraper').call({
  mode: 'search', market: 'cl', queries: ['mochila'], maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Max records and max pages

Max records is the single cap that stops the whole run (`0` means no limit; the walk then runs to the catalogue's natural end). Max pages per source is a runaway guard, not a target: leave it `0` to read as deep as the source serves. Either way a single search or listing walk stops after at most 500 pages, and a walk stopped by that guard counts as incomplete. Multiple search terms and pasted links share the record cap, split proportionally across the remaining sources as the run progresses.

#### Resume and recurring updates

- **Resume** (`resumeFromRunId`) continues ONE interrupted run: paste its run id (or dataset id) and every record it already collected is skipped, so you don't pay twice.
- **Recurring updates** (`incrementalMode`) is for scheduled runs over the same setup. Each record is classified `NEW`, `UPDATED` (with `changedFields`), `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on), `REAPPEARED`, or `EXPIRED` (only after a run that scanned its whole configured scope end to end, and only with `emitExpired`). `stateKey` names or shares the stored baseline. With recurring updates off, output is exactly as before.
- Without a `stateKey`, the baseline follows the mode, market, search terms or links, sort and the detail-reads switch: changing any of them starts a fresh baseline, while Max records and Max pages do not. Giving two different setups the same `stateKey` makes them share one baseline, so each can mark the other's products `EXPIRED`.
- `EXPIRED` only fires after a scan the actor considers complete: a resumed run, a run stopped by Max records or the page guard, or a run where a source failed never produces it.
- If the storefront answers "page not found" for page 2 or later of a search or listing before the results it declared are all read, the actor logs a warning and treats that search as incomplete: the rows already read are returned, and no `EXPIRED` rows are produced for that run. (A "page not found" on page 1 is reported as a failed source and also blocks `EXPIRED`.)

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

Optionally pipe results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step after the scrape: the Apify dataset is never changed.

1. Authorize a connector once under **Apify, Settings, API & Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the `mcpConnectors` input field. Notion gets a rich page-per-item export; other connectors get a best-effort write or a digest.
3. For Notion, also set `notionParentPageUrl` to the page under which item pages should be created.

`maxNotifyListings` caps how many items are written to each connector per run; it does not affect the dataset. Leave `mcpConnectors` empty to skip this step entirely.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | Keyword search on one storefront, or your own product and listing links. |
| `market` | string | `cl` | Country storefront: Chile, Colombia or Peru. Searches run on it; in links mode it sets the connection country and the labels on listing-link rows, so match it to your links. |
| `queries` | array | (none) | Search terms for search mode, one entry per search (alias `term`); all searches share the record cap. |
| `sort` | string | `relevance` | Ordering per search: most relevant (`relevance`), lowest price (`price-asc`), highest price (`price-desc`), brand A to Z (`brand-asc`) or best rated (`rating-desc`). |
| `term` | string | | Alias of `queries` for a single keyword (used only when `queries` is empty). |
| `urls` | array | one example of each supported shape | Product or listing links for links mode. Each link is fetched, labelled and connected through its own storefront. |
| `fetchDetails` | boolean | `false` | Read each product's own page for description, specifications, stock and seller details (a per-product surcharge applies; pasted product links always carry it). |
| `maxItems` | integer | `20` | Stop after this many records across the whole run (`0` = no limit; the page guard still applies). |
| `maxPages` | integer | `0` | Runaway guard: upper bound on pages read for any single search or listing walk (`0` = as deep as the source serves, up to 500 pages). |
| `resumeFromRunId` | string | (none) | Run id or dataset id of an earlier run to continue; already-collected records are skipped. |
| `incrementalMode` | boolean | `false` | Turn on for recurring monitoring: later runs return only new, updated and reappeared records. |
| `stateKey` | string | (none) | Optional name for a monitoring campaign, to keep its memory stable or to share it across setups. |
| `emitUnchanged` | boolean | `false` | Also return (and bill) records that did not change, labelled UNCHANGED. |
| `emitExpired` | boolean | `false` | Also return (and bill) records that are gone, labelled EXPIRED. Only produced after a complete scan. |
| `ignoreFieldsForChanges` | array | empty | Field names (dotted paths for nested values, for example `sellerDetails.isVerified`) whose changes do not make a record UPDATED. The fields are still returned. |
| `mcpConnectors` | array | (none) | Optional: send results into apps you authorized under Integrations. Never changes the dataset. |
| `notionParentPageUrl` | string | (none) | Notion connector only: page under which item pages are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. |
| `concurrency` | integer | `6` | Accepted for compatibility; pages are read one at a time to stay polite to the storefront. |
| `retries` | integer | `3` | Accepted for compatibility; the connection ladder decides its own retries. |
| `timeoutSecs` | integer | `60` | Wall-clock budget for one page across all retries and connection fallbacks (5-120). The fallback connection tier takes about 35-40 seconds for a product page, so values below 45 cannot serve pages the site refuses on the first connection. |
| `proxyConfiguration` | object | Apify Proxy, residential group | Connection used for every request; pinned to the selected market's country when residential. See Plan Requirement. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "recordType": "product",
  "id": "300000001",
  "skuId": "300000002",
  "name": "Mochila de muestra",
  "brand": "MARCA MUESTRA",
  "url": "https://www.falabella.com/falabella-cl/product/300000001/producto-de-muestra",
  "imageUrl": "https://media.falabella.com/falabellaCL/300000002_01/public",
  "currency": "CLP",
  "price": 22990.0,
  "priceDisplay": "$ 22.990",
  "oldPrice": 27990.0,
  "discountPercent": 18,
  "ratingAverage": 4.6,
  "ratingCount": 128,
  "sellerId": "S00042",
  "sellerName": "Tienda de muestra",
  "officialSeller": true,
  "sponsored": false,
  "bestSeller": true,
  "market": "CL",
  "marketHost": "www.falabella.com",
  "description": "Descripcion del producto de muestra.",
  "specifications": [{ "name": "Color", "value": "Azul" }],
  "changeType": "NEW"
}
```

### Plan Requirement

Connection needs differ by page type, so the default connection is a residential-grade proxy pinned automatically to the market's country.

- **Listing, search and collection pages (Chile, Colombia):** often load on a standard datacenter connection, but not reliably: the storefront sometimes answers with a small "Access denied" page. A single refusal only makes the actor retry from a fresh exit on the same tier; after two refusals in a row on one link it moves that link up to the residential-grade tier, and the next link starts from the configured tier again.
- **Product pages and the Peru storefront:** treat these as needing escalation. Product pages are frequently answered with a verification page (even on residential connections) and Peru has only been seen refusing datacenter connections. The actor sends refused product pages through an alternate connection tier, but success is not guaranteed: it logs a warning per pasted product or Peru link, and detail reads can come back empty.

Running the actor reliably needs a plan that includes residential access, or your own proxy links pasted into the Connection section. Connection tiers are chosen from what your plan actually allows. Each page has a 60 second budget (the `timeoutSecs` input) across all retries and connection fallbacks; a product page that needs the fallback connection takes about 35-40 seconds of it.

If your plan has no residential access, the run logs this warning and continues on a backup connection when one is available:

> The selected connection is unavailable to this run. Apify free plans do not include residential proxies. Continuing on a backup connection; some pages may still be unavailable.

and, when the backup serves a page, "Served over the backup connection (the default connection was unavailable)." If no page can be loaded the run ends as failed (never as an empty success) with one of these messages:

- **Proxy refused for the account:** "The proxy connection was refused for this account, so no page could be read. Your Apify plan does not include proxy access; a paid plan is required." Check your own proxy credentials if you entered any.
- **Free plan, backup also failed:** "No results: residential proxies are unavailable on this run (Apify free plans do not include them), and the backup connection could not load the requested Falabella pages."
- **Connection problem:** "Could not load any results page (the requests failed), so nothing was collected. This is a connection problem, not an empty search." Try again later.

#### Output views and run summary

The dataset has three views: **Results** (every product record), **Detail** (description, specifications, stock and seller details from detail reads) and **Changes** (change type, changed fields and first/last seen, for recurring updates). A run with several searches or links also saves an `OUTPUT` record in the key-value store with items per source, sources that succeeded, failed or were truncated, whether the cap was hit and the change-type counts.

#### Notes and limits

- **Reviews are not included:** the review data sits on product pages, which the storefront answers with a verification page, so no review text or limit is offered.

- **Links default changed:** the default `urls` value is now one example of each supported link shape (it used to be a single link); clear it or replace it with your own links.

- Product ids and category ids are per country: a Chilean product id does not exist on the Peruvian storefront.

- Max records is the only cap that stops a run; max pages is a runaway guard.

- Resume and recurring updates are mutually exclusive on the same setup: use one or the other.

- Keyword searches can be answered by a keyword collection or a category page; the actor follows the storefront's own redirect and walks that route.

### FAQ

#### How much does it cost?

You pay per product record returned, plus a per-product detail surcharge on every returned product when detail reads are switched on, and on every pasted product link (a product link is always read from its full product page). Records suppressed as unchanged by recurring updates are never charged. The **Pricing** tab on this actor's page shows the current rates for your plan. Use **Max records** to cap the cost of any run.

#### Is it legal to scrape Falabella?

This actor collects only publicly available marketplace data: product listings, prices and seller information as shown on the storefront pages. You are responsible for how you use it: follow Falabella's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Prices and product facts are generally not protected, but product photos, descriptions and brand names may be subject to third-party rights.

#### Can I get only new or changed products on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Recurring updates**. Each run then returns only new, updated and reappeared records; unchanged ones are not returned or billed unless you turn that on too.

#### Why did a run fail instead of returning an empty dataset?

If every page is refused, the run stops with a clear message so "no results for this search" is never confused with "nothing could be read". Run it again in a few minutes. A genuinely empty search still succeeds, with zero rows and a visible note on the run.

#### Why does a resumed or capped run never report EXPIRED products?

Recurring updates only marks a product gone after a run that scanned its whole configured scope end to end. A resumed run, a run stopped by Max records, or a run where a source failed never qualifies, because none of them actually confirmed the product is gone; the stored baseline for that product is left untouched until a later, complete run says otherwise.

#### Can a product be marked EXPIRED by mistake?

No. If the storefront answers "page not found" for page 2 or later of a search or listing, the actor logs a warning and treats the walk as incomplete, so no `EXPIRED` rows are produced for that run. A product is only marked gone after a run that read its whole search or listing to the end.

#### What is the difference between the Chile, Colombia and Peru links?

Each market is its own catalogue: product and category ids are not portable across storefronts. A product id from the Chilean site will not resolve on the Colombian or Peruvian one. Links are fetched from the storefront in the link, and the `market`, `marketHost` and `currency` written on each row and the connection country follow that link's own storefront, not the Market setting. Pick the matching market when you search by keyword.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the `mcpConnectors` field to push results into Notion, Linear or Airtable.

### 🔗 More scrapers you might like

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🧩 <a href="https://apify.com/abotapi/jumia-marketplace-scraper"><b>Jumia Marketplace Scraper</b></a><br>Scrape Jumia, Africa's largest marketplace: products with local prices, discounts...</td><td>🧩 <a href="https://apify.com/abotapi/galaxus-marketplace-scraper"><b>Digitec Galaxus Scraper</b></a><br>Scrape Digitec Galaxus, Switzerland's largest online retailer: products with local...</td></tr>
<tr><td>🧩 <a href="https://apify.com/abotapi/vidaxl-com-scraper"><b>VidaXL Scraper</b></a><br>Scrape the vidaXL storefronts by keyword or URL across 6 European markets. Every row...</td><td>🧩 <a href="https://apify.com/abotapi/walmart-scraper"><b>Walmart Scraper</b></a><br>Scrape Walmart.com by keyword, URL, or item ID. Extract prices, was-prices, sellers...</td></tr>
<tr><td>🧩 <a href="https://apify.com/abotapi/fruugo-com-scraper"><b>Fruugo Scraper</b></a><br>Scrape Fruugo marketplace products by keyword or URL across country storefronts. Extract...</td><td>🏷️ <a href="https://apify.com/abotapi/wildberries-marketplace-scraper"><b>Wildberries Scraper</b></a><br>Scrape Wildberries marketplace: product search with prices (wallet vs retail), discounts...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/falabella-marketplace-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

#### Extra listing columns

Each record also carries `offering_id`, `discount_label`, `badges`, `promotions`, `category_id`, `total_reviews`, `search_term`, `shipping_labels` and a `raw_product` JSON string of the listing card, plus snake_case copies of the main fields (`product_id`, `sku_id`, `seller_name`, `seller_id`, `is_sponsored`, `is_best_seller`, `rating`, `image`, `scraped_at`). `internet_price` is the online price the card publishes as its internet or event price and `normal_price` is the card's normal (list) price; each is empty when the card does not publish that price type, and the card-holder price is never used for either. They are left out of the recurring-update comparison, so adding them does not mark existing products as UPDATED.

# Actor input Schema

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

Where to collect from: a keyword search on one storefront, or your own product and listing links.

## `market` (type: `string`):

Which country storefront to search. Each market is its own catalogue with its own currency and its own product ids.

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

Only read when mode = keyword search. One entry per search; each search is walked forward, and all searches share the record cap. The alias "term" is also accepted.

## `term` (type: `string`):

Alias of Search terms for a single keyword. Used only when Search terms is empty.

## `sort` (type: `string`):

Order in which products are returned for each search.

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

Only read when mode = my own links. Paste listing links (a search, a keyword collection, a category or a brand page; a ?page=N link starts the walk at that page and a pasted sort is kept) or product page links. Each link is read and labelled with its own storefront's country and currency, and connects through that country. Left untouched, links mode scrapes one example of each supported link shape.

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

Open each product's own page and add the description, specification table, category path, stock state, seller legal details and extra images to the record. Off by default: a run without it is much cheaper and still carries prices, discounts, ratings and seller names.

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

Stop after this many records across the whole run. Defaults to 20; set 0 to remove the limit (the walk then ends when the catalogue runs out, capped by the per-source page guard).

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

Runaway guard: an upper bound on how much is read for any single search or listing walk. Leave 0 to go as deep as the source serves, with the record cap above as the only real limit.

## `concurrency` (type: `integer`):

Accepted for compatibility; pages are read one at a time to stay polite to the storefront.

## `retries` (type: `integer`):

Accepted for compatibility; the connection ladder decides its own retries.

## `timeoutSecs` (type: `integer`):

Wall-clock budget for one page, across all retries and connection fallbacks (the fallback connection tier needs about 40 seconds for a product page, so values below 45 cannot serve pages the site refuses on the first connection).

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

Connection used for every request. Chile and Colombia listing, search and collection pages often load on an ordinary datacenter connection but are refused intermittently; product pages and Peru need escalation with no guarantee. The default requests the premium consumer connection tier pinned to the selected market's country; it needs a paid plan that includes that tier. You can also paste your own connection links.

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

Paste the run id (or dataset id) of an earlier run of this Actor to continue it. Records that run already returned are skipped, so an interrupted large collection can finish without paying for the same rows twice. Leave empty for a normal run.

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

Turn this on for daily or weekly monitoring. The first run returns everything as NEW. Later runs return only NEW, UPDATED and REAPPEARED records, each labelled in a changeType column. Prices and rating counts move constantly on a marketplace, so a record whose only difference is a price still counts as UPDATED. Leave off for a normal one-off run.

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

Optional. Name this monitoring campaign to keep its memory stable, or to deliberately share one memory across differently configured runs. Leave empty and the memory is keyed on the run setup automatically.

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

Off by default. Turn on to also return records that have not changed since the last run, labelled UNCHANGED. This returns, and bills, rows you already have.

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

Off by default. Turn on to also return records that were present before and are no longer found, labelled EXPIRED. Only produced when a run covered its whole setup, so a capped or continued run never reports records as gone. This returns, and bills, extra rows.

## `ignoreFieldsForChanges` (type: `array`):

Optional. Field names whose changes should not make a record count as UPDATED, for example rating or totalReviews. Nested values can be addressed with dots, for example sellerDetails.isVerified. Ignored fields are still returned in the row; they only stop triggering an UPDATED label. Leave empty to watch every field.

## `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.

## `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",
  "market": "cl",
  "queries": [
    "iphone"
  ],
  "sort": "relevance",
  "urls": [
    "https://www.falabella.com/falabella-cl/search?Ntt=iphone",
    "https://www.falabella.com/falabella-cl/collection/iphone?sred=iphone",
    "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video",
    "https://www.falabella.com/falabella-cl/category/cat1012",
    "https://www.falabella.com/falabella-cl/brand/APPLE",
    "https://www.falabella.com/falabella-cl/brand/APPLE?page=2",
    "https://www.falabella.com/falabella-cl/search?Ntt=televisor&page=2",
    "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video?sortBy=derived.price.search,asc",
    "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video?f.product.brandName=SAMSUNG",
    "https://www.falabella.com/falabella-cl/product/80746061/led-smart-tv-58-pud7019-4k-uhd-philips",
    "https://www.falabella.com.co/falabella-co/search?Ntt=televisor",
    "https://www.falabella.com.co/falabella-co/category/cat1660941",
    "https://www.falabella.com.pe/falabella-pe"
  ],
  "fetchDetails": false,
  "maxItems": 20,
  "maxPages": 0,
  "concurrency": 6,
  "retries": 3,
  "timeoutSecs": 60,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50
}
```

# Actor output Schema

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

No description

## `detail` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `summary` (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",
    "market": "cl",
    "queries": [
        "iphone"
    ],
    "sort": "relevance",
    "urls": [
        "https://www.falabella.com/falabella-cl/search?Ntt=iphone",
        "https://www.falabella.com/falabella-cl/collection/iphone?sred=iphone",
        "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video",
        "https://www.falabella.com/falabella-cl/category/cat1012",
        "https://www.falabella.com/falabella-cl/brand/APPLE",
        "https://www.falabella.com/falabella-cl/brand/APPLE?page=2",
        "https://www.falabella.com/falabella-cl/search?Ntt=televisor&page=2",
        "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video?sortBy=derived.price.search,asc",
        "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video?f.product.brandName=SAMSUNG",
        "https://www.falabella.com/falabella-cl/product/80746061/led-smart-tv-58-pud7019-4k-uhd-philips",
        "https://www.falabella.com.co/falabella-co/search?Ntt=televisor",
        "https://www.falabella.com.co/falabella-co/category/cat1660941",
        "https://www.falabella.com.pe/falabella-pe"
    ],
    "fetchDetails": false,
    "maxItems": 20,
    "maxPages": 0,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "maxNotifyListings": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/falabella-marketplace-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",
    "market": "cl",
    "queries": ["iphone"],
    "sort": "relevance",
    "urls": [
        "https://www.falabella.com/falabella-cl/search?Ntt=iphone",
        "https://www.falabella.com/falabella-cl/collection/iphone?sred=iphone",
        "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video",
        "https://www.falabella.com/falabella-cl/category/cat1012",
        "https://www.falabella.com/falabella-cl/brand/APPLE",
        "https://www.falabella.com/falabella-cl/brand/APPLE?page=2",
        "https://www.falabella.com/falabella-cl/search?Ntt=televisor&page=2",
        "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video?sortBy=derived.price.search,asc",
        "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video?f.product.brandName=SAMSUNG",
        "https://www.falabella.com/falabella-cl/product/80746061/led-smart-tv-58-pud7019-4k-uhd-philips",
        "https://www.falabella.com.co/falabella-co/search?Ntt=televisor",
        "https://www.falabella.com.co/falabella-co/category/cat1660941",
        "https://www.falabella.com.pe/falabella-pe",
    ],
    "fetchDetails": False,
    "maxItems": 20,
    "maxPages": 0,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "maxNotifyListings": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/falabella-marketplace-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",
  "market": "cl",
  "queries": [
    "iphone"
  ],
  "sort": "relevance",
  "urls": [
    "https://www.falabella.com/falabella-cl/search?Ntt=iphone",
    "https://www.falabella.com/falabella-cl/collection/iphone?sred=iphone",
    "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video",
    "https://www.falabella.com/falabella-cl/category/cat1012",
    "https://www.falabella.com/falabella-cl/brand/APPLE",
    "https://www.falabella.com/falabella-cl/brand/APPLE?page=2",
    "https://www.falabella.com/falabella-cl/search?Ntt=televisor&page=2",
    "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video?sortBy=derived.price.search,asc",
    "https://www.falabella.com/falabella-cl/category/cat1012/TV-y-Video?f.product.brandName=SAMSUNG",
    "https://www.falabella.com/falabella-cl/product/80746061/led-smart-tv-58-pud7019-4k-uhd-philips",
    "https://www.falabella.com.co/falabella-co/search?Ntt=televisor",
    "https://www.falabella.com.co/falabella-co/category/cat1660941",
    "https://www.falabella.com.pe/falabella-pe"
  ],
  "fetchDetails": false,
  "maxItems": 20,
  "maxPages": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50
}' |
apify call abotapi/falabella-marketplace-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/falabella-marketplace-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/Z5lpvrsQGBbXlt3mv/builds/0BeJH655Xau7GQUkx/openapi.json