Michelin Guide Scraper: 26 Data Fields, Up to 1,000 Free Results/Month

Each record carries 26 output fields, capturing star ratings, cuisine types, addresses, and optional geo-coordinates from guide.michelin.com. This data collector is built for analysts and engineers needing structured fine-dining datasets across global regions. It is not for anyone who needs internal reservation logs or historical pricing archives, which are absent from the records.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 1,000 results at $0.005 each before platform usage. Open Michelin Guide Scraper on Apify and run the prefilled example.

How reliable is Michelin Guide Scraper in production?

Across the last 30 days of public runs on the Apify platform, Michelin Guide Scraper recorded 57 runs with the following outcomes.

To maintain data continuity, build automated retries and alerting into your workflow. User-aborted runs are not failures and are not included in this rate.

What does it cost to run Michelin Guide Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Worked example: collecting 10,000 results costs $50.00 in result charges before run-start fees and platform usage. With 22.8% of runs failing or timing out in the last 30 days, budget for re-running a portion of those batches rather than assuming every run completes.

The maxItems control is the primary driver of your bill because result charges apply to each restaurant record written to the dataset. To find out if this Actor meets your requirements without overspending, use the example input cap of 5 items for your first run.

How do you run Michelin Guide Scraper from the API?

The schema marks 1 of its 10 controls as required: mode. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~michelin-guide-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"starredRestaurants","country":"","starFilter":"","cuisineFilter":"","startUrls":[],"maxItems":5,"includeDetails":false,"proxyConfiguration":{"useApifyProxy":true}}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "starredRestaurants",
  "country": "",
  "starFilter": "",
  "cuisineFilter": "",
  "startUrls": [],
  "maxItems": 5,
  "includeDetails": False,
  "proxyConfiguration": {
    "useApifyProxy": True
  }
}

