# Fnac Scraper 💰 From $0.9/1K | Products, Prices & EAN (`ahmed_jasarevic/fnac-scraper`) Actor

Scrape fnac.com products, prices, EAN codes, specs, ratings, reviews and marketplace offers. Monitor French retail prices, track competitor sellers and build product databases, fast or full detail.

- **URL**: https://apify.com/ahmed_jasarevic/fnac-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

## Fnac Scraper

Scrape **fnac.com** products, marketplace offers, prices, EAN/GTIN codes, specs, ratings and reviews from search, category and product URLs — structured JSON for **French retail price monitoring**, **competitor seller tracking**, **MAP compliance** and **product database building**.

Fnac is one of France's largest electronics, books and culture retailers. This actor turns its catalog into data you can monitor and export, with a **flat fast mode** for listing data and a **full mode** that pulls every product page.

### Use Cases

- **French retail price monitoring** — track fnac.com prices over time and detect drops and promotions
- **Marketplace & competitor seller tracking** — see every seller's offer, condition and total delivered price per product
- **MAP compliance & pricing intelligence** — compare Fnac-direct vs marketplace pricing, and Fnac vs your own store
- **Product catalog & database building** — collect titles, brands, EAN/GTIN, specs and images by category
- **Review & sentiment analysis** — gather aggregate ratings and on-page review samples
- **Deal & promotion feeds** — build alerting pipelines on top of scheduled runs

### How It Works

The actor fetches pages over **plain HTTP with browser-grade TLS fingerprints behind a tiered proxy — no browser**, then parses them cheapest-layer-first:

1. **Embedded JSON-LD** (`@type: Product`) — primary source for title, brand, EAN (`gtin13`), SKU, MPN, price, currency, availability, condition, seller, `aggregateRating` and images.
2. **Meta tags** (`og:title`, `product:price:amount`, …) as a second layer.
3. **Static HTML (Cheerio)** as a fallback for spec tables, marketplace-offer blocks, reviews, breadcrumbs and gallery images.

**Tiered proxy with automatic fallback:** tier 0 is fast French **residential** (~1–3 s/request); when fnac's edge starts returning 403, the per-domain tracker automatically shifts to the **Apify Unblocker** managed bypass (~10–15 s/request) and probes back automatically once the window reopens. You never configure the switch — open window = fast and cheap, closed window = slower but never blocked.

**Two extraction depths, one actor:**

- `fields: "listing"` (default) reads products straight from the **search/category result cards** — a typical run fetches only 3–6 listing pages: **seconds and about $0.01 of proxy**.
- `fields: "full"` additionally fetches **every product page** for EAN/GTIN, SKU, MPN, full spec table, description, all images, offer list and a review sample.

### Extract Fnac Product Data Without An Official API

Fnac exposes **no public catalog API**. Its storefront is server-rendered ASP.NET with no exposed search backend, and its only real API is seller-side (credentials required, no catalog data). Every third-party "Fnac API" is a wrapper that scrapes the same public pages this actor reads. This actor gives you the same data as clean JSON, scheduling and export included.

### What You Get Per Product

**Default (`fields: "listing"`) — parsed from result cards, no product-page fetch:**

- Title, **brand**, canonical URL, Fnac product id (`a…` / `mp…`)
- **Buy-box price** (+ crossed-out list price), currency, availability / in-stock flag, condition, seller, **lowest marketplace offer**
- **Rating + review count**, the card's main specs, product image

**`fields: "full"` — additionally fetches every product page:**

- **Title, brand, EAN/GTIN, SKU, MPN**, canonical URL and Fnac product id
- Buy-box price (+ crossed-out list price), currency, availability, condition, seller
- **Marketplace offer list** — seller, seller type (fnac/marketplace), condition, price, shipping, total, delivery estimate, new/used counts
- **Rating + review count** and a sample of on-page customer reviews
- **Full spec table** (fiche technique), description, breadcrumb categories, all product images

Direct `productUrls` are always parsed in full detail regardless of `fields`.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `searchTerms` | array | No | — | Keywords to search, e.g. `["iphone 15", "lego technic"]` |
| `productUrls` | array | No | — | Direct fnac.com product URLs (`/a123…` or `/mp123…`) — always full detail |
| `startUrls` | array | No | — | Any fnac.com search / category / product URLs (type auto-detected) |
| `fields` | string | No | `listing` | Extraction depth: `"listing"` (fast, result-card data) or `"full"` (fetch every product page) |
| `maxItems` | integer | No | `100` | Max products to save. Free users capped at 10 |
| `maxPagesPerQuery` | integer | No | `3` | Listing pages per search term / category (max 20) |
| `maxRequestsPerCrawl` | integer | No | `300` | Hard request cap for the run |
| `maxConcurrency` | integer | No | `30` | Parallel pages (max 50). 25–40 is the sweet spot |
| `fetchOffers` | boolean | No | `true` | Include marketplace offers |
| `fetchReviews` | boolean | No | `true` | Include on-page review samples (full mode) |
| `proxy` | object | No | RESIDENTIAL (France) | Sets the fast tier. Unblocker (France) is always the automatic fallback. Leave it on |

