# TheFork Scraper – Restaurants, Menus, Reviews & Offers (`reviewly/the-fork-scraper`) Actor

Scrape every restaurant in a city from TheFork / LaFourchette / ElTenedor: menus with prices, ratings, multilingual reviews, discounts and a 90-day offer calendar. 11 countries, search by city name, no URLs needed.

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

## Pricing

from $3.00 / 1,000 search 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/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: Restaurants, Menus, Prices, Reviews and Booking Offers

**Extract complete restaurant data from TheFork (LaFourchette / ElTenedor) in minutes.** You get full menus with prices, ratings and reviews, opening hours, current discounts and a 90-day offer calendar for every restaurant in a city, ready to export as JSON, CSV or Excel.

- 🍽️ **Full menus with prices.** Every dish, its description and price, plus set menus.
- ⭐ **Reviews in every language,** with food / service / ambience scores and the owner's replies.
- 💸 **Live booking data:** today's discounts (up to -50%), a 90-day offer calendar and bookable time slots.
- 🌍 **11 countries:** France, Italy, Spain, Portugal, UK, Germany, Austria, Switzerland, Belgium, Netherlands and Sweden.
- 🔎 **Search by city name.** Type "Paris" or "Madrid" and get every restaurant there, no URLs needed.

***

### What does TheFork Scraper do?

TheFork Scraper is an **Apify actor for web scraping restaurant data from TheFork** (thefork.com, also known as LaFourchette in France and ElTenedor in Spain), Europe's largest restaurant booking platform. Give it a city, a search page or a list of restaurant pages. It returns one clean, structured record per restaurant, holding everything the restaurant's TheFork page shows and more.

**Who uses it:**

- **Restaurant tech and SaaS sales teams** building **restaurant lead lists** by city, cuisine, price and rating.
- **Market researchers and analysts** comparing menus, prices and ratings across cities.
- **Restaurant owners and groups** monitoring competitors' prices, discounts and reviews.
- **Food, travel and data apps** that need fresh restaurant listings, menus and photos.
- **Reputation and review-analysis tools** that need multilingual review text at scale.

***

### ✨ Key features

| You get | Details |
|---|---|
| **Restaurant profile** | Name, cuisine, chef, full address, GPS coordinates, average price, public transport, awards (MICHELIN stars, Insider, Top Host) |
| **Menu and prices** | À-la-carte sections and dishes with descriptions and prices, set menus with their courses, number of PDF menu pages |
| **Ratings** | TheFork score /10, rating count, monthly rating count, food / service / ambience sub-scores, TripAdvisor rating, review counts per language |
| **Reviews** | Text, rating, meal date, likes, reviewer profile, the restaurant's reply, review photos |
| **Booking and offers** | Bookable yes/no, today's reservation count, best current discount, bookable time windows for the next days, a ~90-day calendar of daily offers, Yums loyalty rules |
| **Practical info** | Opening hours, payment methods, dietary options (vegetarian, gluten free…), features (Wi-Fi, terrace, languages spoken…), FAQ |
| **Photos** | Restaurant photo URLs, plus diner photos (optional) |

***

### 🧠 Why this TheFork scraper?

- **It works on a protected site.** TheFork uses DataDome bot protection on every page. This actor gets through automatically with a real browser and residential proxies, so you configure nothing.
- **Local IPs, chosen automatically.** Each restaurant is scraped through residential IPs in its own country (Paris → France, Madrid → Spain), which is what keeps blocks rare.
- **Fast once it's in.** A restaurant takes a few seconds after the initial connection. Expect a few hundred restaurants per hour.
- **More data than the page shows.** The 90-day offer calendar, reservations today, review counts per language and Yums rules aren't visible at a glance on the website.
- **All the reviews, not just one language.** TheFork's own review API quietly filters reviews to your browser's language. This actor asks for every language unless you choose one.
- **Clean, typed output.** Prices come as numbers with a currency, times as `"12:00-14:30"`, dates in ISO format. Ready for spreadsheets, databases and BI tools.

