# Norauto Scraper — French Car Parts & Auto Products (`studio-amba/norauto-scraper`) Actor

Scrape car parts, accessories, and maintenance products from Norauto.fr, France's leading automotive retailer with 400+ service centers.

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

## Pricing

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

## Norauto Scraper -- Extract Car Parts, Accessories & Prices from France's Leading Auto Retailer

Scrape product listings, prices, specifications, availability, and reviews from [Norauto.fr](https://www.norauto.fr) -- France's largest car parts and automotive accessories retailer with over 400 service centres nationwide.

### What is Norauto Scraper?

Norauto is the dominant player in the French automotive aftermarket, selling everything from tyres and batteries to roof racks, dashcams, and engine oil. With hundreds of thousands of SKUs and a strong e-commerce presence, Norauto.fr is the go-to reference for French car part pricing and availability.

This actor scrapes product listings from search results and category pages, then extracts detailed product data from individual pages using JSON-LD structured data with HTML fallback parsing. What you can do with it:

- **Competitive pricing analysis** -- auto parts retailers and distributors monitor Norauto prices to adjust their own pricing in real time across the French market.
- **Market research** -- automotive industry analysts track product ranges, brand availability, and pricing trends for tyres, batteries, lubricants, and accessories in France.
- **Product catalogue enrichment** -- e-commerce platforms pull Norauto product specs (EAN codes, images, technical details) to populate their own product databases.
- **Price monitoring** -- fleet managers and garages track prices on consumables like brake pads, wipers, and oil filters to optimise procurement timing.
- **SEO and content strategy** -- digital agencies analyse Norauto's product taxonomy and descriptions to improve their automotive clients' online presence.

### What data does Norauto Scraper extract?

Each product is returned as a structured JSON object with:

- :wrench: **Product name** -- full product title as displayed on Norauto.fr
- :label: **Brand** -- manufacturer brand (Michelin, Bosch, Castrol, etc.)
- :euro: **Price and original price** -- current price, strikethrough price if on sale
- :currency_exchange: **Currency** -- always EUR
- :barcode: **EAN and SKU** -- GTIN/EAN barcode and internal SKU reference
- :white_check_mark: **Stock status** -- whether the product is available for purchase
- :star: **Rating and review count** -- average customer rating and number of reviews
- :camera: **Product images** -- primary image URL and gallery of all product images
- :page_facing_up: **Description** -- product description text
- :gear: **Specifications** -- technical specs as key-value pairs (tyre dimensions, oil viscosity, battery capacity, etc.)
- :file_folder: **Category and breadcrumbs** -- full category path from the navigation

### How to scrape Norauto.fr

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Search by keyword: `"pneus"`, `"huile moteur"`, `"batterie"`, `"essuie-glace"` |
| `categoryUrl` | String | No | A Norauto category page URL, e.g. `https://www.norauto.fr/c/pneus` |
| `maxResults` | Integer | No | Maximum products to return (default: 100, max: 50,000) |
| `proxyConfiguration` | Object | No | Proxy settings (recommended for large runs to avoid rate limiting) |

**Tips:**

- Use **French keywords** for best results: `"pneus hiver"` (winter tyres), `"huile 5W30"` (engine oil), `"tapis de sol"` (floor mats).
- For bulk extraction, browse Norauto.fr to find the category URL you want and paste it directly into `categoryUrl`.
- The actor automatically handles pagination, following "Suivant" links through search results.
- Provide either `searchQuery` OR `categoryUrl` -- at least one is required.

### Output

```json
{
    "name": "Pneu Michelin Crossclimate 2 205/55 R16 91H",
    "brand": "Michelin",
    "price": 109.90,
    "originalPrice": 129.90,
    "currency": "EUR",
    "ean": "3528700929157",
    "sku": "NOR-MICH-CC2-20555R16",
    "inStock": true,
    "rating": 4.7,
    "reviewCount": 342,
    "url": "https://www.norauto.fr/p/pneu-michelin-crossclimate-2-205-55-r16.html",
    "imageUrl": "https://www.norauto.fr/media/michelin-cc2.jpg",
    "imageUrls": [
        "https://www.norauto.fr/media/michelin-cc2.jpg",
        "https://www.norauto.fr/media/michelin-cc2-side.jpg"
    ],
    "description": "Le pneu Michelin CrossClimate 2 offre une traction exceptionnelle sur sol sec et mouille...",
    "specs": {
        "Largeur": "205 mm",
        "Hauteur": "55",
        "Diametre": "R16",
        "Indice de charge": "91",
        "Indice de vitesse": "H",
        "Saison": "4 saisons"
    },
    "category": "Pneus 4 saisons",
    "categories": ["Pneus", "Pneus tourisme", "Pneus 4 saisons"],
    "language": "fr",
    "scrapedAt": "2026-04-03T11:00:00.000Z"
}
````

### How much does it cost?

Norauto Scraper uses efficient CheerioCrawler (HTML parsing without a browser):

| Volume | Estimated CUs | Estimated Cost |
|--------|--------------|----------------|
| 100 products | ~0.02 | ~$0.01 |
| 500 products | ~0.08 | ~$0.04 |
| 1,000 products | ~0.15 | ~$0.08 |
| 5,000 products | ~0.60 | ~$0.30 |

The actor first collects product URLs from listing pages, then visits each product page for full details, so costs scale linearly with the number of products.

### Can I integrate?

Connect Norauto product data to your existing tools:

- **Google Sheets** -- maintain a live price tracker for your procurement team
- **Slack** -- get alerts when specific products drop below target prices
- **Zapier / Make** -- automate competitive price monitoring workflows
- **Webhooks** -- stream new data to your own pricing engine or ERP system
- **Amazon S3 / Google Cloud** -- archive product data for trend analysis
- **BigQuery / PostgreSQL** -- feed a structured product database for analytics

### Can I use it as an API?

Yes. Call the actor programmatically:

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/norauto-scraper").call(run_input={
    "searchQuery": "huile moteur 5W30",
    "maxResults": 50,
})

for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{product['name']} - EUR {product['price']} ({product.get('brand', '')})")
```

**JavaScript:**

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/norauto-scraper").call({
    searchQuery: "huile moteur 5W30",
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((p) => console.log(`${p.name} - EUR ${p.price}`));
```

### FAQ

**Does this scrape Norauto Belgium (norauto.be) or France?**
This actor targets Norauto.fr (France). Norauto Belgium has a separate website structure.

**Can I filter by vehicle compatibility?**
The actor does not input vehicle registration plates. Instead, use Norauto's pre-filtered category URLs that already include vehicle compatibility (paste those as `categoryUrl`).

**Are product specifications always available?**
Specs depend on the product category. Tyres typically have comprehensive specs (dimensions, load index, speed rating). Accessories may have fewer technical details.

**How often should I run this actor?**
For competitive pricing, daily runs are common. For catalogue snapshots, weekly or monthly is sufficient.

**Does it handle Norauto sales/promotions?**
Yes. Both the current price and the original (strikethrough) price are extracted, so you can calculate exact discount percentages.

**Can I scrape product reviews?**
The actor extracts the aggregate rating and review count. Individual review text is not currently extracted.

**What brands does Norauto carry?**
Norauto stocks major automotive brands: Michelin, Continental, Bridgestone, and Goodyear for tyres; Bosch, Valeo, and Philips for parts; Castrol, Total, and Shell for lubricants; plus Norauto's own private label products. The actor captures the brand field for every product.

**Can I scrape Norauto's service prices (oil change, tyre fitting)?**
No. Service prices are not listed as products on the website. The actor focuses on physical products available for purchase.

**How does Norauto structure its categories?**
Norauto uses a hierarchical category system (breadcrumbs): top-level categories like "Pneus", "Accessoires", "Entretien" branch into sub-categories. The actor captures the full breadcrumb path, allowing you to reconstruct the taxonomy.

### Limitations

- Targets Norauto.fr only (France). Not compatible with Norauto.be (Belgium), Norauto.es (Spain), or other country variants.
- Product pages without JSON-LD structured data fall back to HTML parsing, which may capture fewer fields.
- Norauto may rate-limit requests on large runs. Use proxy configuration and keep `maxResults` reasonable for first runs.
- Some promotional prices may be region-specific (tied to a Norauto store) and the online price may differ from in-store.
- Technical specifications vary by product category -- there is no standard set of spec fields.

### Related automotive and European retail scrapers

- [Touring Scraper](https://apify.com/studio-amba/touring-scraper) -- Belgian automobile club articles and travel guides
- [AutoVlan Scraper](https://apify.com/studio-amba/autovlan-scraper) -- Belgian used car marketplace listings and prices
- [Prisjakt Scraper](https://apify.com/studio-amba/prisjakt-scraper) -- Nordic price comparison for automotive accessories and beyond
- [Ceneo Scraper](https://apify.com/studio-amba/ceneo-scraper) -- Polish price comparison across thousands of retailers

### Your feedback

Found a bug, need additional fields, or want support for Norauto Belgium? Open an issue on the actor's GitHub page or contact us through the Apify platform. We ship improvements based on real user requests.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for products by keyword (e.g., 'pneus', 'huile moteur', 'batterie').

## `categoryUrl` (type: `string`):

A Norauto.fr category page URL to scrape. Example: https://www.norauto.fr/c/pneus. If empty and no search query, nothing is scraped.

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

Maximum number of products to return.

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

Proxy settings. Recommended for large runs to avoid rate limiting.

## Actor input object example

```json
{
  "searchQuery": "pneus",
  "maxResults": 100
}
```

# 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 = {
    "searchQuery": "pneus"
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/norauto-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 = { "searchQuery": "pneus" }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/norauto-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 '{
  "searchQuery": "pneus"
}' |
apify call studio-amba/norauto-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Norauto Scraper — French Car Parts & Auto Products",
        "description": "Scrape car parts, accessories, and maintenance products from Norauto.fr, France's leading automotive retailer with 400+ service centers.",
        "version": "0.1",
        "x-build-id": "dZpIBytSH28CMIOQi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~norauto-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-norauto-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/studio-amba~norauto-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-norauto-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/studio-amba~norauto-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-norauto-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by keyword (e.g., 'pneus', 'huile moteur', 'batterie')."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "A Norauto.fr category page URL to scrape. Example: https://www.norauto.fr/c/pneus. If empty and no search query, nothing is scraped."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Recommended for large runs to avoid rate limiting."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
