# Feu Vert Scraper — French Car Parts, Tires & Service Prices (`studio-amba/feuvert-fr-scraper`) Actor

Scrape products, prices, stock, and ratings from feuvert.fr, France's major car-service and tire chain. Point it at any category page (tires, batteries, brakes, oil, accessories) and export clean structured data.

- **URL**: https://apify.com/studio-amba/feuvert-fr-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 $1.20 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Feu Vert Scraper — French Car Parts, Tires & Service Prices

Scrape products, prices, stock, and ratings from **feuvert.fr**, one of France's largest car-service and tire chains. Point it at any category page — tires, batteries, brakes, oil, accessories — and export clean, structured data.

### Why use this actor?

Feu Vert sells far more than tires: batteries, brake pads, oil, wipers, dashcams, bike gear, and dozens of other automotive categories, each with its own catalogue page. This actor turns any of those category pages into a structured dataset you can drop into a spreadsheet, database, or price-monitoring pipeline. For tires specifically, it also parses the size string into width, aspect ratio, rim diameter, load index, speed index, and season, so you can filter and join tire data the same way you would with Euromaster or Kwik Fit.

### How to scrape Feu Vert data

1. Enter a **Category URL** — the full feuvert.fr address of any category page, for example:
   - `https://www.feuvert.fr/pneu/michelin/r2711.html` (tires, filtered by brand)
   - `https://www.feuvert.fr/pneu/195-65r15-91t_r2711.html` (tires, filtered by size)
   - `https://www.feuvert.fr/batterie/r2805.html` (car batteries)
   - `https://www.feuvert.fr/plaquettes-de-frein/r2797.html` (brake pads)
2. Set **Max Results** to how many products you want (each category page returns 16-18 products; the actor paginates automatically).
3. Provide a **Bright Data API key** (see "Anti-bot" below).
4. Run the actor. Results stream into the dataset and can be exported as JSON, CSV, Excel, or via the API.

Note: `https://www.feuvert.fr/pneu/r2711.html` (the plain tire landing page) is a marketing page, not a real catalogue — it only surfaces a handful of featured products. Use a brand page, a size page, or any other rayon URL instead.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `categoryUrl` | String | No | Full feuvert.fr category page URL (default: Michelin tires) |
| `maxResults` | Integer | No | Maximum products to return (default: 100) |
| `brightDataApiKey` | String | Yes | Bright Data Web Unlocker API key (or set `BRIGHT_DATA_API_KEY` env var) |
| `proxyConfiguration` | Object | No | Kept for compatibility; fetching is handled by Bright Data |

### Output

Each result contains:

| Field | Type | Example |
|-------|------|---------|
| `productId` | String | `"268233"` |
| `productName` | String | `"Pneu Hiver Michelin 195/65R15 91T Alpin 7"` |
| `brand` | String | `"Michelin"` |
| `category` | String | `"Michelin"` (breadcrumb label for the page scraped) |
| `price` | Number | `74.9` |
| `currency` | String | `"EUR"` |
| `inStock` | Boolean or null | `true` |
| `rating` | Number | `3` |
| `reviewCount` | Number | `2` |
| `size` | String | `"195/65R15 91T"` (tires only) |
| `width` | Integer | `195` (tires only) |
| `aspectRatio` | Integer | `65` (tires only) |
| `rimDiameter` | Integer | `15` (tires only) |
| `loadIndex` | String | `"91"` (tires only) |
| `speedIndex` | String | `"T"` (tires only) |
| `season` | String | `"Hiver"` (tires only) |
| `description` | String | Full product description text |
| `imageUrl` | String | Primary product image URL |
| `url` | String | Full product page URL |
| `scrapedAt` | String | ISO 8601 timestamp |

Tire-specific fields (`size`, `width`, `aspectRatio`, `rimDiameter`, `loadIndex`, `speedIndex`, `season`) are only present when the product name matches a tire size pattern — they are omitted, never guessed, on batteries, brake pads, or any other category.

### Example output

