TheFork Restaurant Reviews Scraper

Extract public diner reviews from TheFork restaurant pages into a clean dataset.

The Actor collects review text, scores, meal dates, reviewer details, review photos, restaurant replies, and venue-level rating summaries. It is designed for recurring reputation monitoring, hospitality research, and restaurant competitor analysis.

Give it one or more public TheFork restaurant URLs and choose how many reviews you need. The Actor handles the protected page, normalizes TheFork's hydrated data, and returns one flat record per review for JSON, CSV, Excel, API, or MCP workflows.

What does TheFork Restaurant Reviews Scraper do?

The Actor turns public TheFork review pages into structured records.

• 🍽️ Accepts restaurant pages and /reviews URLs.
• ⭐ Extracts 1–10 review scores and venue rating summaries.
• 💬 Returns full written feedback and restaurant replies.
• 👤 Includes public reviewer names, IDs, avatars, and review counts.
• 📷 Preserves public review photo URLs and descriptions.
• 🌍 Supports all reviews or a selected language bucket.
• 🔁 Deduplicates records with stable review UUIDs.
• 📊 Orders results by recency, highest score, or lowest score.

The current public SSR workflow returns up to 40 written reviews per run. This bounded contract keeps runs predictable and avoids claiming unsupported pagination.

Who is it for?

Restaurant groups can monitor feedback for multiple locations and identify recurring service, menu, and ambience themes.

Hospitality agencies can automate weekly reputation reports instead of copying reviews into spreadsheets by hand.

Reputation platforms can ingest structured review and response data through the Apify API, webhooks, or scheduled runs.

Market researchers can compare restaurants by ratings, review language, response behavior, cuisine, average price, and customer comments.

Data and AI teams can feed review text into sentiment, topic modeling, or classification pipelines with stable source IDs.

Why use this TheFork review extractor?

TheFork pages use DataDome protection and hydrated application state. A normal HTTP request often returns a challenge instead of the review content.

This Actor uses browser-compatible HTTP impersonation and residential session rotation to retrieve the public server-rendered review surface. It resolves TheFork's Apollo references and emits flat, typed records.

You get repeatable output without maintaining proxy sessions, parsing changing JSON wrappers, or writing export code.

What data can you extract?

Group	Fields
Review identity	reviewId, restaurantId, restaurantUrl
Review content	rating, text, reviewDate, mealDate, language
Engagement	helpfulCount, photos, ownerResponse, ownerResponseDate
Reviewer	reviewerId, reviewerName, reviewerReviewCount, reviewerAvatarUrl
Restaurant	restaurantName, restaurantAddress, restaurantCuisine
Price	restaurantAveragePrice, restaurantCurrency
Rating summary	restaurantRating, restaurantReviewCount
Category scores	foodRating, serviceRating, ambienceRating
Provenance	scrapedAt

Optional fields are omitted when TheFork does not expose them for a review.

How much does it cost to scrape TheFork reviews?

The Actor uses pay-per-event pricing:

• Start: $0.005 per run.
• Review: $0.001001 per review on the Bronze tier.
• Higher Apify plans receive automatic tier discounts.

At the Bronze price, 10 reviews cost about $0.015 including the start event. Forty reviews cost about $0.045 including the start event.

The Free tier review event is $0.0011511. Final charges appear in the run details, and you can set a maximum total charge in Apify before starting a run.

How to scrape TheFork restaurant reviews

1. Open a public restaurant on TheFork.
2. Copy the restaurant URL or its Reviews-tab URL.
3. Add the URL to Restaurant URLs.
4. Set Maximum reviews between 1 and 40.
5. Choose a language and ordering option.
6. Click Start.
7. Open the Dataset tab to export JSON, CSV, Excel, XML, or RSS.

A valid URL contains a restaurant identifier such as -r819447.

Input parameters

Parameter	Type	Default	Description
startUrls	array	required	Public TheFork restaurant or review URLs
maxReviews	integer	20	Global cap from 1 to 40 unique reviews
language	string	all	all, en, fr, de, it, es, nl, or pt
sortBy	string	newest	newest, highest_rating, or lowest_rating
proxyConfiguration	object	residential GB	Advanced Apify Proxy settings

The same global cap applies when several restaurant URLs are supplied.

Example input

{
  "startUrls": [
    {
      "url": "https://www.thefork.com/restaurant/1905-london-r819447/reviews"
    }
  ],
  "maxReviews": 10,
  "language": "all",
  "sortBy": "newest"
}

For complaint analysis, use lowest_rating. For showcasing positive feedback, use highest_rating.

Example output

{
  "reviewId": "f4e753f9-69f7-4fb4-9908-2f0da65b67fc",
  "restaurantId": "e74eefa0-d31a-416a-833f-d93f9f5fa171",
  "restaurantName": "1905 London",
  "restaurantUrl": "https://www.thefork.com/restaurant/1905-london-r819447/reviews",
  "restaurantAddress": "40 Mortimer Street, W1W 7RQ, London",
  "restaurantCuisine": "Greek",
  "restaurantAveragePrice": 40,
  "restaurantCurrency": "GBP",
  "restaurantRating": 9.2,
  "restaurantReviewCount": 394,
  "foodRating": 9.2,
  "serviceRating": 9.3,
  "ambienceRating": 9.2,
  "reviewerName": "Beth J.",
  "rating": 10,
  "mealDate": "2025-10-05T11:45:00.000Z",
  "text": "Great service and very tasty food.",
  "helpfulCount": 0,
  "photos": [],
  "scrapedAt": "2026-07-22T02:59:03.989Z"
}

