# Oscaro Scraper — French Car Parts, Prices & Stock (`studio-amba/oscaro-scraper`) Actor

Scrape car parts from oscaro.com: names, brands, manufacturer part numbers, prices, stock status, ratings and images. Crawls Oscaro's paginated part-group catalogue pages and optionally enriches every product with the full detail-page record (description, availability, rating).

- **URL**: https://apify.com/studio-amba/oscaro-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 result scrapeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Oscaro Scraper — French Car Parts, Prices & Stock

Pull car part names, brands, manufacturer part numbers (MPN), prices, live stock status and ratings from Oscaro, one of France's largest online aftermarket parts retailers. No login, no vehicle plate lookup, and no Bright Data key needed — this actor handles Oscaro's Cloudflare challenge itself.

### What is Oscaro Scraper?

Oscaro sells aftermarket car parts (brake pads, discs, filters, oil, and more) to the French market. Its catalogue is organized by part type rather than free-text search — each part-group page (URLs ending in `-g`) carries a full, paginated listing for one specific product family, for example "4-piece front brake pad set". This actor crawls those listing pages and, optionally, renders every product's own detail page for the deeper record (stock status, description, rating).

- **Price monitoring** — Track aftermarket part prices on the French market over time
- **Stock signal** — Know which SKUs are actually sellable right now, not just listed
- **Catalog enrichment** — Pull brand, MPN and images to enrich a parts database or marketplace listing
- **Assortment analysis** — See which brands (BOSCH, BREMBO, ATE, FERODO, VALEO, TRW...) Oscaro carries per part family
- **Competitive benchmarking** — Compare Oscaro's pricing against Autodoc and other aftermarket retailers ([Autodoc Scraper](https://apify.com/jelle.desramaults/autodoc-scraper) covers the same vertical for the Autodoc storefronts)

### What data does Oscaro Scraper extract?

