# Leboncoin Real Time Data Scraper (`b2b_leads/leboncoin-real-time-data-scraper`) Actor

Live Leboncoin classifieds intelligence: keyword search across 60+ French categories, full ad details, pro store inventory, seller profiles, price-history watchlists, and URL collection. Stream structured JSON in real time with webhooks, Slack alerts & MCP. Free 2-result trial.

- **URL**: https://apify.com/b2b\_leads/leboncoin-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.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/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

## Leboncoin Real-Time Data

> **Live Leboncoin classifieds market intelligence** — France's largest classifieds platform, streamed to your dataset in real time. Keyword search across 60+ categories (vehicles, real estate, fashion, electronics, home, jobs…), full ad details, pro store inventory tracking, seller profiles, and direct URL collection.

**ⓘ Free plan notice:** on Apify free plans this Actor returns a 2-result trial per run. Paid plans get full, uncapped output. See [Free tier](#-free-tier--paid-plans) below.

> 🔁 **Watchlist-ready:** every run also exports a paste-able **`WATCHLIST`** (`{"adId", "lastPrice"}` entries built from *every* ad row) — feed it into the **Price History** feature on your next run to track price drops and delistings over time. See [The watchlist loop](#-the-watchlist-loop--price-history-with-one-click-setup).

Leboncoin is where France buys and sells — tens of millions of live ads across every category and every department. This Actor turns that live catalog into clean, structured rows for resellers, market watchers, lead-gen teams, and AI agents.

***

### 👥 Who is this for

- **Cross-listers & resale arbitrageurs** sourcing French vintage fashion, sneakers, and collectibles to flip on Vinted, Depop, Grailed, eBay, or across borders.
- **Dealerships & pro sellers** tracking competitor store inventory, prices, and new arrivals in their category and region.
- **Real-estate & rental watchers** following listings by department with price and seller-type filters.
- **Lead-gen & outreach teams** building verified business lists from professional sellers (name, SIREN, city, store profile).
- **Pricing teams & researchers** modeling ask-price distributions across categories and regions.
- **AI agents & automation** (Apify MCP, n8n, Make, custom bots) that need clean, structured French classifieds data.

### 🔁 The watchlist loop — price history with one-click setup

This is the feature that turns one-off scrapes into **market monitoring**:

1. **Run anything** — search, store inventory, scrape-by-url, details… every ad row the Actor saves also lands in a ready-made **`WATCHLIST`** export: a clean JSON array of `{"adId": "…", "lastPrice": 59}` entries. No manual copying, no column mapping.
   - Platform runs: the default key-value store, key **`WATCHLIST`** (also linked from the run OUTPUT as `watchlistCount`).
   - Local runs: **`output/watchlist.json`**.
2. **Feed it back** — paste the array into the **Price History** feature's `watchlist` input (or hand-pick entries).
3. **Schedule it** — daily or hourly runs now emit one `price_changed` row per tracked ad: price drops (negative `price_change`), raises, and `is_delisted: true` when an ad sells or disappears.
4. **Get told only when it matters** — with a webhook configured, watchlist runs are in **alert mode**: unchanged ads stay quiet, and only actual price moves and delistings are POSTed. Your Slack channel shows signals, not noise.

```
{
  "ad_id": "3261759281",
  "previous_price": 59,
  "current_price": 49,
  "price_change": -10,
  "price_change_percent": -16.9,
  "is_delisted": false
}
```

### 🎯 Use cases

- **Fresh-inventory deal alerts** — "Newest first" search for `carhartt`, `vintage levis 501`, `patagonia fleece`; webhook fires per record for instant Slack/Discord pings.
- **Competitor store surveillance** — watch any pro dealership's full live inventory; get alerts when new stock lands or prices move.
- **Regional price mapping** — same keyword across departments with min/max price filters to map ask-price spreads.
- **Pro seller prospecting** — pull store name, SIREN, city, and rating aggregates for outreach lists.
- **Watchlist price tracking** — the one-click `WATCHLIST` export plus the Price History feature turn any run into a scheduled price-drop monitor with quiet-until-it-matters webhooks.
- **Cross-border arbitrage** — compare French street prices against US/UK platforms before you buy or list.
- **Category analytics** — total result counts (pro vs private) per query give instant supply-side signals.

***

### ✨ Features (checkbox UX — enable only what you need)

| Feature | Checkbox | What you get |
|---|---|---|
| **Listing Search** 🔍 | `enableListingSearch` (default **on**) | Live keyword search with category, department, price, and seller-type filters, sorted by newest/price/relevance, up to 350 results per keyword. Streamed row-by-row in seconds. |
| **Listing Details** 📦 | `enableListingDetails` | Full record for specific ad URLs or IDs: complete description, all category attributes (brand, mileage, surface, rooms…), seller identity, location, favorites. |
| **Store Inventory** 🏬 | `enableStoreInventory` | The full live inventory of any professional store or dealership — competitor stock and repricing surveillance. |
| **Seller Profile** 👤 | `enableSellerProfile` | Storefront identity and stats: name, slogan, description, address, opening hours, website, Google-rating aggregates, SIREN, activity sector, live ad count. |
| **Scrape By URL** 🔗 | `enableScrapeByUrl` | Paste any Leboncoin URL (search, ad, store, category) — page type is auto-detected. |
| **Price History** 💲 | `enablePriceHistory` | Recheck a saved watchlist of ads; one `price_changed` row per ad with the price delta, percent change, and a delisted flag for ads no longer live. Built for scheduled watchlist runs. |

#### Enrichment — in-place, never filtered

**"Enrich with full ad details"** (`searchFetchFullDetails`) upgrades each search row **in place**: the row keeps `featureType: "listing_search"` and gets `detailsFetched: true` plus the full description, native category attributes, and favorites count.

- **No duplicate rows.** One ad = one row, always.
- **No filtered-out partial items.** Every discovered ad goes to the dataset, even if enrichment fails for that one ad (it's saved as a fast card).

***

### 🚀 Quick start

1. Click **Start** — Listing Search is prefilled with 3 demo keywords (`carhartt`, `vintage levis 501`, `patagonia fleece`) and 10 results each, so your first run finishes in seconds.
2. Optional: set a **Webhook URL** for real-time Slack/Discord alerts.
3. Optional: turn on **Enrich with full ad details** for deeper rows (adds a little extra time per record to enrich full details).

#### Practical search examples

| Goal | Keywords | Category | Filters |
|---|---|---|---|
| Vintage fashion sourcing | `vintage levis 501`, `carhartt` | Vêtements | — |
| Sneaker deals | `jordan 1`, `new balance 550` | Chaussures | Max price 100 |
| Bike flipping | `velo route`, `vtt electrique` | Vélos | Sort: Newest first |
| Regional auto pricing | `renault clio` | Voitures | Department `75` / `69` |
| Pro-only supply | any keyword | any | Seller type: Professional only |

> French keywords return the deepest inventory — Leboncoin is a French-first marketplace.

***

### ⚙️ Input reference

#### 🔍 Listing Search

| Field | Type | Default | Notes |
|---|---|---|---|
| `enableListingSearch` | boolean | `true` | Master switch for keyword search. |
| `searchKeywords` | stringList | 3 demo keywords | One or more terms. Required when search is on. |
| `searchMaxResults` | integer | `10` | Per keyword, 1–350. |
| `searchCategoryId` | select | *(any)* | One Leboncoin category ID (e.g. `2` Voitures, `15` Vêtements, `10` Locations, `39` Vélos). |
| `searchSort` | select | `date` | `relevance`, `date` (newest), `price_asc`, `price_desc`. |
| `searchMinPrice` / `searchMaxPrice` | integer | — | Price window in EUR. |
| `searchDepartmentCode` | string | — | French department code: `75` Paris, `69` Rhône, `33` Gironde, `13` Bouches-du-Rhône… |
| `searchOwnerType` | select | *(all)* | `private` or `pro`. |
| `searchFetchFullDetails` | boolean | `false` | Enrich each search row in place (adds a little extra time per record). |

#### 📦 Listing Details

| Field | Type | Notes |
|---|---|---|
| `enableListingDetails` | boolean | Master switch. |
| `listingUrls` | stringList | Full ad URLs (`https://www.leboncoin.fr/ad/...`). |
| `listingIds` | stringList | Numeric ad IDs (e.g. `3261759281`). |

#### 🏬 Store Inventory / 👤 Seller Profile

| Field | Type | Default | Notes |
|---|---|---|---|
| `enableStoreInventory` / `enableSellerProfile` | boolean | `false` | Feature switches. |
| `storeUrls` | stringList | — | Store URLs (`https://www.leboncoin.fr/boutique/...`) or numeric store IDs. Shared by both features. |
| `storeMaxListings` | integer | `30` | Max ads per store (1–500). |

#### 🔗 Scrape By URL

| Field | Type | Notes |
|---|---|---|
| `enableScrapeByUrl` | boolean | Master switch. |
| `scrapeUrls` | stringList | Any Leboncoin search, ad, store, or category URL. Non-Leboncoin URLs are rejected with a clear error. |

#### 💲 Price History

| Field | Type | Notes |
|---|---|---|
| `enablePriceHistory` | boolean | Master switch. |
| `watchlist` | json list | Objects `{"adId": "3261759281", "lastPrice": 59}` — paste the `WATCHLIST` export from any earlier run. With a baseline, rows carry `price_change` and `price_change_percent`. |
| `watchlistIds` | stringList | Numeric ad IDs to recheck without a price baseline. |

Every run also produces the export for you — see [The watchlist loop](#-the-watchlist-loop--price-history-with-one-click-setup).

#### 🔔 Delivery

| Field | Type | Default | Notes |
|---|---|---|---|
| `webhookUrl` | string | — | Every row is POSTed here as well as saved to the dataset. Slack, Discord, Zapier, Make, n8n, or your own bot. |
| `webhookFormat` | select | `json` | `json` = full record object; `slack` = Slack-friendly message. |

#### 🌐 Connection

Residential proxies are recommended and pre-configured. Configurable via the standard Apify proxy editor.

***

### 📤 Output reference

One dataset row per ad or seller. Filter by `featureType`:

`listing_search` · `listing_details` · `store_inventory` · `seller_profile` · `scrape_by_url` · `price_changed`

#### Core fields

| Field | Type | Description |
|---|---|---|
| `featureType` | string | Which feature produced the row. |
| `scrapedAt` | ISO date | When the row was written. |
| `url` / `ad_url` | string | Leboncoin ad or source URL. |
| `ad_id` | string | Native numeric ad ID (for dedupe & re-checks). |
| `title` / `description` | string | Seller-written copy. |
| `main_image_url`, `additional_image_urls`, `image_count` | string/array/number | Image gallery. |
| `status` | string | Live ad status (e.g. `active`). |
| `current_price` / `currency` | number/string | Asking price in EUR. |
| `category_id` / `category_name` | string | Leboncoin category (e.g. `Voitures`). |
| `ad_type` | string | `offer` or `request`. |
| `first_publication_date` / `index_date` | string | Publish and refresh timestamps. |
| `is_newly_listed` | boolean | `true` when published in the last 24h. |
| `location_city` / `location_zipcode` / `location_department` / `location_department_code` / `location_region` | string | French geography. |
| `location_lat` / `location_lng` | number | Ad coordinates. |
| `seller_name` / `seller_id` / `seller_store_id` / `seller_type` / `seller_siren` | string | Seller identity; `pro` vs `private`; SIREN for companies. |
| `seller_has_phone` | boolean | Phone contact available. |
| `favorites_count` | number | Favorites (on enriched/detail rows). |
| `is_promoted` / `is_urgent` / `is_shippable` | boolean | Seller boost flags. |
| `search_total` / `total_pro` / `total_private` / `shippable_total` | number | Query-level supply counts (on search rows). |
| `position` | number | Rank within the page the ad was found on. |
| `detailsFetched` | boolean | `true` when a search row was enriched in place. |

#### Per-feature extras

- **`listing_details`** (and enriched search rows): `attributes` — the native attribute map for the ad's category (`brand`, `mileage`, `square`, `rooms`, `fuel`, `gearbox`, `regdate`…), plus `attribute_labels` with French display labels (`"Kilométrage": "55 400 km"`).
- **`seller_profile`**: `store_name`, `store_slogan`, `store_description`, `store_address`, `store_opening_hours`, `store_website`, `store_logo_url`, `store_rating`, `store_rating_count`, `store_active_since`, `store_activity_sector`, `store_ads_total`.
- **`scrape_by_url`**: `pageType` tells you which kind of Leboncoin page was processed (`search`, `store`, `listing`).
- **`price_changed`**: `previous_price`, `price_change` (negative = drop), `price_change_percent`, `is_delisted` — the watchlist tracking row.

#### Dataset views

The Console dataset includes ready-made table views: **Overview**, **Listing Search**, **Listing Details**, **Store Inventory**, **Seller Profiles**, **Scrape By URL**, and **Price History**.

***

### 🔔 Webhook guide

Set `webhookUrl` and every saved record is also POSTed there, fire-and-forget (dataset writes never wait on webhook latency).

**Watchlist runs are alert-mode.** On Price History runs the webhook is smart: unchanged ads are saved to the dataset and the `WATCHLIST` export but are **not** POSTed — only price moves (`price_change ≠ 0`) and delistings hit your URL. Normal search/inventory runs always POST every row.

**JSON format** — the full record object, exactly as saved to the dataset. Great for Make, n8n, Zapier, or your own pricing bot:

```json
{
  "featureType": "listing_search",
  "title": "Veste Carhartt Detroit vintage",
  "current_price": 85,
  "currency": "EUR",
  "category_name": "Vêtements",
  "location_city": "Lyon",
  "seller_name": "vintage69",
  "seller_type": "private",
  "ad_url": "https://www.leboncoin.fr/ad/vetements/…",
  "detailsFetched": false
}
```

**Slack format** — a compact message card:

```
:department_store: *Veste Carhartt Detroit vintage*
*Type:* listing_search  •  *Price:* EUR 85  •  *Category:* Vêtements  •  *City:* Lyon  •  *Seller:* vintage69 (private)
<https://www.leboncoin.fr/ad/vetements/…|Open on Leboncoin>
```

Discord works out of the box: paste a Discord webhook URL and use the **Slack** format — Discord translates the payload.

***

### 🤖 MCP / AI agent usage

This Actor is MCP-compatible via the Apify MCP server. Point your agent at it and ask things like:

- *"What's the average asking price for a used Renault Clio on Leboncoin?"*
- *"Find vintage Levi's 501 under €50 listed in the last 24 hours."*
- *"Monitor this dealership's store inventory and alert me on Slack when anything new appears."*
- *"How many pro vs private sellers are listing Patagonia fleece in France right now?"*
- *"Recheck my watchlist and tell me which ads dropped more than 10% since last week."*

The output contract (stable `featureType` + shared core fields) is designed for downstream union across the classifieds-data suite, so the same agent prompt works across marketplaces.

***

### 💰 Free tier & paid plans

- **Free Apify plans** get a **2-result trial per run** — enough to validate output shape and webhook delivery. When the cap hits, the run stops gracefully with an upgrade notice (never an error).
- **Paid plans** get full, uncapped output for every enabled feature.
- The `OUTPUT` object of every run includes a transparent `paywall` summary (`detected`, `isPaying`, `limited`, `blocked`, `freeTierMaxItems`).
- Store owners can configure the cap via Console environment variables (`FREE_TIER_MODE` = `limit`|`block`, `FREE_TIER_MAX_ITEMS`).

This is disclosed in the Actor's input schema (Delivery section) and in this README's first screen.

***

### ❓ FAQ

**How fresh is the data?** Every run queries the live marketplace — ads reflect what's on the platform right now, including fresh listings, price changes, and seller boosts. For deal alerts, schedule runs every 5–15 minutes with "Newest first" sort.

**Do I need proxies?** Residential proxies are recommended and pre-configured for the platform. They deliver the most reliable runs at scale.

**Why does my run stop at 2 results?** You're on an Apify free plan — the 2-result trial is the free-tier cap. Upgrade to a paid plan for full output.

**Is there a limit on results?** Paid runs are limited only by your inputs: up to 350 results per keyword and 500 ads per store, across any number of keywords/stores. The 10,000-second platform timeout allows very large runs, and rows stream to the dataset as they're collected (memory stays light).

**Can I track dealers instead of keywords?** Yes — `storeUrls` powers Store Inventory and Seller Profile. Use the store URL (`https://www.leboncoin.fr/boutique/...`) or numeric store ID.

**How does the price watchlist work?** You don't have to build it: every run saves a `WATCHLIST` export (`adId` + `lastPrice` entries for every ad row). Feed it into Price History, schedule, and each run emits `price_changed` rows with the delta and percent change; ads that have sold or been removed come back flagged `is_delisted` instead of vanishing silently. With a webhook configured, only actual changes alert you — unchanged ads stay quiet.

**Will my webhook get spammed on daily watchlist runs?** No. Alert mode POSTs only price changes and delistings; an unchanged ad is saved silently. Search/inventory runs (without Price History) always POST every row.

**Does Leboncoin show sold ads?** Marketplace ads are removed when sold, so the live catalog reflects what's actually available — that's what makes "Newest first" monitoring valuable.

**Which department codes work?** All French departments: `75` Paris, `13` Bouches-du-Rhône, `69` Rhône, `31` Haute-Garonne, `33` Gironde, `59` Nord… Leave empty for all of France.

***

### 🧾 Notes

- Run `OUTPUT` includes `totalPushed`, `spendingLimitReached`, the `paywall` summary, and `watchlistCount`.
- Platform runs save the watchlist export to the key-value store under `WATCHLIST`; local runs write `output/watchlist.json`.
- Local development: copy `.env.example` → `.env`, `local.input.example.json` → `local.input.json`, then `npm run start:local`.
- Respect Leboncoin's Terms of Service and applicable data-protection law when using marketplace data.

# Actor input Schema

## `enableListingSearch` (type: `boolean`):

Live keyword search across Leboncoin — vehicles, real estate, fashion, electronics, home & garden, and more. On by default and prefilled so you can click Start and get results in seconds.

## `searchKeywords` (type: `array`):

One or more search terms, e.g. "carhartt", "vintage levis 501", "patagonia fleece", "renault clio". French queries return the deepest inventory. Required when Listing Search is on.

## `searchMaxResults` (type: `integer`):

Maximum ads to return for each keyword (1–350). Default 10 — perfect for instant demo runs.

## `searchCategoryId` (type: `string`):

Restrict a search to one Leboncoin category. Leave empty for all categories.

## `searchSort` (type: `string`):

How to order search results. "Newest first" is ideal for deal alerts on fresh inventory.

## `searchMinPrice` (type: `integer`):

Minimum ad price in EUR.

## `searchMaxPrice` (type: `integer`):

Maximum ad price — pair with "Newest first" sort to catch underpriced steals fast.

## `searchDepartmentCode` (type: `string`):

French department (département) code, e.g. 75 for Paris, 69 for Rhône, 33 for Gironde.

## `searchOwnerType` (type: `string`):

Restrict results to private sellers or professional businesses.

## `searchFetchFullDetails` (type: `boolean`):

When on, each search result stays ONE row (featureType listing\_search, detailsFetched=true) but is enriched with the full description, category attributes, seller identity, and favorites count. Adds a little extra time per record to enrich full details. When off, you get fast search cards with price, title, images, seller, and location. Every discovered item is always saved — never filtered out.

## `enableListingDetails` (type: `boolean`):

Fetch the full record for specific Leboncoin ads by URL or ad ID.

## `listingIds` (type: `array`):

Numeric Leboncoin ad IDs, e.g. 3261759281.

## `listingUrls` (type: `array`):

Full Leboncoin ad URLs (https://www.leboncoin.fr/ad/...).

## `enableStoreInventory` (type: `boolean`):

Collect the full live inventory of any professional store or dealership — track competitor stock, prices, and new arrivals.

## `storeUrls` (type: `array`):

Leboncoin boutique URLs (https://www.leboncoin.fr/boutique/<id>/<slug>.htm) or numeric store IDs (e.g. 85343). Shared by Store Inventory and Seller Profile.

## `storeMaxListings` (type: `integer`):

Maximum ads to collect per store (1–500).

## `enableSellerProfile` (type: `boolean`):

Extract seller identity and stats: name, type (private/pro), SIREN registration, store address, opening hours, description, Google-rating aggregates for professional stores, and profile picture.

## `enableScrapeByUrl` (type: `boolean`):

Paste any Leboncoin URL — search results, single ad, store page, or category listing.

## `scrapeUrls` (type: `array`):

Any Leboncoin search, ad, store, or category URL.

## `enablePriceHistory` (type: `boolean`):

Recheck a saved watchlist of ads and emit one price\_changed row per ad — price drops, raises, or a delisted flag. Ideal for scheduled runs that track a watchlist over time.

## `watchlist` (type: `array`):

Objects with adId and lastPrice, e.g. {"adId": "3261759281", "lastPrice": 59}. Paste ad\_id/current\_price pairs saved from earlier runs. When lastPrice is set, each price\_changed row carries price\_change and price\_change\_percent.

## `watchlistIds` (type: `array`):

Numeric ad IDs to recheck without a saved price baseline — rows will report the current price and delisted state.

## `webhookUrl` (type: `string`):

Optional. Every record is always saved to the run dataset — this webhook is an ADDITIONAL real-time push. Each new row is also POSTed to this URL (Slack, Discord, Zapier, Make, n8n, custom pricing bot).

## `webhookFormat` (type: `string`):

json = full record object; slack = Slack-friendly message payload.

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

Residential proxy recommended. US residential routing is pre-configured and delivers the most reliable results.

## Actor input object example

```json
{
  "enableListingSearch": true,
  "searchKeywords": [
    "carhartt",
    "vintage levis 501",
    "patagonia fleece"
  ],
  "searchMaxResults": 10,
  "searchCategoryId": "",
  "searchSort": "date",
  "searchDepartmentCode": "",
  "searchOwnerType": "",
  "searchFetchFullDetails": false,
  "enableListingDetails": false,
  "listingIds": [],
  "listingUrls": [],
  "enableStoreInventory": false,
  "storeUrls": [],
  "storeMaxListings": 30,
  "enableSellerProfile": false,
  "enableScrapeByUrl": false,
  "scrapeUrls": [
    "https://www.leboncoin.fr/recherche?text=carhartt"
  ],
  "enablePriceHistory": false,
  "watchlist": [],
  "watchlistIds": [],
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Full dataset for this run (every featureType).

## `watchlist` (type: `string`):

Paste-able {adId, lastPrice} entries built from every ad row — feed into the Price History feature on your next run.

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

Core fields across features, including detailsFetched for search rows.

## `search` (type: `string`):

featureType=listing\_search only. One ad = one row; full details are merged when "Enrich with full ad details" is enabled.

## `details` (type: `string`):

featureType=listing\_details — only from the Listing Details feature (specific IDs/URLs), not from search enrichment.

## `store_inventory` (type: `string`):

No description

## `seller_profile` (type: `string`):

No description

## `scrape_by_url` (type: `string`):

No description

## `price_changed` (type: `string`):

featureType=price\_changed — one row per rechecked watchlist ad, with price\_change, price\_change\_percent, and a delisted flag for ads no longer live.

# 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 = {
    "enableListingSearch": true,
    "searchKeywords": [
        "carhartt",
        "vintage levis 501",
        "patagonia fleece"
    ],
    "searchMaxResults": 10,
    "searchCategoryId": "",
    "searchSort": "date",
    "searchDepartmentCode": "",
    "searchOwnerType": "",
    "searchFetchFullDetails": false,
    "enableListingDetails": false,
    "listingIds": [],
    "listingUrls": [],
    "enableStoreInventory": false,
    "storeUrls": [],
    "storeMaxListings": 30,
    "enableSellerProfile": false,
    "enableScrapeByUrl": false,
    "scrapeUrls": [
        "https://www.leboncoin.fr/recherche?text=carhartt"
    ],
    "enablePriceHistory": false,
    "watchlist": [],
    "watchlistIds": [],
    "webhookFormat": "json",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/leboncoin-real-time-data-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 = {
    "enableListingSearch": True,
    "searchKeywords": [
        "carhartt",
        "vintage levis 501",
        "patagonia fleece",
    ],
    "searchMaxResults": 10,
    "searchCategoryId": "",
    "searchSort": "date",
    "searchDepartmentCode": "",
    "searchOwnerType": "",
    "searchFetchFullDetails": False,
    "enableListingDetails": False,
    "listingIds": [],
    "listingUrls": [],
    "enableStoreInventory": False,
    "storeUrls": [],
    "storeMaxListings": 30,
    "enableSellerProfile": False,
    "enableScrapeByUrl": False,
    "scrapeUrls": ["https://www.leboncoin.fr/recherche?text=carhartt"],
    "enablePriceHistory": False,
    "watchlist": [],
    "watchlistIds": [],
    "webhookFormat": "json",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/leboncoin-real-time-data-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 '{
  "enableListingSearch": true,
  "searchKeywords": [
    "carhartt",
    "vintage levis 501",
    "patagonia fleece"
  ],
  "searchMaxResults": 10,
  "searchCategoryId": "",
  "searchSort": "date",
  "searchDepartmentCode": "",
  "searchOwnerType": "",
  "searchFetchFullDetails": false,
  "enableListingDetails": false,
  "listingIds": [],
  "listingUrls": [],
  "enableStoreInventory": false,
  "storeUrls": [],
  "storeMaxListings": 30,
  "enableSellerProfile": false,
  "enableScrapeByUrl": false,
  "scrapeUrls": [
    "https://www.leboncoin.fr/recherche?text=carhartt"
  ],
  "enablePriceHistory": false,
  "watchlist": [],
  "watchlistIds": [],
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/leboncoin-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/leboncoin-real-time-data-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/fWM0xpEHBPmQNDv4p/builds/u5ERsz3dNxErkD3u4/openapi.json