### Example Input

```json
{
    "searchTerms": ["iphone 15", "lego technic"],
    "fields": "full",
    "maxItems": 40,
    "maxPagesPerQuery": 3,
    "fetchOffers": true,
    "fetchReviews": true
}
```

### Example Output

Full mode (`fields: "full"`). The default listing mode returns the same shape with `ean`/`sku`/`mpn`/`description` null, `reviews: []`, and `specs` limited to the card's main specs:

```json
{
    "title": "Apple iPhone 15 128 Go Noir",
    "brand": "Apple",
    "ean": "0195949041947",
    "price": 809,
    "currency": "EUR",
    "availability": "In stock",
    "seller": "FNAC.COM",
    "rating": 4.7,
    "reviewCount": 1234,
    "offers": [
        {
            "seller": "FNAC.COM",
            "sellerType": "fnac",
            "condition": "New",
            "price": 809,
            "shippingPrice": 0,
            "totalPrice": 809
        }
    ],
    "specs": { "EAN": "0195949041947", "Mémoire": "128 Go" },
    "url": "https://www.fnac.com/a19876543/..."
}
```

### Pricing

Besides standard Apify platform usage (compute + proxy, passed through at cost), the actor bills **one pay-per-event charge per saved product**:

| Event | Charged for | Price |
|---|---|---|
| `listing-result` | every product saved by the default fast mode | $0.003/item |
| `full-result` | every product saved by `fields: "full"` (EAN, description, full specs, offers, review sample) | $0.01/item |

A default 40-item fast run is about **$0.12 + a few cents of usage**; a 40-item full run about **$0.40 + ~$0.10 of usage**. Error and `blocked: true` rows are never charged, and the run stops delivering items once the event budget is exhausted. Live prices are always shown on the Store page.

### Integrations And Automation

- **Apify API** — run programmatically and pull results from the dataset.
- **Webhooks** — notify your systems when a monitoring run finishes.
- **Scheduled runs** — set a **daily** (or twice-daily) schedule to track prices and promotions; a **weekly** schedule is enough for catalog building.
- **Zapier / Make / n8n** — push price changes into Sheets, Airtable, Slack or your pricing dashboard.
- **Export** — JSON, CSV, Excel from the dataset tab.

### Related Actors