```json
{
    "productId": "268233",
    "productName": "Pneu Hiver Michelin 195/65R15 91T Alpin 7",
    "brand": "Michelin",
    "price": 74.9,
    "currency": "EUR",
    "inStock": true,
    "rating": 3,
    "reviewCount": 2,
    "width": 195,
    "aspectRatio": 65,
    "rimDiameter": 15,
    "loadIndex": "91",
    "speedIndex": "T",
    "size": "195/65R15 91T",
    "season": "Hiver",
    "description": "Pneu hiver pour les véhicules de tourisme. Sécurité : Gardez le contrôle sur les routes enneigées. Performance : Freinage et motricité renforcés.",
    "imageUrl": "https://cdnfw-racine.feuvert.fr/img/268233/sans1_nd.jpg",
    "url": "https://www.feuvert.fr/trouver-un-pneu/michelin-pneu-hiver-michelin-195-65r15-91t-alpin-7/p268233.html",
    "scrapedAt": "2026-08-27T09:20:39.979Z",
    "category": "Michelin"
}
```

### Anti-bot: Bright Data Web Unlocker required

feuvert.fr is protected by DataDome — a plain HTTP request returns a 403 with an `x-datadome: protected` header instead of the real page. To fetch pages reliably, this actor uses the [Bright Data Web Unlocker](https://brightdata.com) (zone `web_unlocker1`).

You need a Bright Data account with a Web Unlocker zone. Provide the API key either:

- in the input field **Bright Data API Key**, or
- as the environment variable `BRIGHT_DATA_API_KEY`.

Bright Data bills per request. Because each category page returns 16-18 products in a single request, the anti-bot cost per product is low when scraping the listing directly, which is all this actor does — no per-product detail fetches are needed.

### Cost estimate

- Roughly one Bright Data request (~$0.0015) per 16-18 products, plus Apify compute. Scraping 1,000 products is about 60 page requests — fast and cheap, well under a cent of Bright Data cost per result.
- Your run's usage cost only settles once the run finishes with status **SUCCEEDED** — a run that fails partway shows partial or zero usage in your billing until Apify reconciles it.

### How pagination works

Every feuvert.fr category page paginates with a `?pageNumber=<N>` query parameter and SSR-embeds a schema.org `ItemList` of `Product` entries directly in the page HTML — no separate API call or DOM scraping of CSS classes needed. The actor starts at page 1 and requests the next page until it reaches your Max Results or runs out of products, deduplicating by product ID so the same item is never exported twice.

For long runs, the actor persists its progress (seen product IDs and page cursor). If Apify migrates the run to another host, it resumes where it left off instead of restarting, so you never get duplicate rows or a half-finished catalogue.

### Limitations

- Prices and availability are Feu Vert's national online catalogue values and may differ from a specific store's price or stock.
- `inStock` reflects the site's own availability flag; when the site does not expose one, the field is `null`, never guessed as `false`.
- A Bright Data Web Unlocker key is required; without it the actor cannot fetch pages.
- Data is scraped from the public website and may change without notice.
- Respect the website's terms of service and use responsibly.

### Related Scrapers

- [Euromaster Scraper](https://apify.com/store) — French and German tire prices by brand and model
- [Kwik Fit Scraper](https://apify.com/store) — UK tire and car-service prices
- [Carrefour Scraper](https://apify.com/store) — French grocery prices and products

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# Actor input Schema

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

Full feuvert.fr category/rayon page URL to scrape, e.g. https://www.feuvert.fr/pneu/michelin/r2711.html (tires by brand), https://www.feuvert.fr/pneu/195-65r15-91t\_r2711.html (tires by size), or https://www.feuvert.fr/batterie/r2805.html (batteries). The scraper paginates the category (~16-18 products per page) until it reaches Max Results.

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

Maximum number of products to return.

## `brightDataApiKey` (type: `string`):

Your Bright Data API key for the Web Unlocker zone (web\_unlocker1). Required to bypass Feu Vert's DataDome anti-bot protection. Get one at https://brightdata.com. Can also be provided via the BRIGHT\_DATA\_API\_KEY environment variable.

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

Proxy settings. Kept for compatibility — page fetching is handled by Bright Data Web Unlocker, so this does not affect scraping.

## Actor input object example

```json
{
  "categoryUrl": "https://www.feuvert.fr/pneu/michelin/r2711.html",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "categoryUrl": "https://www.feuvert.fr/pneu/michelin/r2711.html",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/feuvert-fr-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 = {
    "categoryUrl": "https://www.feuvert.fr/pneu/michelin/r2711.html",
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/feuvert-fr-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 '{
  "categoryUrl": "https://www.feuvert.fr/pneu/michelin/r2711.html",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/feuvert-fr-scraper --silent --output-dataset

```

## MCP server setup

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