***

### ⚙️ Input

You only need **one** of `searchLocations` or `startUrls`. Everything else has sensible defaults.

#### Where to scrape

| Field | What it does | Example |
|---|---|---|
| `searchLocations` | City or area names, typed like on TheFork's "Where" box. Each one is expanded into its restaurants. | `["Paris", "Lisbon, Portugal"]` |
| `startUrls` | TheFork restaurant pages (any country site) and/or listing pages (city pages, cuisine pages, search URLs with filters) | `https://www.thefork.com/restaurants/rome-c461789/pizzeria-t896` |
| `maxRestaurantsPerSearch` | How many restaurants to take from each location or listing. `0` = all. | `50` (default `20`) |
| `searchResultsOnly` | Fast mode: save only the listing summary (name, rating, price, offers, address, coordinates) without opening each restaurant. | `true` |

#### Reviews

| Field | What it does | Default |
|---|---|---|
| `includeReviews` | Scrape written reviews | `true` |
| `maxReviewsPerRestaurant` | Reviews per restaurant. `0` = all. | `100` |
| `reviewsLanguage` | `all`, or an ISO code such as `en`, `fr`, `it`, `es` | `all` |
| `reviewsSortOrder` | `newest` or `oldest` (by meal date) | `newest` |
| `reviewsSince` | Only reviews for meals on or after this date, e.g. `2026-01-01`. Great for weekly updates. | none |

#### Restaurant details

| Field | What it does | Default |
|---|---|---|
| `includeMenu` | À-la-carte menu with prices, plus set menus | `true` |
| `includeBookingInfo` | Bookable times, the 90-day offer calendar, today's reservations | `true` |
| `availabilityDays` | How many days of bookable time windows to collect (1–90) | `7` |
| `maxCustomerPhotos` | Diner photos per restaurant (restaurant photos are always included) | `0` |
| `proxyConfiguration` | Leave as is. Residential proxies are required, and the country is picked automatically per restaurant. | Residential |

#### Example inputs

**Every restaurant in Paris, with its last 20 reviews:**

```json
{
  "searchLocations": ["Paris, France"],
  "maxRestaurantsPerSearch": 0,
  "maxReviewsPerRestaurant": 20
}
```

**A quick lead list (no reviews, no menus) for three cities:**

```json
{
  "searchLocations": ["Madrid", "Barcelona", "Valencia"],
  "maxRestaurantsPerSearch": 200,
  "searchResultsOnly": true
}
```

**All English reviews from this year for specific restaurants:**

```json
{
  "startUrls": [
    { "url": "https://www.thefork.com/restaurant/restaurant-auguste-gael-orieux-r26201" },
    { "url": "https://www.thefork.it/ristorante/fantasie-di-napoli-2-0-r814368" }
  ],
  "maxReviewsPerRestaurant": 0,
  "reviewsLanguage": "en",
  "reviewsSince": "2026-01-01",
  "includeMenu": false,
  "includeBookingInfo": false
}
```

#### 💡 Tips for best results

- **Add the country to the location** (`"Lyon, France"` rather than `"Lyon"`). The actor then starts with the right proxy country and saves a few seconds.
- **To filter by cuisine or vibe,** open TheFork, pick a city and a filter (Pizzeria, Italian, Romantic, MICHELIN…), and paste that page's URL into `startUrls`.
- **For big cities, start with `searchResultsOnly: true`** to see what's there cheaply, then scrape full details for the restaurants you care about.
- **For recurring monitoring,** schedule the actor weekly with `reviewsSince` set to your last run date.

***

### 📤 Output

Each restaurant is one item in the dataset. You can download it as **JSON, CSV, Excel, XML or HTML**, or read it through the Apify API.

#### Sample record (shortened)