- [Amazon Scraper](https://apify.com/jungle_synthesizer/amazon-scraper) — the largest general marketplace; pair with Fnac for cross-marketplace price comparison
- [Google Shopping Scraper](https://apify.com/parseforge/google-shopping-scraper) — compare Fnac offers against every seller carrying the same EAN
- [Cdiscount Scraper](https://apify.com/lexis-solutions/cdiscount-scraper) — France's other major marketplace for full French retail coverage
- [Ebay Scraper](https://apify.com/dtrungtin/ebay-items-scraper) — new/used offers and auction pricing to complement Fnac marketplace data
- [Darty Scraper](https://apify.com/studio-amba/darty-scraper) — Fnac-Darty group sibling store for wider French electronics coverage

### FAQ

#### Does Fnac have an official API?

No public catalog API. Fnac's only real API is the seller-side Marketplace webservice (credentials required, no catalog data). This actor reads the same public pages any "Fnac API" wrapper reads — no credentials needed.

#### Why use this actor instead of a generic Fnac scraper?

It combines a **fast listing mode** (pulls products from result cards, no product-page fetch) with an **automatic two-tier proxy ladder** (French residential → Apify Unblocker fallback), so runs stay fast when Fnac's edge is open and keep working when it closes — without you touching any proxy setting.

#### Which fields does the fast listing mode leave empty?

In `fields: "listing"`, `ean`, `sku`, `mpn`, `description` and `reviews` are null and `specs` is limited to the card's main specs. Switch to `fields: "full"` for the complete record, or pass direct `productUrls` (always parsed in full).

#### Can I monitor prices over time?

Yes — schedule the actor daily and store each run's dataset. Comparing runs by product URL/EAN gives you a price and availability history.

#### Does it work only for fnac.com?

Yes. Only `fnac.com` URLs are accepted (other Fnac country stores are rejected at input).

#### How much does a run cost?

You pay standard Apify platform usage plus the per-item events above. The default listing-mode run is about **$0.01 of proxy** plus pennies of compute; full mode costs more because it fetches every product page.

#### Can I export Fnac data to CSV or Excel?

Yes — JSON, CSV, Excel and more from the dataset tab or via the API.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Fnac (Fnac Darty)**. It accesses only **publicly available** fnac.com pages; it does not bypass login, and it does not solve CAPTCHAs.

You are responsible for complying with fnac.com's Terms of Service and all applicable laws (including GDPR where the data relates to individuals in the EU). Product and offer data collected here should be used in line with applicable competition and data-protection rules.

### For AI Agents & LLM Apps

**Purpose:** returns fnac.com products with prices, EAN/GTIN, specs, ratings, reviews and marketplace offers as structured JSON for price monitoring and catalog building.

**Minimal working input:**

```json
{
    "searchTerms": ["iphone 15"],
    "maxItems": 10
}
```

**Variant — full detail for direct product URLs:**

```json
{
    "productUrls": ["https://www.fnac.com/a19876543/..."],
    "fields": "full",
    "maxItems": 5
}
```

**Output fields:** `title`, `brand`, `ean`, `sku`, `mpn`, `price`, `currency`, `availability`, `condition`, `seller`, `rating`, `reviewCount`, `offers[]` (`seller`, `sellerType`, `condition`, `price`, `shippingPrice`, `totalPrice`, `delivery`), `specs`, `description`, `images`, `url`.

**Behaviors an agent should know:**

- `fields` defaults to `"listing"` (fast, no product-page fetch, `ean`/`description`/`reviews` null). Set `"full"` for complete data.
- Direct `productUrls` are **always** parsed in full detail regardless of `fields`.
- Only `fnac.com` URLs are accepted; other Fnac country stores are rejected at input.
- `maxItems` default 100; free Apify accounts capped at 10.
- `proxy` defaults to French residential; **Unblocker is the automatic fallback tier** — do not disable it unless you supply your own proxies.
- Billing is **pay-per-event** per saved item (`listing-result` $0.003, `full-result` $0.01); error/blocked rows are never charged.

### SEO Keywords

fnac scraper, fnac.com scraper, fnac api, fnac product scraper, fnac price scraper, fnac product data, scrape fnac prices, fnac marketplace offers, fnac seller data, fnac reviews scraper, fnac ean scraper, french retail price monitoring, france price monitoring, french electronics data, price monitoring france, ean gtin scraping, map compliance monitoring, retail price intelligence, product catalog scraping, competitor price tracking, fnac dataset, fnac price comparison, fnac market research, product data extraction france, marketplace seller monitoring

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search on fnac.com (e.g. "iphone 15", "lego technic"). Each term opens a search listing and products are extracted from it.

## `productUrls` (type: `array`):

Direct fnac.com product URLs (containing /a123... or /mp123...) to scrape in full detail.

## `startUrls` (type: `array`):

Any fnac.com search, category or product URLs to start from. Product pages are auto-detected by URL.

## `fields` (type: `string`):

Where product data comes from. "listing" (default): parsed directly from the search/category result cards — title, brand, price, crossed-out price, availability, in-stock flag, condition, seller, rating, review count, the card's main specs, image and the lowest marketplace offer. Only the listing pages are fetched: a 40-item run is a handful of requests, finishes in seconds and costs roughly $0.01 of proxy. ean, sku, mpn, description, the full spec table and review texts stay null (direct productUrls are still parsed in full). "full": also fetches every product page for complete data — EAN/GTIN, description, full spec table, marketplace offer list, review sample — about 50 requests, ~$0.15, 60-110 seconds. Each saved full item is billed as the premium `full-result` pay-per-event charge (see README, Pricing).

## `maxItems` (type: `integer`):

Maximum number of products to save. Free users are capped at 10 items regardless.

## `maxPagesPerQuery` (type: `integer`):

How many listing pages to follow per search term or category (pagination cap).

## `maxRequestsPerCrawl` (type: `integer`):

Hard cap on total HTTP requests for the whole run (protects your compute budget).

## `maxConcurrency` (type: `integer`):

How many pages to fetch in parallel. All search-term listings start at once and product pages join at this full concurrency (autoscaler floor: min(15, value)). The HTTP tier through Unblocker is light, so 25-40 is the sweet spot: a 40-product run finishes in roughly one minute at 30.

## `fetchOffers` (type: `boolean`):

Include the marketplace offer list (seller, price, condition, shipping) in each product.

## `fetchReviews` (type: `boolean`):

Include the customer reviews shown on the product page (rating summary always included).

## `proxy` (type: `object`):

Select the FAST proxy tier. Runs are tiered: your group here (default RESIDENTIAL, France) is tried first because it is fast and cheap, and when fnac's edge blocks it the crawler automatically shifts to Apify's Unblocker bypass tier (France) and probes back when the block lifts. The group you pick only changes the fast tier; Unblocker always stays as the fallback. Turn Apify proxy off only if you supply your own proxy URLs.

## Actor input object example

```json
{
  "searchTerms": [
    "iphone"
  ],
  "productUrls": [],
  "startUrls": [],
  "fields": "listing",
  "maxItems": 100,
  "maxPagesPerQuery": 3,
  "maxRequestsPerCrawl": 300,
  "maxConcurrency": 30,
  "fetchOffers": true,
  "fetchReviews": true,
  "proxy": {
    "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 = {
    "searchTerms": [
        "iphone"
    ],
    "productUrls": [],
    "startUrls": [],
    "fields": "listing",
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/fnac-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 = {
    "searchTerms": ["iphone"],
    "productUrls": [],
    "startUrls": [],
    "fields": "listing",
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/fnac-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 '{
  "searchTerms": [
    "iphone"
  ],
  "productUrls": [],
  "startUrls": [],
  "fields": "listing",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call ahmed_jasarevic/fnac-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/fnac-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/VcfdIXMLhv06lRrqF/builds/cp5nfbnzSIS2V9jXh/openapi.json