- **Product name** — Full title including part family, brand and reference
- **Brand** — Parts manufacturer (BOSCH, BREMBO, ATE, FERODO, VALEO, TRW, MAPCO, ...)
- **Price & currency** — Current price in EUR
- **SKU** — Oscaro's own internal article ID
- **MPN** — Manufacturer part number as printed by the brand (e.g. `0 986 494 027`)
- **Availability & stock** — Schema.org availability state, plus a clean `true`/`false`/`null` `inStock` flag (never guessed — `null` when the site doesn't expose it)
- **Ratings & reviews** — Customer rating value and rating count
- **Description** — Full product description text
- **Product image** — Main image URL
- **Category & URL** — Part-group name the product was found under and its canonical product URL

### How to scrape Oscaro data

1. Pick one or more part-group URLs — the ones ending in `-g`, for example `https://www.oscaro.com/jeu-de-4-plaquettes-de-frein-402-g` (4-piece brake pad sets). Find these by browsing a part category on oscaro.com; the sidebar of any `-g` page cross-links its sibling groups (front-only, rear-only, related accessories).
2. Set `maxResults` and run.
3. Export the dataset as JSON, CSV, or Excel from the Apify Console or via API.

Oscaro's own `-sc` "top picks" landing pages (curated, no pagination, roughly a dozen items) are not supported as an entry point — use the paginated `-g` group pages instead, which is where the real catalogue lives.

#### Input

| Field | Type | Description |
|-------|------|-------------|
| `categoryUrls` | Array | Part-group pages (`-g` URLs) to scrape |
| `fetchDetails` | Boolean | Render each product's detail page for stock/description/rating (default `true`). Set `false` for fast listing-only data (name, brand, price, image) |
| `maxResults` | Integer | Maximum products to return (default: 100) |
| `proxyConfiguration` | Object | Proxy settings. Defaults to Apify RESIDENTIAL, country FR — required, Oscaro's Cloudflare challenge blocks datacenter IPs |

#### Example input

```json
{
    "categoryUrls": [
        { "url": "https://www.oscaro.com/jeu-de-4-plaquettes-de-frein-402-g" }
    ],
    "maxResults": 100,
    "fetchDetails": true
}
```

### Example output

```json
{
    "name": "Jeu de 4 plaquettes de frein ATE 13.0460-3800.2",
    "brand": "ATE",
    "price": 41.17,
    "currency": "EUR",
    "sku": "291850",
    "mpn": "13.0460-3800.2",
    "availability": "InStock",
    "inStock": true,
    "rating": 5,
    "reviewCount": 2,
    "description": "LES PLAQUETTES ATE Original. Grâce à un mélange de matériaux reconnu sur le marché...",
    "imageUrl": "https://oscaro.media/catalog/images/jpg/zoom/3/603800.jpg",
    "category": "Jeu de 4 plaquettes de frein",
    "url": "https://www.oscaro.com/jeu-de-4-plaquettes-de-frein-ate-13-0460-3800-2-291850-402-p",
    "scrapedAt": "2026-08-25T19:45:08.199Z"
}
```

### How many results per run?

Listing pages are cheap — 12 products per page fetch, no browser render needed. With `fetchDetails: true` (default), every product's own detail page is additionally rendered through a real browser to get stock status, description and rating, at roughly 3–8 seconds per product. A 100-product run with details enabled finishes in several minutes; catalogue-scale runs (a single part group can run to 800+ SKUs across 70+ pages) take longer and are paced deliberately to stay under Cloudflare's radar. The actor persists its crawl state, so long runs survive platform migrations and never push the same product twice.

With `fetchDetails: false` you get listing-level data (name, brand, price, image) in a fraction of the time — no stock, description or rating.

### Cost & usage

This actor is priced per result at the PREMIUM tier: **$0.01 per run start + $0.005 per result**. A 100-product run with `fetchDetails: true` costs roughly $0.51. Usage cost only settles once a run reports **SUCCEEDED** — reading the dataset mid-run (before the run finishes) undercounts what you'll actually be charged, since events keep accruing until the run completes.

### Limitations

- **No free-text search or vehicle-plate lookup.** Oscaro's own site is vehicle-based (make/model/year) for compatibility filtering; this actor works from part-group category pages instead, which is where the full catalogue for a given part type actually lives.
- **No OEM cross-reference numbers or EAN codes.** Unlike Autodoc, Oscaro's product pages don't expose OEM-to-aftermarket cross-references or EAN barcodes — only Oscaro's own SKU and the brand's own MPN.
- **`-sc` curated pages are not an entry point.** Those pages show a fixed set of "best sellers" for a part type with no pagination; use `-g` group pages for the full catalogue.
- **RESIDENTIAL proxy required.** Datacenter IPs get stuck on Oscaro's Cloudflare challenge.

### Related Scrapers

- [Autodoc Scraper](https://apify.com/jelle.desramaults/autodoc-scraper) — European car parts with OEM cross-reference numbers and EAN codes
- [Leroy Merlin Scraper](https://apify.com/jelle.desramaults/leroymerlin-scraper) — French DIY & home improvement products
- [ManoMano Scraper](https://apify.com/jelle.desramaults/manomano-scraper) — European DIY marketplace
- [Idealo Scraper](https://apify.com/jelle.desramaults/idealo-scraper) — German price comparison across categories

### FAQ

**Do I need an Oscaro account or cookies?**
No. Everything comes from public product pages.

**Do I need a Bright Data key or any other API key?**
No. This actor clears Oscaro's Cloudflare challenge itself using a residential proxy session — no third-party anti-bot key required.

**Can I scrape a single product?**
Seed the part-group category the product sits in and set a low `maxResults`, or run with `fetchDetails: true` and filter the output by `sku`.

**Is scraping Oscaro legal?**
This actor extracts publicly available product-page data (prices, part numbers, availability). You are responsible for how you use the data; check the terms that apply to your use case.

**Why is `inStock` sometimes `null` instead of `true`/`false`?**
`inStock` is only set when the product detail page explicitly states an availability status and `fetchDetails` is enabled. It is never guessed — a `null` value means "unknown", not "out of stock".

# Actor input Schema

## `categoryUrls` (type: `array`):

Oscaro part-group pages to scrape (URLs ending in "-g", e.g. https://www.oscaro.com/jeu-de-4-plaquettes-de-frein-402-g). The scraper walks each page's pagination (?page=N) up to Max Results. The "-sc" curated landing pages are NOT supported — they show a fixed set of picks with no pagination.

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

When enabled (recommended), every product page is rendered through a real browser to extract stock status, description, rating and review count. When disabled, only the cheap listing-tile data (name, brand, price, image) is returned — much faster, but without stock/description/rating.

## `maxResults` (type: `integer`):

Maximum number of products to return. Detail-page fetches (when enabled) take several seconds each, so size long runs accordingly.

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

RESIDENTIAL proxy is required — Oscaro's Cloudflare challenge blocks datacenter IPs. Defaults to Apify RESIDENTIAL, country FR.

## Actor input object example

```json
{
  "categoryUrls": [
    {
      "url": "https://www.oscaro.com/jeu-de-4-plaquettes-de-frein-402-g"
    }
  ],
  "fetchDetails": true,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "categoryUrls": [
        {
            "url": "https://www.oscaro.com/jeu-de-4-plaquettes-de-frein-402-g"
        }
    ],
    "fetchDetails": true,
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/oscaro-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 = {
    "categoryUrls": [{ "url": "https://www.oscaro.com/jeu-de-4-plaquettes-de-frein-402-g" }],
    "fetchDetails": True,
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/oscaro-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 '{
  "categoryUrls": [
    {
      "url": "https://www.oscaro.com/jeu-de-4-plaquettes-de-frein-402-g"
    }
  ],
  "fetchDetails": true,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call studio-amba/oscaro-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/oscaro-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/ZebBa6F8lncIEw7SQ/builds/VgyfopAN8pCAqIvEc/openapi.json