Numbers are emitted as numbers, dates as ISO strings when available, and photo collections as arrays.

Review monitoring workflow

Schedule the Actor daily or weekly for each restaurant group.

Use reviewId as the stable key in your database. Upsert each run's rows, then alert only on IDs that were not present in the prior snapshot.

A useful alert rule is:

• notify the manager when rating <= 6;
• include text, mealDate, and ownerResponse;
• suppress the alert if the same reviewId was already handled.

Sentiment and competitor analysis

Export review text to your preferred NLP pipeline and group results by restaurant.

Useful dimensions include:

• average review rating;
• food, service, and ambience summary scores;
• common complaint topics;
• response presence and response wording;
• review volume and reviewer activity;
• language distribution across tourist markets.

Always retain restaurantUrl and reviewId for source traceability.

Tips for reliable runs

• Use canonical public restaurant URLs with a -r<number> identifier.
• Keep the default residential proxy unless you have tested another route.
• Start with 5–10 reviews when validating a new restaurant.
• Use one restaurant per scheduled monitor for simple downstream ownership.
• Treat missing optional fields as source omissions, not empty strings.
• Set a run charge limit when integrating an untrusted external input source.

The Actor fails clearly when only an anti-bot challenge is returned.

Export and integrations

The dataset can be exported directly to:

• Google Sheets for weekly reputation dashboards;
• Slack or email through an Apify webhook for low-score alerts;
• BigQuery, Snowflake, or PostgreSQL for hospitality analytics;
• Zapier or Make for no-code customer-response workflows;
• an LLM for sentiment, topic, and response-draft generation;
• a BI tool for location and competitor scorecards.

Use scheduled runs plus a webhook to create a fully automated monitor.

JavaScript API example

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/thefork-restaurant-reviews-scraper').call({
  startUrls: [{ url: 'https://www.thefork.com/restaurant/1905-london-r819447/reviews' }],
  maxReviews: 10,
  language: 'all',
  sortBy: 'newest',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python API example

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/thefork-restaurant-reviews-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.thefork.com/restaurant/1905-london-r819447/reviews'}],
    'maxReviews': 10,
    'language': 'all',
    'sortBy': 'newest',
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

cURL API example

curl "https://api.apify.com/v2/acts/automation-lab~thefork-restaurant-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.thefork.com/restaurant/1905-london-r819447/reviews"}],
    "maxReviews": 10,
    "language": "all",
    "sortBy": "newest"
  }'

Poll the returned run ID or use the synchronous Apify endpoint for short workflows.

Use with Apify MCP

Add the Actor to Claude Code:

$claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/thefork-restaurant-reviews-scraper"

For Claude Desktop, Cursor, or VS Code, use:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/thefork-restaurant-reviews-scraper",
      "headers": {"Authorization": "Bearer YOUR_APIFY_TOKEN"}
    }
  }
}

Example prompts:

• “Extract the 10 newest reviews from this TheFork restaurant.”
• “Find the lowest-rated feedback and summarize the service complaints.”
• “Compare food, service, and ambience signals in these restaurant reviews.”

Data quality and limitations

The Actor extracts the public data currently exposed by TheFork.

• The public SSR review window is capped at 40 written reviews.
• reviewDate may be absent when the source exposes only mealDate.
• Reviewer profile fields and owner responses are optional.
• Language labels may be absent on individual rows even when a language bucket is used.
• TheFork can change its page application and anti-bot behavior.
• Deleted or moderated reviews can disappear between scheduled runs.

The Actor fails non-zero on total extraction failure rather than returning a false successful empty dataset.

Is it legal to scrape TheFork reviews?

This Actor extracts publicly visible information. Public availability does not remove your responsibilities under applicable law, TheFork's terms, copyright, database rights, privacy rules, or contractual obligations.

Use the data for a legitimate purpose, minimize personal data, secure exports, honor deletion obligations, and avoid harmful profiling. Seek legal advice for regulated or high-risk uses. The Actor is a technical tool, not legal advice.

FAQ

Do I need a TheFork account?

No. The Actor targets public restaurant review pages and does not request login credentials.

Can I scrape more than one restaurant?

Yes. Add several URLs. The maxReviews value is a global cap across the run.

Why is the maximum 40 reviews?

Forty is the verified public server-rendered review window. The Actor intentionally does not claim unverified client-side pagination.

Why did my run report an anti-bot challenge?

TheFork can reject individual proxy sessions. The Actor rotates sessions automatically, but a sustained target-side block can still fail. Retry later or choose another residential country close to the restaurant.

Why is a review field missing?

TheFork does not expose every optional field on every review. For example, many reviews have no photo, avatar, language label, or owner response.

How do I avoid duplicate alerts?

Store reviewId in your destination and process only IDs not seen in previous runs.

Related scrapers

Combine this Actor with other automation-lab tools:

• Google Maps Scraper for place profiles and broader local discovery.
• Trustpilot Reviews Scraper for company reputation monitoring.
• Tripadvisor Scraper for travel and hospitality research.
• Website Content Crawler for public website text extraction.

Use source-specific stable IDs when joining datasets from different review platforms.

Support

If a valid public restaurant URL fails repeatedly, open an Actor issue and include:

• the restaurant URL;
• the run URL or run ID;
• the input without secrets;
• the expected review count;
• whether the page is visible in your normal browser.

Do not post Apify tokens, private proxy credentials, or customer data in support messages.