# Yapo Chile Marketplace Listings Scraper (`automation-lab/yapo-chile-marketplace-listings-scraper`) Actor

🇨🇱 Extract public Yapo.cl ads with CLP prices, descriptions, sellers, images, locations, and category-specific details for inventory and market analysis.

- **URL**: https://apify.com/automation-lab/yapo-chile-marketplace-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Yapo Chile Marketplace Listings Scraper

Turn public Yapo.cl classifieds into structured data for resale research, vehicle intelligence, property monitoring, and recurring inventory analysis.

Paste a Yapo search, category, or individual ad URL. The Actor follows result pages, removes duplicate ads, and exports one clean record per listing.

It can collect summary cards quickly or open each listing to add full descriptions, reference IDs, seller badges, publish dates, images, and category-specific attributes.

### What does Yapo Chile Marketplace Listings Scraper do?

Yapo Chile Marketplace Listings Scraper extracts public classified ads from `yapo.cl` without requiring an account.

It supports:

- 🇨🇱 Yapo search and category result URLs
- 🔗 individual public listing URLs
- 📄 rendered search pagination
- 🔎 optional detail-page enrichment
- 🚗 vehicle fields such as make, model, year, mileage, fuel, and transmission
- 🏷️ category-specific attributes preserved in a portable JSON string
- 🖼️ primary and gallery image URLs
- 🏪 seller names, public profile links, and visible badges
- 📊 JSON, CSV, Excel, XML, RSS, and API exports through Apify datasets

The output is suitable for both one-off exports and scheduled monitoring.

### Who is it for?

#### Resale and marketplace analysts

Compare asking prices, locations, seller types, favorites, and inventory changes across public Yapo categories.

#### Vehicle dealers and automotive intelligence teams

Build a structured feed of make, model, version, year, fuel, transmission, mileage, body style, color, drivetrain, engine size, and equipment.

#### Property and local-market researchers

Collect public ads from Yapo property categories and retain the attributes displayed on each listing page.

#### Pricing and inventory teams

Run the same category URL on a schedule, store listing IDs, and detect new ads or changed prices downstream.

#### Developers and data engineers

Call the Actor through the Apify API, webhooks, Make, Zapier, Google Sheets, or MCP instead of maintaining proxy and parsing code.

### Why use this Yapo.cl scraper?

- **One workflow for search and detail pages:** use category URLs for discovery or listing URLs for precise lookups.
- **Structured CLP prices:** receive both the displayed price and a numeric `price` value.
- **Useful provenance:** every record includes its source search URL, page number, and scrape timestamp.
- **Stable deduplication:** listing IDs prevent repeated records across pages and start URLs.
- **Cost-aware networking:** automatic mode starts with an Apify datacenter proxy and uses Chile residential routing only after a block.
- **Fail-closed validation:** non-Yapo URLs are rejected instead of being crawled accidentally.
- **Honest enrichment:** if one detail page fails, the valid search-card record is still saved with `detailsIncluded: false`.

### What Yapo data can you extract?

| Field | Description |
|---|---|
| `listingId` | Stable public Yapo ad ID |
| `url` | Canonical listing URL |
| `title` | Full listing title |
| `shortDescription` | Description visible in search results |
| `description` | Full public detail-page description |
| `categorySlug` | Yapo category inferred from the URL |
| `price` | Numeric asking price |
| `priceDisplay` | Price as displayed by Yapo |
| `currency` | `CLP` |
| `location` | Visible Chilean location |
| `publishedAt` | Public listing date when available |
| `referenceId` | Seller or Yapo reference code |
| `sellerName` | Public seller name |
| `sellerProfileUrl` | Public seller profile URL |
| `sellerBadges` | Visible badges such as verified or professional |
| `favoriteCount` | Public favorites count when shown |
| `imageUrl` | Primary image URL |
| `imageUrls` | Listing gallery image URLs |
| `make`, `model`, `version` | Vehicle identification fields |
| `year`, `mileageKm` | Numeric vehicle year and mileage |
| `fuel`, `transmission` | Fuel and gearbox |
| `bodyStyle`, `color`, `drivetrain` | Vehicle configuration |
| `engineCc`, `powerHp` | Numeric engine size and power when shown |
| `equipmentComfort` | Visible comfort equipment |
| `equipmentSafety` | Visible safety equipment |
| `equipmentExterior` | Visible exterior equipment |
| `attributesJson` | All parsed category-specific labels and values as JSON text |
| `sourceSearchUrl`, `searchPage` | Discovery provenance |
| `detailsIncluded` | Whether detail enrichment succeeded |
| `scrapedAt` | UTC extraction timestamp |

