# TheFork Scraper API - Restaurants, Ratings & Discounts (`sweet_stickball/thefork-scraper`) Actor

TheFork scraper and API alternative: extract restaurants from any TheFork city, area, cuisine or deals page with name, cuisine, rating out of 10, review count, average price, current discount, address and coordinates. Works on TheFork France, Italy, Spain and 9 other sites, no login.

- **URL**: https://apify.com/sweet_stickball/thefork-scraper.md
- **Developed by:** [CrawlKit](https://apify.com/sweet_stickball) (community)
- **Categories:** Travel, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 restaurants

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

## TheFork Scraper API - Restaurants, Ratings & Discounts

Extract restaurants from TheFork (LaFourchette / ElTenedor) list pages: name, cuisine, TheFork rating out of 10, review count, average price per person, current discount (for example -30 %), address and GPS coordinates. Give a city name, or paste any TheFork city, area, cuisine or deals page. One flat JSON record per restaurant, ready for spreadsheets, databases and AI agents.

### What you can do with it

- Build a restaurant list for a city or neighbourhood with ratings, prices and coordinates.
- Track which restaurants run TheFork discounts and how large they are.
- Compare average prices and ratings by cuisine or area.
- Feed restaurant data to an AI agent or a map.

### Input

| Field | Type | Description |
|---|---|---|
| `city` | string | City as listed on TheFork, e.g. `Paris`, `Lyon`, `Rome`, `Madrid`. Ignored when `searchUrl` is set. |
| `country` | string | TheFork site used with `city`: `com` (English, default), `fr`, `it`, `es`, `uk`, `de`, `ch`, `be`, `nl`, `pt`, `at`, `se`. |
| `searchUrl` | string | Optional. Any TheFork list page, e.g. `https://www.thefork.com/restaurants/paris-c415144/italian-t436` (cuisine), `.../paris-11th-a537` (area), `.../deals` (offers). |
| `maxItems` | integer | Maximum number of restaurants (default 20). TheFork shows 25 restaurants per result page. |

Example:

```json
{
    "city": "Paris",
    "country": "com",
    "maxItems": 50
}
```

### Output

```json
{
    "restaurantId": "849456",
    "name": "Le petit blé noir",
    "cuisine": "French",
    "rating": 9.5,
    "reviewCount": 658,
    "averagePrice": 22.0,
    "currency": "EUR",
    "priceRange": 2,
    "discountPercent": 30,
    "deals": "Yums x2",
    "isBookable": true,
    "address": "188 Rue Saint-Maur",
    "zipCode": "75010",
    "city": "Paris",
    "country": "France",
    "latitude": 48.8713783,
    "longitude": 2.3724345,
    "url": "https://www.thefork.com/restaurant/le-petit-ble-noir-r849456",
    "imageUrl": "https://cdn.thefork.com/tf-lab/image/upload/restaurant/e1b6ff55-3c11-434f-b91c-b62080d04f47/341e3411-1784-4b6a-87f7-2bad2cbf7683.jpg",
    "searchUrl": "https://www.thefork.com/restaurants/paris-c415144",
    "scrapedAt": "2026-10-25T12:00:00+00:00"
}
```

Field notes:

- `rating` is TheFork's own score out of 10; `reviewCount` is the number of TheFork reviews.
- `discountPercent` is the best discount on the time slots shown in the list (TheFork offers vary by time and date); `null` when there is none.
- `averagePrice` is the average price per person displayed by TheFork, in `currency`.
- Labels such as `cuisine` come in the language of the TheFork site you search.

### How it works

TheFork pages are protected by an anti-bot service. Each result page is loaded as a fresh visit in a real Chrome browser, through a new residential proxy session in the site's country; a blocked visit is dropped and another session is tried (up to 15 per page). Captchas are never solved. Restaurant data is read from the JSON embedded in the page, not from screen layout.

### Pricing

Pay-per-event, **no start fee**: **$4.20 per 1,000 restaurants** on the Apify Free plan, with lower prices on paid plans. Each restaurant pushed to the dataset is one event.

| Event | Free | Starter | Scale | Business | Enterprise |
|-------|------|---------|-------|----------|------------|
| Restaurant (`RESTAURANT`) | $4.20 | $3.60 | $3.20 | $2.50 | $2.50 |

Prices in USD per 1,000 events.

#### Cost examples (Free plan)

| Scenario | Restaurants | Cost |
|----------|-------------|------|
| Quick look | 10 | $0.042 |
| One city | 300 | $1.26 |
| Several cities | 1,000 | $4.20 |

### Limitations

- Results are TheFork's list cards: no menus, opening hours, phone numbers or reviews text.
- The `city` input finds cities linked from the TheFork site's home page (large cities). For other towns, open the town's page on TheFork and pass its URL as `searchUrl`.
- Discounts depend on the date and time slot; the value reflects what the list page showed at scraping time.
- Some visits are blocked by the anti-bot service, so run time varies: about 20-40 s for 10 restaurants, 40-80 s for 100.
- Order follows TheFork's default ranking for the page.

### Related Actors

- [Resy Scraper API - Restaurants & Open Reservation Times](https://apify.com/sweet_stickball/resy-scraper) — Scrape Resy restaurants in any city: open reservation times for your date and party size, cuisine, rating, price level and address. Read-only, no login.
- [Yelp Scraper API - Reviews, Ratings & Coordinates](https://apify.com/sweet_stickball/yelp-scraper) — Scrape Yelp businesses and reviews: name, address, rating, review count, coordinates and review text. Yelp data API for local research, no login.
- [Booking.com Scraper API - Hotel Prices & Ratings, No Login](https://apify.com/sweet_stickball/booking-scraper) — Scrape Booking.com hotels for any city and dates: prices, ratings, reviews, stars, coordinates and free cancellation. Hotel data API, no login needed.

# Actor input Schema

## `city` (type: `string`):

City name as listed on TheFork, e.g. Paris, Lyon, Rome, Madrid, Lisbon. Ignored when searchUrl is set. Small towns may not be linked from the site's home page: use searchUrl for them.

## `country` (type: `string`):

TheFork site to search with the city: com (English, international), fr, it, es, uk, de, ch, be, nl, pt, at or se. Cuisine names and labels come in that site's language.

## `searchUrl` (type: `string`):

Optional. Any TheFork restaurant list page of a city, on any TheFork site, e.g. https://www.thefork.com/restaurants/paris-c415144/italian-t436 (cuisine), .../paris-11th-a537 (area), .../deals (offers) or https://www.thefork.it/ristoranti/roma-c461789. Takes precedence over city.

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

Maximum number of restaurants to return (25 per result page, in TheFork's default ranking).

## Actor input object example

```json
{
  "city": "Paris",
  "country": "com",
  "searchUrl": "https://www.thefork.com/restaurants/paris-c415144/italian-t436",
  "maxItems": 10
}
```

# Actor output Schema

## `restaurants` (type: `string`):

Dataset items shown with the 'restaurants' view.

# 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 = {
    "city": "Paris",
    "country": "com",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("sweet_stickball/thefork-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 = {
    "city": "Paris",
    "country": "com",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("sweet_stickball/thefork-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 '{
  "city": "Paris",
  "country": "com",
  "maxItems": 10
}' |
apify call sweet_stickball/thefork-scraper --silent --output-dataset

```

## MCP server setup

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