# Peugeot Store Scraper: 11 Markets Worldwide (`rastriq/peugeot-store-scraper`) Actor

Extract vehicle configurations, pricing, specs, stock and finance from Peugeot across 11 markets (ES, FR, IT, PT, GB, PL, DE, AT, HU, HR, BR). All trims, engines and colours. Dual-backend: GraphQL + Config V3 REST API.

- **URL**: https://apify.com/rastriq/peugeot-store-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Peugeot Store Scraper — Extract Pricing & Specs from 11 Markets Worldwide

Extract vehicle configurations, pricing, specs, and stock from the official **Peugeot online store** across **11 markets**: 🇪🇸 Spain, 🇫🇷 France, 🇮🇹 Italy, 🇵🇹 Portugal, 🇬🇧 United Kingdom, 🇵🇱 Poland, 🇩🇪 Germany, 🇦🇹 Austria, 🇭🇺 Hungary, 🇭🇷 Croatia, and 🇧🇷 Brazil. **Peugeot Store Scraper** enumerates every trim, engine, and color combination for each model — letting you compare Peugeot prices across countries in a single run.

> Try it free — your first $5 of usage is on Apify. No credit card required.


### What is Peugeot Store Scraper?

**Peugeot Store Scraper** is an automated data extraction tool that connects directly to the official Peugeot configurator and retrieves full pricing and specification data for every available vehicle configuration across **11 markets**. Unlike manually browsing each country's configurator one combination at a time, this scraper systematically covers all trim levels, engines, gearboxes, exterior colors, and interior colors — giving you a complete cross-market picture of the Peugeot catalogue in minutes.

The actor uses a **dual-backend architecture**: GraphQL API for Western European markets and Stellantis Config V3 REST API for Central/Eastern Europe and Brazil — automatically selecting the correct backend based on your market selection.

#### Supported markets

| Market | Code | Backend | Available models |
|--------|------|---------|------------------|
| 🇪🇸 Spain | `es` | GraphQL | All models |
| 🇫🇷 France | `fr` | GraphQL | All models |
| 🇮🇹 Italy | `it` | GraphQL | All models |
| 🇵🇹 Portugal | `pt` | GraphQL | All models |
| 🇬🇧 United Kingdom | `gb` | GraphQL | All models |
| 🇵🇱 Poland | `pl` | Config V3 | 208, 2008, 308, 3008 |
| 🇩🇪 Germany | `de` | Config V3 | 2008, 308 |
| 🇦🇹 Austria | `at` | Config V3 | 208, 3008 |
| 🇭🇺 Hungary | `hu` | Config V3 | 208, 2008, 308 |
| 🇭🇷 Croatia | `hr` | Config V3 | 208, 2008, 308, 3008 |
| 🇧🇷 Brazil | `br` | Config V3 | ⚡ e-208, ⚡ e-2008 |

Use **Peugeot Store Scraper** to:

- 💰 **Track Peugeot pricing across 11 markets** — monitor cash prices, finance offers, discounts, and incentives from Western Europe to Brazil
- 🔄 **Compare prices by country** — discover price differences for the same model between Spain, Poland, Germany, and beyond
- 📊 **Cross-market intelligence** — feed structured OEM data into competitive analysis dashboards covering Europe and LATAM
- 📦 **Stock monitoring** — track real-time stock availability per configuration and market (GraphQL markets)
- ⏱️ **Automate recurring reports** — schedule daily or weekly runs to capture price changes over time


### What data does Peugeot Store Scraper extract?

**Peugeot Store Scraper** returns structured data with **50+ fields** per configuration:

| Field group | Fields extracted |
|------------|-----------------|
| 🚗 **Vehicle identity** | Model, trim, body style, LCDV16 code, configuration ID |
| ⚙️ **Engine & drivetrain** | Engine title, gearbox type, fuel type, power (kW) |
| 🎨 **Colors** | Exterior color, interior color, all available color options |
| 💶 **Cash pricing** | Price incl. tax, price excl. tax, catalog price, discounts, savings |
| 💳 **Finance** | Monthly payment, APR, deposit, contract length, final payment |
| 📦 **Stock & availability** | Units in stock, lead time (weeks), estimated delivery date |
| 🌿 **Emissions (WLTP)** | CO2 g/km, fuel consumption l/100km, electric range |
| ⚡ **EV data** | Electric consumption, battery range |
| 📋 **Full specs** | Technical specifications (flattened), standard features list |
| 🔗 **Metadata** | Market code, source API (GraphQL/Config V3), source URL, scraped timestamp |