### How to scrape Yapo Chile listings

1. Open the Actor input page.
2. Add one or more public Yapo.cl search, category, or listing URLs.
3. Choose the maximum number of listings and pages.
4. Keep **detail enrichment** enabled when you need descriptions, seller data, or category attributes.
5. Leave the proxy strategy on **AUTO** unless you have a specific routing requirement.
6. Click **Start**.
7. Preview the dataset, then export it or connect it to your workflow.

For a cheap first run, use one search URL, one page, and five listings.

### Input parameters

| Parameter | Type | Default | What it controls |
|---|---|---:|---|
| `startUrls` | array | required | Public Yapo search, category, or listing URLs |
| `maxItems` | integer | 10 | Global unique-listing limit |
| `maxPages` | integer | 3 | Maximum pages per search/category URL |
| `includeDetails` | boolean | `true` | Fetch every listing page for enrichment |
| `proxyMode` | string | `AUTO` | `AUTO`, `DATACENTER`, or `RESIDENTIAL` |
| `maxRequestRetries` | integer | 2 | Retries per proxy strategy |

`AUTO` is recommended. It minimizes bandwidth cost by trying datacenter routing first and falls back to a Chile residential session only when the response is blocked.

### Input example: enriched vehicle listings

```json
{
  "startUrls": [
    {
      "url": "https://www.yapo.cl/autos-usados/region-metropolitana-santiago"
    }
  ],
  "maxItems": 10,
  "maxPages": 1,
  "includeDetails": true,
  "proxyMode": "AUTO",
  "maxRequestRetries": 2
}
````

### Input example: fast marketplace monitor

```json
{
  "startUrls": [
    {
      "url": "https://www.yapo.cl/marketplace"
    }
  ],
  "maxItems": 30,
  "maxPages": 1,
  "includeDetails": false,
  "proxyMode": "AUTO"
}
```

Use summary mode for frequent discovery runs, then enrich only newly seen listing URLs in a second run.

### Output example

```json
{
  "listingId": "32604320",
  "url": "https://www.yapo.cl/autos-usados/bmw-320-i-sport-2022-329/32604320",
  "title": "BMW 320 I SPORT - 2022 | 329",
  "price": 25990000,
  "priceDisplay": "$25.990.000",
  "currency": "CLP",
  "location": "Santiago",
  "sellerName": "Mercado Car",
  "sellerBadges": ["Profesional", "Verificado"],
  "favoriteCount": 1,
  "make": "BMW",
  "model": "320",
  "version": "I SPORT",
  "year": 2022,
  "fuel": "Bencina",
  "transmission": "Automática",
  "mileageKm": 36174,
  "color": "BLANCO MINERAL",
  "detailsIncluded": true,
  "scrapedAt": "2026-07-23T02:46:01.952Z"
}
```

Fields that are not displayed for a particular category are omitted rather than filled with misleading values.

### How much does it cost to scrape Yapo Chile listings?

This Actor uses pay-per-event pricing: a **$0.005 start charge** per run plus one charge for each listing stored successfully.

| Apify plan tier | Price per listing | Approximate cost for 1,000 listings, including start |
|---|---:|---:|
| Free | $0.00033027 | $0.33527 |
| Starter / Bronze | $0.00028719 | $0.29219 |
| Scale / Silver | $0.00022401 | $0.22901 |
| Business / Gold | $0.00017231 | $0.17731 |
| Platinum | $0.00011488 | $0.11988 |
| Diamond | $0.000080413 | $0.085413 |

A five-listing enriched validation run costs about **$0.0067 on the Free tier**. Higher plan tiers receive lower per-listing rates.

Your final cost depends mainly on the number of saved listings. `includeDetails` affects runtime and proxy bandwidth, but you are charged per successful dataset record rather than per HTTP request.

To control spend:

- begin with `maxItems: 5`;
- use `includeDetails: false` for frequent discovery monitors;
- enrich only new listing URLs;
- use one page while validating a category;
- keep `proxyMode: AUTO` instead of forcing residential routing.

The Apify free plan includes platform credits that can be used for a small validation run.

### Search-card mode versus detail enrichment

**Search-card mode** (`includeDetails: false`) is best for fast inventory discovery. It returns listing ID, URL, title, short description, price, location, favorites, images, seller badges, and visible summary attributes.

**Detail enrichment** (`includeDetails: true`) additionally opens each ad page. It adds the full description, reference ID, seller profile, publish date, gallery, and richer category-specific attributes.

Choose the smallest mode that satisfies your workflow.

### Pagination and duplicate handling

Yapo renders a next-page URL in each result page. The Actor follows that URL until it reaches:

- `maxPages`;
- `maxItems`;
- the end of results; or
- a page without extractable listing cards.

Records are deduplicated by `listingId` across every page and input URL in the run.

### Tips for reliable Yapo extraction

- ✅ Copy URLs directly from the public Yapo site.
- ✅ Keep the default `AUTO` proxy strategy.
- ✅ Schedule moderate runs instead of repeatedly downloading the same large category.
- ✅ Store `listingId` in your database for change detection.
- ✅ Compare `price` as a number and retain `priceDisplay` for presentation.
- ✅ Check `detailsIncluded` before relying on detail-only fields.
- ⚠️ Do not use login, favorites, contact, or messaging URLs as start URLs.
- ⚠️ Category layouts can expose different attributes; use `attributesJson` for category-specific values.

### Scheduled price and inventory monitoring

A practical monitoring workflow is:

1. Run a Yapo category URL every few hours or once per day.
2. Store `listingId`, `price`, and `scrapedAt` in your database.
3. Compare the latest snapshot with the previous snapshot.
4. Flag new IDs as new inventory.
5. Flag changed numeric prices as price movements.
6. Trigger a detail-only run for listings that need deeper analysis.

Apify schedules can start the Actor automatically, and webhooks can notify your application when each run finishes.

### Integrations

#### Google Sheets inventory feed

Send the default dataset to Google Sheets and use `listingId` as the unique key. Build filters by location, category, price, year, or mileage.

#### Make or Zapier alerts

Trigger the Actor on a schedule, compare results in a datastore, and send Slack or email alerts for new ads matching your rules.

#### Data warehouse snapshots

Export JSON or CSV to BigQuery, Snowflake, PostgreSQL, or object storage. Partition snapshots by `scrapedAt` for historical pricing analysis.

#### Dealer CRM enrichment

Start with a search-card monitor, identify new vehicle ads, then run their URLs with detail enrichment before passing qualified records to a CRM.

#### Apify webhooks

Attach a run-succeeded webhook and fetch the default dataset from your backend as soon as extraction finishes.

### Use the Apify API with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/yapo-chile-marketplace-listings-scraper').call({
  startUrls: [{ url: 'https://www.yapo.cl/marketplace' }],
  maxItems: 10,
  maxPages: 1,
  includeDetails: true,
  proxyMode: 'AUTO'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/yapo-chile-marketplace-listings-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.yapo.cl/marketplace'}],
    'maxItems': 10,
    'maxPages': 1,
    'includeDetails': True,
    'proxyMode': 'AUTO',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~yapo-chile-marketplace-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.yapo.cl/marketplace"}],
    "maxItems": 10,
    "maxPages": 1,
    "includeDetails": true,
    "proxyMode": "AUTO"
  }'
```