```json
{
  "restaurantId": 849456,
  "name": "Le petit blé noir",
  "url": "https://www.thefork.com/restaurant/le-petit-ble-noir-r849456",
  "cuisine": "French",
  "address": { "street": "188 Rue Saint-Maur", "zipCode": "75010", "locality": "Paris", "country": "France" },
  "latitude": 48.8713783,
  "longitude": 2.3724345,
  "averagePrice": { "amount": 22, "currency": "EUR" },
  "rating": 9.5,
  "ratingCount": 667,
  "reviewCount": 403,
  "ratingDistinction": "Excellent",
  "subRatings": { "food": 9.5, "service": 9.8, "ambience": 9.2 },
  "reviewLanguages": { "all": 403, "fr": 340, "it": 30, "en": 24 },
  "tripadvisorRating": 4.9,
  "paymentMethods": ["Credit Card", "TheFork Pay", "UnionPay"],
  "dietaryOptions": ["Vegetarian dishes"],
  "features": {
    "Features": ["Wifi"],
    "Languages spoken": ["French spoken"],
    "Other services": ["Homemade cuisine"]
  },
  "publicTransport": "Belleville/ Goncourt",
  "booking": {
    "isBookable": true,
    "bestDiscountPercentage": 50,
    "reservationsToday": 6,
    "bookableTimes": [
      { "date": "2026-10-28", "times": ["12:00-14:00", "18:30-22:00"] }
    ],
    "availabilityCalendar": [
      { "date": "2026-10-28", "offer": "-50%", "discountPercentage": 50, "yumsAvailable": false },
      { "date": "2026-12-01", "offer": "-30%", "discountPercentage": 30, "yumsAvailable": false }
    ]
  },
  "menu": {
    "updatedAt": "2025-10-13T06:53:32.705Z",
    "sections": [
      {
        "name": "Les galettes végétariennes",
        "items": [
          {
            "name": "La chèvre miel",
            "description": "Chèvre, miel, pommes caramélisées, noix",
            "price": { "amount": 10, "currency": "EUR" },
            "isMainDish": true
          }
        ]
      }
    ],
    "setMenus": []
  },
  "photos": ["https://cdn.thefork.com/tf-lab/image/upload/restaurant/…/341e3411-….jpg"],
  "reviewsAvailable": 403,
  "reviewsScraped": 30,
  "reviews": [
    {
      "reviewId": "450aa04c-ff51-49f6-bf97-f59785d9467e",
      "rating": 10,
      "mealDate": "2026-10-23T17:15:00.000Z",
      "text": "Les plats étaient délicieux et le cadre très agréable. Le service était parfait",
      "reviewer": { "name": "L.aurence N.", "reviewCount": 12, "memberSince": "2018-08-14T22:30:22.000Z" },
      "ownerReply": { "text": "Merci beaucoup", "status": "PUBLISHED" },
      "photos": []
    }
  ],
  "scrapedAt": "2026-10-28T13:20:51.091Z"
}
```

#### Field reference

