# Michelin Guide Scraper (`crawlerbros/michelin-guide-scraper`) Actor

Scrape Michelin-starred restaurants from guide.michelin.com. Search by name, filter by city or country, browse all starred restaurants, or fetch individual restaurant pages. Returns name, stars, address, cuisine, price range, coordinates, and more

- **URL**: https://apify.com/crawlerbros/michelin-guide-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Travel
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Michelin Guide Scraper

Extract restaurant data from the [Michelin Guide](https://guide.michelin.com) — the world's most prestigious restaurant rating system. Collect Michelin-starred restaurants, Bib Gourmand picks, and Michelin Selected restaurants with full details including star ratings, cuisine, address, coordinates, price range, and contact information.

### What You Can Scrape

- **Starred restaurants** (1-star, 2-star, 3-star) worldwide or by country/city
- **Bib Gourmand** listings — exceptional value restaurants recognized by Michelin
- **Michelin Selected** restaurants — quality picks that don't hold stars
- **Search** restaurants by name or keyword
- **Individual restaurant pages** from direct URLs

### Output Data

Each record includes:

| Field | Description |
|-------|-------------|
| `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 |
| `address` | Full address string |
| `city` | City |
| `country` | Country |
| `postalCode` | Postal/ZIP code |
| `cuisine` | Cuisine type(s) |
| `priceRange` | Price symbols (e.g. `$$$$`) |
| `phone` | Reservation phone number |
| `website` | Restaurant official website |
| `latitude` | GPS latitude |
| `longitude` | GPS longitude |
| `imageUrl` | Cover photo URL |
| `description` | Short description |
| `openingHours` | Opening hours |
| `scrapedAt` | ISO 8601 timestamp |

### Input Options

#### Mode

| Mode | Description |
|------|-------------|
| `starredRestaurants` | Browse all starred/Bib Gourmand restaurants (default) |
| `search` | Search by restaurant name or keyword |
| `byCity` | Browse restaurants in a specific city |
| `byUrl` | Scrape individual restaurant URL(s) |

#### Filters

- **Star / distinction filter**: filter by 1-star, 2-star, 3-star, Bib Gourmand, or Selected
- **Country**: limit to a specific country (France, Japan, United States, etc.)
- **Cuisine**: filter by cuisine type (French, Japanese, Italian, etc.)

#### Example Inputs

**Browse all 3-star restaurants in France:**
```json
{
  "mode": "starredRestaurants",
  "country": "france",
  "starFilter": "3",
  "maxItems": 30
}
````

**Search restaurants in Tokyo:**

```json
{
  "mode": "search",
  "searchQuery": "tokyo sushi",
  "maxItems": 20
}
```

**Browse Paris restaurants by city:**

```json
{
  "mode": "byCity",
  "city": "Paris",
  "country": "france",
  "maxItems": 50
}
```

**Scrape specific restaurant pages:**

```json
{
  "mode": "byUrl",
  "startUrls": [
    {"url": "https://guide.michelin.com/en/ile-de-france/paris/restaurant/guy-savoy"}
  ]
}
```

### Use Cases

- **Restaurant industry research** — analyze Michelin-starred restaurants by region, cuisine, or price
- **Travel planning** — find top restaurants for destination planning apps
- **Food & dining datasets** — build databases of fine dining establishments
- **Market analysis** — track restaurant openings, closings, and star promotions
- **Competitor analysis** — benchmark restaurant categories and pricing

### FAQ

**How often is the data updated?**
The Michelin Guide updates its listings annually (typically in February-March). This scraper always retrieves the current live data from their website.

**Does this require login or cookies?**
No. All data is publicly accessible on guide.michelin.com without authentication.

**Can I scrape all countries?**
Yes. Use `mode=starredRestaurants` without a country filter to browse globally. Add a `country` filter to focus on a specific region.

**Why might some restaurants be missing coordinates?**
Not all restaurant pages include embedded geo-coordinates. The scraper extracts coordinates when available in the page metadata.

**What is the difference between Bib Gourmand and Michelin Selected?**
Bib Gourmand recognizes restaurants offering excellent quality at moderate prices. Michelin Selected (formerly "Michelin Plate") identifies restaurants serving good food but not yet receiving a star.

**How many restaurants are in the Michelin Guide?**
The guide covers thousands of restaurants across 40+ countries. The global starred list has roughly 3,000+ establishments (1-star through 3-star combined).

# Actor input Schema

## `mode` (type: `string`):

What to fetch from the Michelin Guide.

## `searchQuery` (type: `string`):

Restaurant name or keyword to search for (mode=search).

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

City name to browse restaurants in (mode=byCity), e.g. `Paris`, `Tokyo`, `New York`.

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

Filter by country slug used in Michelin Guide URLs, e.g. `france`, `japan`, `united-states`.

## `starFilter` (type: `string`):

Filter restaurants by Michelin distinction (applies to all modes).

## `cuisineFilter` (type: `string`):

Filter by cuisine type.

## `startUrls` (type: `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`.

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

Maximum number of restaurant records to emit.

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

Apify proxy settings. AUTO datacenter proxy is used by default for Michelin Guide bot-detection bypass.

## Actor input object example

```json
{
  "mode": "starredRestaurants",
  "country": "",
  "starFilter": "",
  "cuisineFilter": "",
  "startUrls": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Michelin Guide restaurant records.

# 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 = {
    "mode": "starredRestaurants",
    "country": "",
    "starFilter": "",
    "cuisineFilter": "",
    "startUrls": [],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/michelin-guide-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 = {
    "mode": "starredRestaurants",
    "country": "",
    "starFilter": "",
    "cuisineFilter": "",
    "startUrls": [],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/michelin-guide-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 '{
  "mode": "starredRestaurants",
  "country": "",
  "starFilter": "",
  "cuisineFilter": "",
  "startUrls": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/michelin-guide-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Michelin Guide Scraper",
        "description": "Scrape Michelin-starred restaurants from guide.michelin.com. Search by name, filter by city or country, browse all starred restaurants, or fetch individual restaurant pages. Returns name, stars, address, cuisine, price range, coordinates, and more",
        "version": "1.0",
        "x-build-id": "aFluTgiMd28nESYcd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~michelin-guide-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-michelin-guide-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/crawlerbros~michelin-guide-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-michelin-guide-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/crawlerbros~michelin-guide-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-michelin-guide-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "starredRestaurants",
                            "search",
                            "byCity",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch from the Michelin Guide.",
                        "default": "starredRestaurants"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Restaurant name or keyword to search for (mode=search)."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name to browse restaurants in (mode=byCity), e.g. `Paris`, `Tokyo`, `New York`."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "",
                            "france",
                            "japan",
                            "united-states",
                            "united-kingdom",
                            "italy",
                            "spain",
                            "germany",
                            "switzerland",
                            "belgium",
                            "netherlands",
                            "austria",
                            "sweden",
                            "norway",
                            "denmark",
                            "portugal",
                            "singapore",
                            "hong-kong-macau",
                            "south-korea",
                            "china",
                            "taiwan",
                            "thailand",
                            "malaysia",
                            "brazil",
                            "mexico",
                            "canada",
                            "australia"
                        ],
                        "type": "string",
                        "description": "Filter by country slug used in Michelin Guide URLs, e.g. `france`, `japan`, `united-states`.",
                        "default": ""
                    },
                    "starFilter": {
                        "title": "Star / distinction filter",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "bib",
                            "selected"
                        ],
                        "type": "string",
                        "description": "Filter restaurants by Michelin distinction (applies to all modes).",
                        "default": ""
                    },
                    "cuisineFilter": {
                        "title": "Cuisine filter",
                        "enum": [
                            "",
                            "french",
                            "japanese",
                            "italian",
                            "chinese",
                            "mediterranean",
                            "contemporary",
                            "creative",
                            "seafood",
                            "steakhouse",
                            "sushi",
                            "thai",
                            "korean",
                            "indian",
                            "spanish",
                            "american",
                            "european",
                            "modern-british",
                            "cantonese",
                            "dim-sum",
                            "ramen",
                            "vegetarian"
                        ],
                        "type": "string",
                        "description": "Filter by cuisine type.",
                        "default": ""
                    },
                    "startUrls": {
                        "title": "Start URLs (mode=byUrl)",
                        "type": "array",
                        "description": "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": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of restaurant records to emit.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. AUTO datacenter proxy is used by default for Michelin Guide bot-detection bypass.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
