# SensCritique Scraper - French Media Reviews & Ratings (`lulzasaur/senscritique-scraper`) Actor

Scrape SensCritique.com reviews and ratings for films, TV series, books, music, video games, and comics. Extract titles, ratings, cast, directors, genres, synopses, and more from France's leading multi-media review platform.

- **URL**: https://apify.com/lulzasaur/senscritique-scraper.md
- **Developed by:** [lulz bot](https://apify.com/lulzasaur) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/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

## SensCritique Scraper

Scrape reviews, ratings, and metadata from [SensCritique.com](https://www.senscritique.com) -- France's leading multi-media review and rating platform covering films, TV series, books, music albums, video games, and comics/BD/manga.

### What does SensCritique Scraper do?

This Actor searches SensCritique by title name and extracts structured data including:

- **Title and original title** (French and original language)
- **Rating** (community average on a 1-10 scale)
- **Rating count, wish count, review count**
- **Year of production**
- **Genre(s)** (e.g., Action, Drame, Thriller)
- **Country/countries of origin**
- **Director/Creator** (contextual: directors for films, authors for books, developers for games, artists for music)
- **Cast** with character roles (for films and TV)
- **Duration** (formatted and in seconds)
- **Synopsis/description**
- **Cover image and backdrop URLs**
- **Media type and category**
- **Release dates** (original and French)
- **SensCritique ID** for unique identification

### Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `searchQueries` | string[] | Title names to search for | `["The Dark Knight"]` |
| `maxListings` | integer | Maximum total results to scrape | `100` |
| `scrapeDetails` | boolean | Fetch full details (synopsis, cast, genres, stats) | `true` |
| `mediaType` | enum | Filter by media type: `film`, `serie`, `jeuvideo`, `livre`, `musique`, `bd` | `film` |
| `proxyConfiguration` | object | Proxy settings (optional) | `{}` |

#### Media Type Options

| Value | Description | Creator Field |
|-------|-------------|---------------|
| `film` | Films and movies | Directors |
| `serie` | TV series and cartoons | Creators / Directors |
| `jeuvideo` | Video games | Developers |
| `livre` | Books | Authors |
| `musique` | Music albums | Artists |
| `bd` | Comics, BD, Manga | Authors |

### Output Example

```json
{
    "title": "The Dark Knight - Le Chevalier noir",
    "originalTitle": "The Dark Knight",
    "year": 2008,
    "rating": 8,
    "ratingCount": 86529,
    "wishCount": 2107,
    "reviewCount": 1042,
    "genre": "Action, Policier, Thriller",
    "country": "Etats-Unis, Royaume-Uni",
    "director": "Christopher Nolan",
    "cast": [
        "Christian Bale (Bruce Wayne / Batman)",
        "Heath Ledger (Le Joker)",
        "Aaron Eckhart (Harvey Dent / Double-Face)"
    ],
    "duration": "2h 32min",
    "durationSeconds": 9120,
    "description": "Batman aborde une nouvelle phase...",
    "coverImageUrl": "https://media.senscritique.com/media/.../the_dark_knight.png",
    "url": "https://www.senscritique.com/film/the_dark_knight_le_chevalier_noir/419456",
    "mediaType": "film",
    "category": "Film",
    "sensCritiqueId": 419456,
    "scrapedAt": "2026-04-25T12:00:00.000Z"
}
````

### How it works

The scraper uses SensCritique's GraphQL API (Apollo) directly rather than parsing HTML pages. This approach is:

1. **Fast** -- No browser rendering needed, pure API calls
2. **Reliable** -- Structured JSON data, no HTML selector fragility
3. **Comprehensive** -- Access to all product metadata including stats, cast, and media URLs

The scraper first searches for titles using the autocomplete endpoint, then optionally fetches full details for each result via the product query.

### Use cases

- **Film research** -- Compare ratings and reviews across French and international audiences
- **Media analytics** -- Track popularity, ratings, and engagement metrics
- **Content databases** -- Build comprehensive media catalogs with French metadata
- **Market research** -- Understand French entertainment preferences and trends
- **Academic research** -- Analyze cultural reception of media across categories

### Cost

This Actor uses pay-per-event (PPE) pricing. Each result in the dataset is charged at $0.005. For example:

- 100 results = $0.50
- 1,000 results = $5.00

### Limitations

- The autocomplete search returns up to ~50 results per query. Use multiple specific search queries for broader coverage.
- SensCritique is a French-language platform. Titles are typically in French with original titles available when different.
- Rate limits are respected with built-in delays between API calls.

***

### Run on Apify

This scraper runs on the [Apify platform](https://apify.com/?fpr=lulzasaur) -- a full-stack web scraping and automation cloud. Sign up for a free account to get started with 30-day trial of all features.

[Try Apify free](https://apify.com/?fpr=lulzasaur)

### Related Scrapers

More scrapers and data tools by [lulzasaur](https://apify.com/lulzasaur):

- [Album of the Year Scraper](https://apify.com/lulzasaur/albumoftheyear-scraper) -- Music album ratings and reviews
- [Goodreads Scraper](https://apify.com/lulzasaur/goodreads-scraper) -- Book ratings and reviews
- [IMDb Scraper](https://apify.com/lulzasaur/imdb-scraper) -- Movie and TV show data
- [Letterboxd Scraper](https://apify.com/lulzasaur/letterboxd-scraper) -- Film ratings and reviews
- [PSA Population Report](https://apify.com/lulzasaur/psa-pop-scraper) -- Card grading data
- [StubHub Scraper](https://apify.com/lulzasaur/stubhub-scraper) -- Event ticket prices
- [TCGPlayer Scraper](https://apify.com/lulzasaur/tcgplayer-scraper) -- Trading card prices

# Actor input Schema

## `searchQueries` (type: `array`):

List of title names to search for on SensCritique (e.g., 'The Dark Knight', 'Breaking Bad', 'Zelda'). Each query will search independently and return matching results.

## `maxListings` (type: `integer`):

Maximum total number of results to scrape across all search queries. Set to 0 for unlimited. The autocomplete API returns up to ~50 results per query.

## `scrapeDetails` (type: `boolean`):

If enabled, fetches full details for each result including synopsis, cast, genres, countries, duration, and stats (rating count, wish count, review count). If disabled, only basic search data is returned (title, rating, year, URL). Enabling this is slower but provides much richer data.

## `mediaType` (type: `string`):

Filter search results by media type. SensCritique covers films, TV series, video games, books, music albums, and comics/manga.

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

Proxy settings. Not typically required for SensCritique but recommended for large-scale runs.

## Actor input object example

```json
{
  "searchQueries": [
    "The Dark Knight"
  ],
  "maxListings": 100,
  "scrapeDetails": true,
  "mediaType": "film",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "searchQueries": [
        "The Dark Knight"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lulzasaur/senscritique-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 = { "searchQueries": ["The Dark Knight"] }

# Run the Actor and wait for it to finish
run = client.actor("lulzasaur/senscritique-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 '{
  "searchQueries": [
    "The Dark Knight"
  ]
}' |
apify call lulzasaur/senscritique-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SensCritique Scraper - French Media Reviews & Ratings",
        "description": "Scrape SensCritique.com reviews and ratings for films, TV series, books, music, video games, and comics. Extract titles, ratings, cast, directors, genres, synopses, and more from France's leading multi-media review platform.",
        "version": "1.0",
        "x-build-id": "0y7D1IH0DSLexGHc1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lulzasaur~senscritique-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lulzasaur-senscritique-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/lulzasaur~senscritique-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lulzasaur-senscritique-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/lulzasaur~senscritique-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lulzasaur-senscritique-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",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "List of title names to search for on SensCritique (e.g., 'The Dark Knight', 'Breaking Bad', 'Zelda'). Each query will search independently and return matching results.",
                        "default": [
                            "The Dark Knight"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxListings": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total number of results to scrape across all search queries. Set to 0 for unlimited. The autocomplete API returns up to ~50 results per query.",
                        "default": 100
                    },
                    "scrapeDetails": {
                        "title": "Scrape Full Details",
                        "type": "boolean",
                        "description": "If enabled, fetches full details for each result including synopsis, cast, genres, countries, duration, and stats (rating count, wish count, review count). If disabled, only basic search data is returned (title, rating, year, URL). Enabling this is slower but provides much richer data.",
                        "default": true
                    },
                    "mediaType": {
                        "title": "Media Type",
                        "enum": [
                            "film",
                            "serie",
                            "jeuvideo",
                            "livre",
                            "musique",
                            "bd"
                        ],
                        "type": "string",
                        "description": "Filter search results by media type. SensCritique covers films, TV series, video games, books, music albums, and comics/manga.",
                        "default": "film"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Not typically required for SensCritique but recommended for large-scale runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