| Field | Meaning |
|---|---|
| `restaurantId`, `uuid`, `url`, `slug` | TheFork identifiers and the restaurant's page |
| `cuisine`, `chefName`, `description` | What the restaurant serves and who cooks |
| `address`, `city`, `latitude`, `longitude` | Location, ready for mapping |
| `averagePrice` | Average price per person, as a number plus currency |
| `rating` / `ratingCount` | TheFork score out of 10 and how many diners rated |
| `reviewCount` / `reviewsAvailable` | How many ratings come with written text (in the chosen language) |
| `subRatings` | Average food, service and ambience scores |
| `reviewLanguages` | Number of written reviews per language |
| `ratingDistinction` | TheFork's label, e.g. "Excellent" |
| `tripadvisorRating`, `tripadvisorReviewCount` | TripAdvisor figures shown on TheFork |
| `openingHours` | Opening hours per weekday, e.g. `["12:00-14:00","19:30-22:30"]` (empty when the restaurant hasn't published them) |
| `paymentMethods`, `dietaryOptions`, `features`, `tags`, `highlights` | Practical information and TheFork's categories |
| `awards` | MICHELIN stars and review link, Insider, Top Host, TheFork Awards |
| `booking.isBookable`, `booking.hasAvailability` | Whether the restaurant takes TheFork bookings and has free tables |
| `booking.bestDiscountPercentage`, `booking.currentOffer` | The best discount running now |
| `booking.reservationsToday` | Bookings made on TheFork today, a popularity signal |
| `booking.bookableTimes` | Time windows you can book, per day |
| `booking.availabilityCalendar` | For the next ~90 days: each open day's best offer (`-50%`, `MENU`…), its id, and whether Yums can be used |
| `booking.yums` | TheFork loyalty (Yums) rules: pay-at-table bonus, exchange rates |
| `menu.sections` | À-la-carte menu: sections, then dishes with description, price and whether it's a main |
| `menu.setMenus` | Set menus with their courses and availability |
| `menu.pdfMenus`, `menu.menuPhotoCount` | Extra menu documents and photos the restaurant uploaded |
| `photos` | Restaurant photo URLs |
| `customerPhotos`, `customerPhotoCount` | Diner photos (when `maxCustomerPhotos` > 0) and how many exist |
| `faq` | TheFork's Q\&A about the restaurant |
| `reviews[]` | `rating` (/10), `mealDate`, `text`, `likes`, `reviewer` (name, review count, member since), `ownerReply`, `photos` |
| `scrapedAt` | When the record was collected |

With `searchResultsOnly`, each item is a lighter listing record: `restaurantId`, `name`, `url`, `cuisine`, `address`, `country`, coordinates, `rating`, `ratingCount`, `averagePrice`, `priceRangeLevel`, `offers`, `isBookable`, `reservationsToday`, `paymentMethods`, `mainPhotoUrl`.

***

### ▶️ How to use TheFork Scraper

1. **Open the actor** and click **Try for free**.
2. **Choose where to scrape.** Type one or more cities into **Search locations**, or paste TheFork URLs into **Start URLs**.
3. **Set the size.** Pick **Max restaurants per search** and **Max reviews per restaurant**. Start small (for example 10 and 20) to see the data.
4. **Leave the proxy as is.** Residential proxies are needed and already selected.
5. **Click Start.** Results show up in the **Output** tab as each restaurant finishes.
6. **Export** to CSV, Excel or JSON, or connect it to Google Sheets, Make, Zapier or your own app through the Apify API.

**Common workflows**

- **City lead list:** `searchLocations` + `searchResultsOnly: true` → export to CSV → import into your CRM.
- **Competitor tracking:** a list of `startUrls` + a weekly schedule + `reviewsSince` → only new reviews and current prices each week.
- **Menu and price research:** a city search with `includeReviews: false` → compare menus and dish prices across neighbourhoods.

***

### 📈 Use cases

1. **Restaurant lead generation for B2B sales.** Build targeted **restaurant lead lists** with name, full address, coordinates, cuisine, price level, rating and popularity (bookings today) for POS, delivery, booking or food-supplier sales teams. Note that TheFork doesn't publish phone numbers or emails; see the FAQ.
2. **Price and menu benchmarking.** Compare dish prices, set-menu offers and average spend across cities, cuisines or competitors, and track menu changes over time.
3. **Review and sentiment analysis.** Collect thousands of multilingual reviews with ratings and owner replies to measure satisfaction, spot recurring complaints or train models.
4. **Discount and demand monitoring.** Use the 90-day offer calendar and daily reservation counts to see who discounts, how deeply, on which days, and which places are in demand.
5. **Market mapping and site selection.** Map restaurant density, cuisines, ratings and price levels by neighbourhood with GPS coordinates before opening a new venue.

***

### 💰 Pricing

You pay only for the data you get (pay per event):

| Event | When it's charged |
|---|---|
| **Restaurant scraped** | Once for each full restaurant record |
| **Review scraped** | Once for each review included in a record |
| **Search result** | Once for each listing row in `searchResultsOnly` mode |

See the **Pricing** tab for current prices. Turning reviews off, or lowering `maxReviewsPerRestaurant`, makes each restaurant cheaper. `searchResultsOnly` is the cheapest way to build a list.

**Spending limit:** if you set a maximum cost for a run, the actor plans around it. It takes only as many restaurants and reviews as the limit covers, then stops cleanly with everything collected so far in the dataset.

***

### 🛠️ Advanced tips

- **Speed:** most of the time goes into the first connection of each session (roughly 10–60 seconds). After that, a restaurant takes a few seconds. Bigger runs are therefore much more efficient per restaurant than many tiny runs.
- **Cost control:** reviews are the largest part of each record. Lower `maxReviewsPerRestaurant`, or turn reviews off, for menu/price or lead-list jobs.
- **Proxies:** keep **Residential** proxies. Leave the country empty so it's chosen per restaurant. Only set one if every restaurant is in that country.
- **Scaling to whole countries:** split the work by city (one location per city) and set `maxRestaurantsPerSearch: 0`. Large cities have thousands of listings (Paris ≈ 3,350, Rome ≈ 1,700, Madrid ≈ 1,300).
- **Run summary:** each run saves a `RUN_SUMMARY` record in its key-value store with counts and any restaurants that failed.

***

### ❓ FAQ

**Does it return phone numbers, emails or websites?**
No. TheFork doesn't publish restaurant phone numbers, emails or websites anywhere on its site, so no scraper can get them from TheFork. You get the name, full address and GPS coordinates, which are enough to match restaurants with other sources.

**Which countries are supported?**
Every country TheFork operates in: France, Italy, Spain, Portugal, United Kingdom, Germany, Austria, Switzerland, Belgium, Netherlands and Sweden. Restaurant URLs from any TheFork country site work (thefork.fr, thefork.it, thefork.es, lafourchette.com…).

**Can I filter by cuisine, price or rating?**
Yes. Apply the filters on TheFork's website, copy the URL of the results page, and paste it into `startUrls`. Cuisine pages like `/restaurants/rome-c461789/pizzeria-t896` work too. You can also filter the dataset afterwards by `cuisine`, `averagePrice` or `rating`.

**Why are text labels in English?**
All restaurants are read from the international site (thefork.com), so TheFork's own labels (features, tags, FAQ) come back in English. Menus and reviews stay in the language they were written in.

**Why is `openingHours` empty for some restaurants?**
Some restaurants don't publish opening hours on TheFork. Their `booking.bookableTimes` still shows when you can book.

**Why does `reviewsAvailable` differ from `ratingCount`?**
Many diners leave only a score. `ratingCount` counts all scores; `reviewsAvailable` counts reviews with written text (in your chosen language).

**The run started with only one restaurant and 12 reviews. Why?**
When the input is left exactly as prefilled, the actor runs a quick demo (1 restaurant, 12 reviews) so Apify's daily health check finishes fast. Change any field, for example add a location or change the review count, to run normally.

**My run stopped with "Spending limit reached". What happened?**
The run hit the maximum cost you set for it. Everything scraped up to that point is in the dataset. Raise the run's maximum cost (in the run options) to collect more.

**A run logs "rotating IP" or "switching proxy". Is something wrong?**
No. It means the actor moved to a fresh residential IP, or to IPs in the next restaurant's country. That's part of how it avoids being blocked. Failures are listed in the run's `RUN_SUMMARY`.

**Is it legal to scrape TheFork?**
This actor collects publicly visible data only and doesn't log in. Reviews contain personal data (reviewer first names and initials), so make sure your use complies with GDPR and TheFork's terms. If in doubt, ask a lawyer.

***

### 📞 Support

- **Questions or feature requests:** open an issue in the actor's **Issues** tab on Apify.
- **Bug reports:** please include the **run ID** (or a link to the run) and the input you used. That's usually all that's needed to reproduce it.
- **Custom data or a tailored scraper:** email **me@ahmedhrid.com**.

*Looking for more restaurant and review data? Check my other actors on Apify for review and listing scrapers.*

# Actor input Schema

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

TheFork restaurant pages (any country site, e.g. thefork.com/restaurant/…-r814368 or thefork.it/ristorante/…) and/or listing pages on www.thefork.com (/restaurants/rome-c461789, /search?…). Listings are expanded into their restaurants.

## `searchLocations` (type: `array`):

Free-text places to search, the way the site's "Where" box works (e.g. "Rome", "Paris 11e", "Lisbon, Portugal"). Each is resolved to a listing page and expanded into its restaurants.

## `maxRestaurantsPerSearch` (type: `integer`):

How many restaurants to take from each listing page or search location. 0 = all.

## `searchResultsOnly` (type: `boolean`):

Save the listing summary (name, rating, price, offers, address, coordinates) for each search result instead of opening every restaurant. Much faster and cheaper.

## `includeReviews` (type: `boolean`):

Scrape written reviews for each restaurant.

## `maxReviewsPerRestaurant` (type: `integer`):

0 = all reviews.

## `reviewsLanguage` (type: `string`):

"all" for every language, or an ISO code such as "en", "fr", "it". The record's reviewLanguages field shows what each restaurant has.

## `reviewsSortOrder` (type: `string`):

Order reviews by meal date.

## `reviewsSince` (type: `string`):

Skip reviews for meals before this date (YYYY-MM-DD). With newest-first order the scraper stops paging once it passes this date, which makes incremental runs cheap.

## `includeMenu` (type: `boolean`):

À-la-carte menu with sections, dishes, descriptions and prices, plus set menus.

## `includeBookingInfo` (type: `boolean`):

Bookable time windows, the ~90-day availability calendar with each day's best offer, and today's reservation count.

## `availabilityDays` (type: `integer`):

How many days ahead to read bookable time windows for.

## `maxCustomerPhotos` (type: `integer`):

Diner-uploaded photos to collect per restaurant. Restaurant photos are always included.

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

TheFork is protected by DataDome; residential proxies are strongly recommended. Leave the country empty and the actor picks it per restaurant: from the country site in the URL (thefork.it → Italy), the searched location, or the listing's results. On Apify, IPs with no country got a hard captcha, while IPs in the restaurant's own country cleared on the first try. Choosing a country here pins every request to it.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.thefork.com/restaurant/fantasie-di-napoli-2-0-r814368"
    }
  ],
  "maxRestaurantsPerSearch": 20,
  "searchResultsOnly": false,
  "includeReviews": true,
  "maxReviewsPerRestaurant": 100,
  "reviewsLanguage": "all",
  "reviewsSortOrder": "newest",
  "includeMenu": true,
  "includeBookingInfo": true,
  "availabilityDays": 7,
  "maxCustomerPhotos": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

One record per restaurant (or per search result when searchResultsOnly is on).

# 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 = {
    "startUrls": [
        {
            "url": "https://www.thefork.com/restaurant/fantasie-di-napoli-2-0-r814368"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/the-fork-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 = {
    "startUrls": [{ "url": "https://www.thefork.com/restaurant/fantasie-di-napoli-2-0-r814368" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("reviewly/the-fork-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 '{
  "startUrls": [
    {
      "url": "https://www.thefork.com/restaurant/fantasie-di-napoli-2-0-r814368"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call reviewly/the-fork-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reviewly/the-fork-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/F5qixCff864onoDSi/builds/Fxpnd9FtnT0kXEKwH/openapi.json