Fetch dataset items after the run succeeds:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use Yapo Chile Marketplace Listings Scraper with MCP

Connect Apify Actors to Claude Code with:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/yapo-chile-marketplace-listings-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this HTTP MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/yapo-chile-marketplace-listings-scraper"
    }
  }
}
```

Example prompts:

- “Scrape five enriched vehicle listings from this Yapo Santiago URL and summarize price per model year.”
- “Extract the first page of this Yapo marketplace category without detail enrichment.”
- “Run these three Yapo listing URLs and return seller badges, prices, descriptions, and images.”
- “Compare mileage and asking price for the vehicle records returned by the Yapo Actor.”

### Data quality and field behavior

Yapo categories do not all share one schema. Vehicle ads often include structured mechanical fields, while marketplace or property ads expose different labels.

The Actor normalizes common fields and preserves all visible key-value attributes in `attributesJson`.

Numeric values are emitted only when they can be parsed safely. Optional fields are omitted when the source does not display them.

The Actor does not infer private contact information or fabricate missing seller details.

### Limitations

- Only public `yapo.cl` pages are supported.
- Contact buttons, phone reveals, messages, login, and account actions are intentionally excluded.
- Yapo can change HTML structure or anti-bot behavior.
- Search-card output is less detailed when `includeDetails` is disabled.
- Some categories provide only free-form attributes.
- A deleted or expired direct listing can return no record and fail an explicit lookup run.
- Residential fallback availability depends on the Apify plan and proxy access.

### Is it legal to scrape Yapo.cl?

This Actor collects information displayed on public Yapo pages. Web scraping may still be regulated by website terms, copyright, database rights, privacy law, and the purpose or scale of collection.

You are responsible for ensuring that your use has a lawful basis and complies with Yapo's terms and applicable Chilean and international laws.

Do not use the Actor to collect sensitive personal data, bypass authentication, contact sellers without consent, spam users, or make decisions that unlawfully affect individuals.

Use conservative schedules, collect only fields needed for your purpose, secure exported datasets, and honor valid deletion or access requests where applicable.

### Troubleshooting

#### Why did my run reject a URL?

The Actor accepts only `https://yapo.cl` or `https://www.yapo.cl` public URLs. Remove redirects, tracking wrappers, contact endpoints, or URLs from other sites.