### How to use Peugeot Store Scraper

Extracting Peugeot configurator data takes under two minutes:

1. **Create a free Apify account** at [apify.com](https://apify.com) — your first $5 is free
2. **Open Peugeot Store Scraper** in Apify Console or click **Try for free** on this page
3. **Select a market** 🌍 — choose from 11 countries using the flag dropdown
4. **Add models** 🚗 — pick one or more Peugeot models (leave empty to scrape all available models for your market)
5. **Set a combination limit** — use 5–10 for testing, or 0 for unlimited (full catalogue)
6. **Click Start** and wait for the run to finish (1–15 minutes depending on market and model count)
7. **Download your results** in JSON, CSV, Excel, or XML — or access them via the Apify API

> **Where to find model slugs**: visit `store.peugeot.es` and click any model. The slug is the last part of the URL (e.g., `store.peugeot.es/selector/configurable/2008-suv` → slug is `2008-suv`).


### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `market` | string | `"es"` | Market code: `es` 🇪🇸, `fr` 🇫🇷, `it` 🇮🇹, `pt` 🇵🇹, `gb` 🇬🇧, `pl` 🇵🇱, `de` 🇩🇪, `at` 🇦🇹, `hu` 🇭🇺, `hr` 🇭🇷, `br` 🇧🇷 |
| `models` | array | `[]` (all) | Model slugs (e.g., `["2008-suv", "308"]`). Leave empty to scrape all |
| `maxCombinationsPerModel` | integer | `0` (unlimited) | Max trim × engine × color combinations per model. Use 5–10 for testing |
| `includeStockCount` | boolean | `true` | Query stock availability (GraphQL markets only) |
| `language` | string | `"es"` | Language code for store interface (GraphQL markets only) |
| `proxyConfiguration` | object | Apify auto | Proxy settings. Datacenter proxies work fine |
| `requestDelay` | integer | `500` | Delay between requests in ms |
| `debugMode` | boolean | `false` | Enable verbose logging |

**Example input — GraphQL market (Spain):**

```json
{
  "market": "es",
  "models": ["2008-suv", "3008-suv"],
  "maxCombinationsPerModel": 50,
  "includeStockCount": true
}
````

**Example input — Config V3 market (Poland, all models):**

```json
{
  "market": "pl",
  "models": [],
  "maxCombinationsPerModel": 0
}
```

### Output example

Each result is a structured JSON object with full configuration details. Here is a sample from a real run on the Poland market (Config V3):

```json
{
  "configurationId": "1PP2A5HJLKC05YH2",
  "lcdv16": "1PP2A5HJLKC05YH2",
  "title": "208 Edition 1.2 Turbo 100KM M6",
  "modelSlug": "208",
  "modelTitle": "208",
  "bodyStyle": "hatchback",
  "trimTitle": "Edition",
  "engineTitle": "100 KM S&S",
  "gearboxTitle": "manualna M6",
  "fuel": "Benzyna",
  "exteriorColourTitle": "Czarny Perla Nera",
  "interiorColourTitle": "Tapicerka RENZO",
  "availableExteriorColours": ["Czarny Perla Nera", "Bialy Okenite", "Szary Artense", "Zolty Agueda"],
  "cashTotalAmount": 72000,
  "cashTotalAmountExclTax": 58130.09,
  "cashCatalogAmount": 72000,
  "cashSaving": 0,
  "wltp_co2Combined": "117",
  "wltp_consumptionCombined": "5.2",
  "powerKW": "74",
  "market": "pl",
  "sourceApi": "configv3",
  "derivedModel": "VP1PP2A5",
  "scrapedAt": "2026-07-04T20:46:14.361361+00:00"
}
```

Download results in **JSON, CSV, Excel, XML, or HTML** from the Output tab, or pull them programmatically using the [Apify API](https://docs.apify.com/api/v2).

### 💰 How much does it cost to use Peugeot Store Scraper?

**Peugeot Store Scraper** runs on Apify's standard **Compute Unit (CU)** pricing. A typical run extracting all configurations for one model (50–200 combinations) takes about 1–3 minutes at 512 MB, consuming approximately 0.01–0.03 CUs.

| Scenario | Combinations | Approx. cost |
|----------|-------------|-------------|
| Quick test (1 model, 10 combos) | ~10 | < $0.01 |
| Full model (1 model, all combos) | ~100–200 | ~$0.02 |
| Full catalogue (all models, 1 market) | ~500–1,500 | ~$0.10–$0.20 |
| All 11 markets, all models | ~5,000+ | ~$1.00 |

> **Is scraping the Peugeot configurator free?** Your first $5 of Apify credit covers thousands of configurations at no cost.

Config V3 markets (🇵🇱🇩🇪🇦🇹🇭🇺🇭🇷🇧🇷) are significantly cheaper because they return all versions in a single API call per model, requiring far fewer requests than GraphQL markets.

### Setting up recurring price monitoring

**Peugeot Store Scraper** is ideal for tracking price changes over time:

1. **Save your input as a Task** in Apify Console
2. **Go to Schedules** and set the frequency (e.g., daily at 8am, or weekly on Mondays)
3. **Add a webhook** to receive data in Slack, email, Google Sheets, or your own endpoint
4. **Compare datasets** across runs to detect price changes, new discounts, or stock movements

### Related Rastriq Actors

Explore the full [Rastriq automotive intelligence portfolio](https://apify.com/rastriq) on Apify Store:

| Actor | Description |
|-------|-------------|
| [Coches.net Scraper](https://apify.com/rastriq/cochesnet-spain) | Extract car listings from Spain's largest classifieds platform |
| [Wallapop Cars Scraper](https://apify.com/rastriq/wallapop-cars-scraper) | Scrape used car listings from Wallapop Spain |
| [Mobile.de Scraper](https://apify.com/rastriq/mobile-de-scraper) | Extract car marketplace data from Germany |
| [Collecting Cars Scraper](https://apify.com/rastriq/collecting-cars-scraper) | Online car auction data extraction |

### Frequently Asked Questions

#### Is scraping the Peugeot online store legal?

**Peugeot Store Scraper** accesses **publicly available data** from the official Peugeot configurator — information visible to any visitor without logging in. The actor respects rate limiting and uses reasonable delays between requests. As with any data collection, you are responsible for ensuring your use case complies with applicable laws and terms of service. For guidance, see [Apify's blog on the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

#### Can I compare Peugeot prices across different European countries?

Yes — that is the core strength of **Peugeot Store Scraper**. Simply run the actor multiple times with different `market` codes (or schedule parallel runs) and compare the output datasets. The same model slug works across all 11 markets, so you can directly compare prices for a Peugeot 3008 in Spain vs. Poland vs. Germany vs. the UK.

#### What is the difference between GraphQL and Config V3 markets?

GraphQL markets (🇪🇸🇫🇷🇮🇹🇵🇹🇬🇧) use the Peugeot store's GraphQL API and support full enumeration of every trim × engine × color combination, including stock counts and finance offers. Config V3 markets (🇵🇱🇩🇪🇦🇹🇭🇺🇭🇷🇧🇷) use the Stellantis Config V3 REST API, which returns all versions in a single call — faster and cheaper, but without stock or finance data.

#### Does Peugeot Store Scraper require a Peugeot account?

No. The actor works entirely with public configurator data and does not require any account, login, or API credentials.

#### Which Peugeot models are available?

For GraphQL markets: any model listed on the Peugeot online store. Common slugs: `208`, `2008-suv`, `308`, `308-sw`, `408`, `508`, `508-sw`, `3008-suv`, `5008-suv`, `rifter`, `partner`, `traveller`, `expert`. Electric variants: `e-208`, `e-2008`. For Config V3 markets, availability varies by country — see the supported markets table above.

#### What proxy configuration should I use?

Datacenter proxies work well for the Peugeot store. The actor automatically uses Apify proxies when running on the platform. No special proxy configuration is needed.

#### How do I integrate Peugeot Store Scraper with my workflow?

**Peugeot Store Scraper** integrates natively with **Make**, **Zapier**, **Google Sheets**, **webhooks**, and the **Apify API** (Python, Node.js, or any language). Check the API tab for ready-to-use code snippets.

#### I found a bug or my run failed. Where do I report it?

Please open an issue in the **Issues tab** on this page. Include your input configuration and the run ID so we can investigate quickly.

***

### 🇪🇸 Versión en español

> Esta sección es un resumen en español del README anterior.

#### ¿Qué es Peugeot Store Scraper?

**Peugeot Store Scraper** extrae configuraciones de vehículos, precios, especificaciones técnicas y disponibilidad de stock del configurador oficial de Peugeot en **11 mercados**: 🇪🇸 España, 🇫🇷 Francia, 🇮🇹 Italia, 🇵🇹 Portugal, 🇬🇧 Reino Unido, 🇵🇱 Polonia, 🇩🇪 Alemania, 🇦🇹 Austria, 🇭🇺 Hungría, 🇭🇷 Croacia y 🇧🇷 Brasil. Utiliza una arquitectura dual (GraphQL + Config V3 REST) para cubrir la máxima cantidad de países. Enumera automáticamente todas las combinaciones de acabado, motor y color para cada modelo, permitiendo comparar precios entre países.

#### ¿Qué datos extrae Peugeot Store Scraper?

| Campo | Descripción |
|-------|-------------|
| 🚗 Modelo, acabado y carrocería | Identificación completa del vehículo |
| ⚙️ Motor, cambio y combustible | Configuración mecánica y potencia (kW) |
| 💶 Precio al contado | Total con y sin IVA, precio de catálogo, descuentos |
| 💳 Financiación | Cuota mensual, entrada, TAE, plazo |
| 📦 Stock disponible | Unidades disponibles por configuración (mercados GraphQL) |
| ⏱️ Plazo de entrega | Semanas de espera y fecha estimada |
| 🌿 Emisiones y WLTP | CO2 combinado, consumo combinado, autonomía eléctrica |
| 🎨 Colores disponibles | Lista completa de opciones exteriores e interiores |

#### ¿Cómo usar Peugeot Store Scraper?

1. Crea una cuenta gratuita en [apify.com](https://apify.com)
2. Abre **Peugeot Store Scraper** y selecciona el mercado con bandera 🌍
3. Elige los modelos a scrapear (deja vacío para obtener todos los disponibles en ese mercado)
4. Configura el límite de combinaciones (5–10 para pruebas, 0 para catálogo completo)
5. Haz clic en **Start** y descarga los resultados en JSON, CSV o Excel

#### ¿Cuánto cuesta usar Peugeot Store Scraper?

El actor funciona con el sistema estándar de Compute Units de Apify. Extraer todas las configuraciones de un modelo cuesta aproximadamente $0.02. Los mercados Config V3 (🇵🇱🇩🇪🇦🇹🇭🇺🇭🇷🇧🇷) son significativamente más baratos. Los primeros $5 de crédito son gratuitos, suficientes para miles de configuraciones.

# Actor input Schema

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

Select the Peugeot market to scrape.<br><br><b>GraphQL markets</b> (full enumeration, stock & finance data): 🇪🇸 🇫🇷 🇮🇹 🇵🇹 🇬🇧<br><b>Config V3 markets</b> (flat version list, faster & cheaper): 🇵🇱 🇩🇪 🇦🇹 🇭🇺 🇭🇷 🇧🇷<br><br>The actor auto-detects which backend to use.

## `models` (type: `array`):

Select one or more Peugeot models to scrape. <b>Leave empty to scrape all available models</b> in the selected market.<br><br>Electric models are marked with ⚡. Not all models are available in every market — the actor skips unavailable ones automatically.<br><br>For GraphQL markets (🇪🇸🇫🇷🇮🇹🇵🇹🇬🇧) the slug matches the configurator URL: <code>store.peugeot.es/selector/configurable/<b>2008-suv</b></code>

## `maxCombinationsPerModel` (type: `integer`):

Maximum trim × engine × colour combinations per model. Use <b>5–10</b> for a quick test run. Set to <b>0</b> for unlimited (full catalogue).

## `includeStockCount` (type: `boolean`):

Query stock availability for each configuration. Only applies to <b>GraphQL markets</b> (🇪🇸🇫🇷🇮🇹🇵🇹🇬🇧). Adds one extra API call per combination.

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

Language code for the Peugeot store interface. Only used for <b>GraphQL markets</b> (🇪🇸🇫🇷🇮🇹🇵🇹🇬🇧). Config V3 markets (🇵🇱🇩🇪🇦🇹🇭🇺🇭🇷🇧🇷) auto-detect the language.

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

Select proxies for the scraping run. Datacenter proxies work fine for this site.

## `requestDelay` (type: `integer`):

Delay between API requests in milliseconds. Increase if you get rate-limited.

## `debugMode` (type: `boolean`):

Enable verbose logging for troubleshooting. Not recommended for production runs.

## Actor input object example

```json
{
  "market": "es",
  "models": [],
  "maxCombinationsPerModel": 10,
  "includeStockCount": true,
  "language": "es",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestDelay": 500,
  "debugMode": false
}
```

# Actor output Schema

## `results` (type: `string`):

Structured dataset of Peugeot vehicle configurations. Each record contains 50+ fields covering identity (model, trim, engine, colours), cash pricing (total, catalog, savings, discounts), finance offers (monthly payment, APR, deposit, term), stock and lead time (GraphQL markets only), WLTP emissions, and metadata (market code, source API, scraped timestamp).

# 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 = {
    "models": [],
    "maxCombinationsPerModel": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/peugeot-store-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 = {
    "models": [],
    "maxCombinationsPerModel": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/peugeot-store-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 '{
  "models": [],
  "maxCombinationsPerModel": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rastriq/peugeot-store-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=rastriq/peugeot-store-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Peugeot Store Scraper: 11 Markets Worldwide",
        "description": "Extract vehicle configurations, pricing, specs, stock and finance from Peugeot across 11 markets (ES, FR, IT, PT, GB, PL, DE, AT, HU, HR, BR). All trims, engines and colours. Dual-backend: GraphQL + Config V3 REST API.",
        "version": "0.1",
        "x-build-id": "FaLP49xvyX304dovw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rastriq~peugeot-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rastriq-peugeot-store-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/rastriq~peugeot-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-rastriq-peugeot-store-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/rastriq~peugeot-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-rastriq-peugeot-store-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",
                "properties": {
                    "market": {
                        "title": "🌍 Market",
                        "enum": [
                            "es",
                            "fr",
                            "it",
                            "pt",
                            "gb",
                            "pl",
                            "de",
                            "at",
                            "hu",
                            "hr",
                            "br"
                        ],
                        "type": "string",
                        "description": "Select the Peugeot market to scrape.<br><br><b>GraphQL markets</b> (full enumeration, stock & finance data): 🇪🇸 🇫🇷 🇮🇹 🇵🇹 🇬🇧<br><b>Config V3 markets</b> (flat version list, faster & cheaper): 🇵🇱 🇩🇪 🇦🇹 🇭🇺 🇭🇷 🇧🇷<br><br>The actor auto-detects which backend to use.",
                        "default": "es"
                    },
                    "models": {
                        "title": "🚗 Models",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more Peugeot models to scrape. <b>Leave empty to scrape all available models</b> in the selected market.<br><br>Electric models are marked with ⚡. Not all models are available in every market — the actor skips unavailable ones automatically.<br><br>For GraphQL markets (🇪🇸🇫🇷🇮🇹🇵🇹🇬🇧) the slug matches the configurator URL: <code>store.peugeot.es/selector/configurable/<b>2008-suv</b></code>",
                        "items": {
                            "type": "string",
                            "enumSuggestedValues": [
                                "208",
                                "e-208",
                                "2008-suv",
                                "e-2008",
                                "308",
                                "308-sw",
                                "3008-suv",
                                "408",
                                "508",
                                "508-sw",
                                "5008-suv",
                                "rifter",
                                "partner",
                                "traveller",
                                "expert"
                            ],
                            "enumTitles": [
                                "208",
                                "⚡ e-208 (electric)",
                                "2008 SUV",
                                "⚡ e-2008 (electric)",
                                "308",
                                "308 SW",
                                "3008 SUV",
                                "408",
                                "508",
                                "508 SW",
                                "5008 SUV",
                                "Rifter",
                                "Partner",
                                "Traveller",
                                "Expert"
                            ]
                        }
                    },
                    "maxCombinationsPerModel": {
                        "title": "Max combinations per model",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum trim × engine × colour combinations per model. Use <b>5–10</b> for a quick test run. Set to <b>0</b> for unlimited (full catalogue).",
                        "default": 0
                    },
                    "includeStockCount": {
                        "title": "Include stock count",
                        "type": "boolean",
                        "description": "Query stock availability for each configuration. Only applies to <b>GraphQL markets</b> (🇪🇸🇫🇷🇮🇹🇵🇹🇬🇧). Adds one extra API call per combination.",
                        "default": true
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "es",
                            "fr",
                            "it",
                            "pt",
                            "en",
                            "pl",
                            "de",
                            "hu",
                            "hr"
                        ],
                        "type": "string",
                        "description": "Language code for the Peugeot store interface. Only used for <b>GraphQL markets</b> (🇪🇸🇫🇷🇮🇹🇵🇹🇬🇧). Config V3 markets (🇵🇱🇩🇪🇦🇹🇭🇺🇭🇷🇧🇷) auto-detect the language.",
                        "default": "es"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies for the scraping run. Datacenter proxies work fine for this site."
                    },
                    "requestDelay": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between API requests in milliseconds. Increase if you get rate-limited.",
                        "default": 500
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Enable verbose logging for troubleshooting. Not recommended for production runs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