run = client.actor("crawlerbros~michelin-guide-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "starredRestaurants",
  "country": "",
  "starFilter": "",
  "cuisineFilter": "",
  "startUrls": [],
  "maxItems": 5,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

const run = await client.actor('crawlerbros~michelin-guide-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which Michelin Guide Scraper inputs matter, and which can you skip?

The input schema provides 10 controls, but only mode is required. Most practitioners should start with a simple city or country filter before adding a cuisineFilter to verify how Michelin labels different regional styles.

• mode (string): What to fetch from the Michelin Guide. Default: "starredRestaurants".
• searchQuery (string): Restaurant name or keyword to search for (mode=search).
• city (string): City name to browse restaurants in (mode=byCity), e.g. Paris, Tokyo, New York.
• country (string): Filter by country slug used in Michelin Guide URLs. Use lowercase slug format (e.g. 'france', 'japan', 'united-states'). The value is automatically normalized to lowercase if entered manually. Default: "".
• starFilter (string): Filter restaurants by Michelin distinction (applies to all modes). Default: "".
• cuisineFilter (string): Filter by cuisine type. Note: 'Classic Cuisine' and 'Traditional Cuisine' are how Michelin labels most French/regional cuisine in France - use those options to find French cuisine restaurants in Paris, Lyon, etc. 'French' matches restaurants explicitly labeled 'French' by Michelin, which is more common outside France. Default: "".
• startUrls (array): List of Michelin Guide restaurant page URLs to scrape (mode=byUrl). Each item must have a url key, e.g. https://guide.michelin.com/en/ile-de-france/paris/restaurant/guy-savoy. Default: [].
• maxItems (integer): Maximum number of restaurant records to emit. Default: 20.
• includeDetails (boolean): If enabled, the scraper visits each individual restaurant page for additional data (phone, website, geo-coordinates, opening hours, full description). Note: detail pages may be rate-limited or blocked in some regions; listing data is always scraped regardless of this setting. Default: false.
• proxyConfiguration (object): Apify proxy settings. AUTO datacenter proxy is used by default for Michelin Guide bot-detection bypass. Default: {"useApifyProxy":true}.

Fixed-choice controls: mode accepts starredRestaurants (Starred & Bib Gourmand restaurants (browse all)), search (Search restaurants by name or keyword), byCity (Browse restaurants by city), byUrl (Scrape individual restaurant URL(s)); country accepts 27 values (default ""), including "" (All countries), france, japan, united-states (United States); starFilter accepts "" (All distinctions), 1 (1 Star), 2 (2 Stars), 3 (3 Stars), bib (Bib Gourmand), selected (Michelin Plate); cuisineFilter accepts 24 values (default ""), including "" (All cuisines), classic (Classic Cuisine), traditional (Traditional Cuisine), french.

What does Michelin Guide Scraper return?

The returned records provide a foundation for regional culinary databases and tourism apps. They do not include private booking engine data or historical rating archives from previous years.

• name: Restaurant name
• url: Michelin Guide URL
• slug: URL slug identifier
• stars: Michelin star count (1, 2, or 3)
• bibGourmand: true if Bib Gourmand designation
• michelinSelected: true if Michelin Selected
• distinction: Raw distinction label from Michelin
• address: Full address string
• city: City
• country: Country or region (may be ISO code, e.g. "FRA")
• postalCode: Postal/ZIP code
• countryCode: 2-letter ISO country code (e.g. "FR", "JP")
• cuisine: Cuisine type(s) as labeled by Michelin
• priceRange: Price range: "$" - "$$" from listings, or text from detail pages
• hasOnlineBooking: true if online reservations available via Michelin Guide
• chefName: Head chef name
• district: Neighbourhood/district
• phone: Reservation phone number (detail page)
• website: Restaurant official website (detail page)
• latitude: GPS latitude (detail page)
• longitude: GPS longitude (detail page)
• imageUrl: Cover photo URL (detail page)
• description: Short editorial description (detail page)
• openingHours: Opening hours list (detail page)
• recordType: Always "restaurant"
• scrapedAt: ISO 8601 scrape timestamp

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Michelin Guide Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Set the mode control to starredRestaurants to browse all listings globally or select byCity for a specific market.
2. Choose a target country slug from the country control list if you want to restrict results to a single region.
3. Apply the starFilter control to pull only 1, 2, 3 star establishments or Bib Gourmand picks.
4. Set the cuisineFilter control if you need to isolate specific culinary styles such as classic, traditional, or french.
5. Toggle the includeDetails control to true if your project requires GPS coordinates, phone numbers, and website links.
6. Set maxItems to a small integer like 5 for your initial test run to verify dataset output before scaling up.
7. Execute the run and check the output dataset to ensure fields like name, stars, and address are correctly populated.

How do you apply it? Three worked playbooks

These are Michelin Guide Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Restaurant industry research

Outcome: Analyze Michelin-starred restaurants by region, cuisine, or price

Configure: Set mode to byCity, specify a city in the city control, and apply a cuisineFilter value.

Working method: Start with a single city and cuisine combination using a low maxItems cap, compare the returned entries against known local venues, and then widen the geographic scope.

Deliverable: A structured JSON dataset containing restaurant names, star counts, addresses, and cuisine classifications.

Stop condition: Zero records returned or empty cuisine strings appearing across consecutive pagination requests.

Use case 2: Travel planning

Outcome: Find top restaurants for destination planning apps

Configure: Set mode to starredRestaurants, select a destination country in the country control, and enable includeDetails.

Working method: Run a targeted query for a single destination city with maxItems set to 20, verify that latitude and longitude coordinates resolve correctly, and then expand to country-level browsing.

Deliverable: A geo-tagged restaurant catalog including coordinates, price ranges, and active website links.

Stop condition: Missing latitude or longitude values on more than ten percent of the fetched detail records.

Use case 3: Market analysis

Outcome: Track restaurant openings, closings, and star promotions

Configure: Set mode to byUrl, supply a list of target restaurant pages in startUrls, and set includeDetails to true.

Working method: Execute scheduled runs against a fixed list of URLs, compare the current scraped timestamp and star count against historical logs, and flag any status shifts.

Deliverable: A time-stamped comparison log detailing changes in star ratings, chef names, and operating statuses.

Stop condition: HTTP errors or empty payloads returned for more than half of the supplied startUrls.

What breaks, and how do you design around it?

• Over the last 30 days, 8.8% of public runs failed and 14.0% timed out. Build retries and alerting around those rates rather than assuming every run completes.

When the scraper is blocked in specific regions, fetching detail page data may fail even if the listing data is retrieved. Disable includeDetails if you hit persistent timeouts while trying to fetch phone numbers and coordinates.

When should you not use Michelin Guide Scraper?

Do not use this Actor if you require official regulatory health inspection records, which Michelin does not provide. For structured health department data in New York, use the NYC Restaurant Inspection Scraper. If your project requires delivery fee analysis or estimated wait times across South America, the Rappi Restaurant Scraper is a more appropriate choice. Avoid this tool if you need live real-time table availability, and instead consider the OpenTable + Resy Scraper for booking-specific data.

What should you check before trusting the output?

• Verify that the name field is present and non-empty on every returned record in the dataset.
• Check that the stars field contains a valid integer between 1 and 3 when filtering for starred establishments.
• Confirm that detail-page fields such as phone and website are populated only when includeDetails is enabled.
• Ensure that the address and city fields match the expected geographic parameters of your search query.
• Stop scheduled runs immediately if the failure or timeout rate exceeds twenty percent across consecutive batches.

None of this proves a record is correct. It gives a scheduled Michelin Guide Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does it cost to scrape 1,000 Michelin restaurants?

On the free plan, 1,000 results cost $5.00 in result charges. This figure does not include the run-start fee charged every time a run begins or the platform usage consumed during the crawl. Apify's free plan includes $5.00 of monthly usage, which effectively covers your first 1,000 results.

Is it possible to scrape restaurant phone numbers and GPS coordinates?

Yes, the output includes phone, website, latitude, and longitude fields. These are populated when includeDetails is enabled, which instructs the Actor to visit each restaurant's individual detail page for additional data. Listing data is always scraped regardless of this setting.

How can I reliably scrape restaurants in South Korea?

The Michelin Guide may serve global listings from US-based IPs for specific countries like South Korea or the UK. If you encounter issues with the country filter for these regions, the documentation suggests using mode set to byCity with a specific city name to obtain more reliable results.

What is the success rate of the Michelin Guide Scraper?

In the last 30 days, the Actor has a success rate of 75.4%, with 43 of 57 runs succeeding. Approximately 23 in a hundred runs fail or time out, so it is recommended to implement retry logic for production schedules.

How do I filter for restaurants that offer good value?

To find restaurants recognized for value, set the starFilter control to bib. This will return Bib Gourmand restaurants, which is Michelin's specific designation for establishments offering high-quality food at moderate price points.

Where to go next

When you are ready to run it, open Michelin Guide Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the Michelin Guide Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• GoCollect Comic Price Guide Scraper: Scrape GoCollect's comic book price guide and sales-history data.
• Rappi Restaurant Scraper: Scrape Rappi restaurant listings across Latin America.
• NYC Restaurant Inspection Scraper: Scrape the official NYC DOHMH Restaurant Inspection Results open dataset.
• Atlas Obscura Scraper: Scrape Atlas Obscura, the world's definitive guide to 30K+ hidden wonders, unusual, and offbeat destinations.
• OpenTable + Resy Scraper: Scrape restaurant data from OpenTable and Resy in a single actor.
• Bing Maps Business Listings Scraper: Scrape business listings from Bing Maps.
• Foodpanda Restaurant & Menu Scraper: Scrape Foodpanda restaurants by URL or location.
• VinylHub Record Store Scraper: Scrape VinylHub - the world's largest record store directory powered by Discogs.

Related guides:

• DoorDash Restaurant Scraper: Up to 500 Free Results a Month (2026)

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-25.

• Actor last updated by its maintainers on 2026-06-21.

• Run outcome figures cover the 30 day public window ending 2026-09-25.

• Michelin Guide Scraper on Apify