#### Why is `detailsIncluded` false?

The search card was extracted, but Yapo did not return a usable detail page after the configured retries. Keep `proxyMode: AUTO`, rerun the specific listing URL, or increase retries modestly.

#### Why are some vehicle fields missing?

The seller or category did not expose those fields. Inspect `description` and `attributesJson`; do not assume every ad includes mileage, transmission, or equipment.

#### Why did a direct listing run fail?

The ad may be expired, deleted, private, redirected, or temporarily blocked. Verify that the same URL opens as a public Yapo listing and use `AUTO` proxy mode.

#### Why did a search return fewer listings than `maxItems`?

The category may contain fewer public results, pagination may have ended, or duplicate IDs may have appeared across input URLs. `maxItems` is a ceiling, not a promised result count.

### FAQ

#### Can I scrape multiple Yapo categories in one run?

Yes. Add multiple public category URLs to `startUrls`. The global `maxItems` limit applies across all of them.

#### Can I scrape one known ad?

Yes. Pass its full listing URL. The Actor extracts the detail page directly without crawling unrelated search results.

#### Does the Actor require Yapo credentials?

No. It uses only anonymous public pages.

#### Does it reveal phone numbers or send messages?

No. Login-gated contact actions and messaging are outside the product scope.

#### Can I export results to Excel?

Yes. Open the dataset and choose Excel, CSV, JSON, XML, or another supported format.

#### Can I monitor price changes?

Yes. Schedule runs and compare records by `listingId`. Numeric `price` makes change detection straightforward.

#### What proxy mode should I use?

Use `AUTO`. It tries cost-efficient datacenter routing first and uses Chile residential routing only after a block.

#### Are images downloaded?

No. The dataset contains public image URLs, which keeps runs faster and exports smaller.

### Related marketplace scrapers

- [Wallapop Marketplace Scraper](https://apify.com/automation-lab/wallapop-marketplace-scraper) — Spanish second-hand marketplace listings
- [FINN.no Marketplace Scraper](https://apify.com/automation-lab/finn-no-marketplace-scraper) — Norwegian marketplace inventory
- [DBA.dk Marketplace Scraper](https://apify.com/automation-lab/dba-dk-marketplace-scraper) — Danish classifieds
- [Drom.ru Car Marketplace Scraper](https://apify.com/automation-lab/drom-ru-car-marketplace-scraper) — vehicle market research
- [Willhaben.at Marketplace Scraper](https://apify.com/automation-lab/willhaben-at-marketplace-scraper) — Austrian marketplace listings

Choose this Actor when your source is Yapo.cl and you need Chilean marketplace, vehicle, property, or local classified data.

### Support

If a public Yapo URL produces unexpected output, open an issue from the Actor page and include:

- the input URL;
- whether detail enrichment was enabled;
- the proxy mode;
- the run ID; and
- the fields you expected.

Do not include private credentials, phone numbers, or personal data in support reports.

# Actor input Schema

## `startUrls` (type: `array`):

Add one or more public yapo.cl URLs. Search/category URLs are paginated; individual listing URLs are extracted directly.

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

Stop after saving this many unique Yapo ads across all start URLs.

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

Maximum number of pagination pages to visit for each search or category URL.

## `includeDetails` (type: `boolean`):

Fetch each ad page to add full description, reference ID, seller badges, publish date, and category-specific attributes.

## `proxyMode` (type: `string`):

AUTO starts with cost-efficient Apify datacenter proxy and falls back to Chile residential only when Yapo blocks the response.

## `maxRequestRetries` (type: `integer`):

Retry failed requests with fresh sticky sessions before giving up or switching proxy strategy.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.yapo.cl/autos-usados/region-metropolitana-santiago"
    }
  ],
  "maxItems": 5,
  "maxPages": 1,
  "includeDetails": true,
  "proxyMode": "AUTO",
  "maxRequestRetries": 2
}
```

# Actor output Schema

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

Open the default dataset table containing one record per unique public Yapo listing.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.yapo.cl/autos-usados/region-metropolitana-santiago"
        }
    ],
    "maxItems": 5,
    "maxPages": 1,
    "includeDetails": true,
    "proxyMode": "AUTO",
    "maxRequestRetries": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/yapo-chile-marketplace-listings-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 = {
    "startUrls": [{ "url": "https://www.yapo.cl/autos-usados/region-metropolitana-santiago" }],
    "maxItems": 5,
    "maxPages": 1,
    "includeDetails": True,
    "proxyMode": "AUTO",
    "maxRequestRetries": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/yapo-chile-marketplace-listings-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.yapo.cl/autos-usados/region-metropolitana-santiago"
    }
  ],
  "maxItems": 5,
  "maxPages": 1,
  "includeDetails": true,
  "proxyMode": "AUTO",
  "maxRequestRetries": 2
}' |
apify call automation-lab/yapo-chile-marketplace-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/yapo-chile-marketplace-listings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yapo Chile Marketplace Listings Scraper",
        "description": "🇨🇱 Extract public Yapo.cl ads with CLP prices, descriptions, sellers, images, locations, and category-specific details for inventory and market analysis.",
        "version": "0.1",
        "x-build-id": "2IE8U3PcUq7H9Bxn9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~yapo-chile-marketplace-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-yapo-chile-marketplace-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~yapo-chile-marketplace-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-yapo-chile-marketplace-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~yapo-chile-marketplace-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-yapo-chile-marketplace-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Yapo search, category, or listing URLs",
                        "type": "array",
                        "description": "Add one or more public yapo.cl URLs. Search/category URLs are paginated; individual listing URLs are extracted directly.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after saving this many unique Yapo ads across all start URLs.",
                        "default": 10
                    },
                    "maxPages": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of pagination pages to visit for each search or category URL.",
                        "default": 3
                    },
                    "includeDetails": {
                        "title": "Enrich every listing from its detail page",
                        "type": "boolean",
                        "description": "Fetch each ad page to add full description, reference ID, seller badges, publish date, and category-specific attributes.",
                        "default": true
                    },
                    "proxyMode": {
                        "title": "Proxy strategy",
                        "enum": [
                            "AUTO",
                            "DATACENTER",
                            "RESIDENTIAL"
                        ],
                        "type": "string",
                        "description": "AUTO starts with cost-efficient Apify datacenter proxy and falls back to Chile residential only when Yapo blocks the response.",
                        "default": "AUTO"
                    },
                    "maxRequestRetries": {
                        "title": "Retries per proxy strategy",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Retry failed requests with fresh sticky sessions before giving up or switching proxy strategy.",
                        "default": 2
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```