MenuPages Restaurant Menu Scraper

Turn public MenuPages restaurant pages into analysis-ready menu and price data.

Provide one restaurant URL or a batch of URLs. The Actor returns one row per unique menu item, enriched with restaurant identity, cuisine, address, coordinates, phone number, image, and source information.

Use the output in spreadsheets, databases, BI tools, catalogs, or scheduled price-monitoring workflows.

What does MenuPages Restaurant Menu Scraper do?

MenuPages Restaurant Menu Scraper extracts server-rendered restaurant and menu data from public menupages.com restaurant pages.

It collects:

• 🍽️ restaurant name and cuisine categories
• 📍 street address, city, region, postal code, and country
• 🗺️ latitude and longitude
• ☎️ telephone number
• 🖼️ restaurant image and canonical URL
• 📋 menu section and stable item ID
• 🥘 menu item name and available description or ingredients
• 💵 displayed price, normalized numeric price, and currency
• 🔗 source URL and extraction timestamp

Repeated entries, such as items shown in both “Most Popular” and their normal section, are deduplicated using the restaurant URL and MenuPages item ID.

Who is it for?

Restaurant chains and operators

Compare menus and public prices across nearby restaurants or markets.

Food-data vendors

Build structured menu feeds without manually copying restaurant pages.

Pricing and competitive-intelligence teams

Schedule repeat runs, compare snapshots, and identify price or assortment changes.

Analysts and researchers

Export normalized menu records to CSV, Excel, JSON, or a database.

Developers

Call the Actor through the Apify API and connect results to internal applications.

Why use this MenuPages scraper?

Manual menu collection is slow and inconsistent. A single restaurant may have dozens or hundreds of items, repeated promotional sections, and prices embedded in page markup.

This Actor provides:

• structured rows ready for filtering and joins
• batch processing of multiple restaurant URLs
• deterministic duplicate removal
• both raw and normalized price values
• per-URL errors for stale or unavailable pages
• optional Apify Proxy support for transient access problems
• pay-per-event billing tied to actual saved menu items

What data can you extract?

Field	Type	Description
status	string	success for menu rows or error for failed URLs
restaurantName	string	Restaurant name from structured page data
cuisines	array	Cuisine and meal categories
streetAddress	string	Street address
locality	string	City or locality
region	string	State or region
postalCode	string	Postal code
country	string	Country code or name
latitude	number	Restaurant latitude
longitude	number	Restaurant longitude
telephone	string	Public telephone number
restaurantImageUrl	string	Restaurant image URL
canonicalUrl	string	Canonical MenuPages restaurant URL
itemId	string	Stable MenuPages item identifier
section	string	Menu section name
itemName	string	Menu item name
description	string	Available description or ingredients
rawPrice	string	Price exactly as displayed
price	number	Normalized numeric price
currency	string	Detected currency, usually USD
sourceUrl	string	Requested restaurant page
scrapedAt	string	ISO 8601 extraction timestamp
error	string	Explanation for a failed source URL

How to scrape MenuPages restaurant menus

1. Open the Actor input page.
2. Add one or more public MenuPages restaurant URLs.
3. Choose the maximum number of unique items per restaurant.
4. Leave proxy configuration empty for the normal direct-HTTP route.
5. Click Start.
6. Review the dataset while the run is executing.
7. Export results as JSON, CSV, Excel, XML, or another supported format.

A small first run is recommended before processing a larger restaurant list.

Input

{
  "startUrls": [
    { "url": "https://menupages.com/pings/22-mott-street-new-york" }
  ],
  "maxItemsPerRestaurant": 200
}

startUrls

Required array of exact public MenuPages restaurant-detail URLs.

Only HTTPS URLs on menupages.com are accepted. Search pages, unrelated domains, and malformed paths fail closed instead of returning misleading output.

maxItemsPerRestaurant

Optional integer from 1 to 5,000.

The default is 200. The limit applies after item-ID deduplication and independently to each restaurant.

proxyConfiguration

Optional standard Apify Proxy configuration.

Most public pages work without a proxy. Configure a proxy only when direct access is transiently blocked or a workflow requires a particular proxy policy.

Output example

{
  "status": "success",
  "restaurantName": "Pings",
  "cuisines": ["Asian", "Chinese", "Dinner", "Lunch Specials"],
  "streetAddress": "22 Mott Street",
  "locality": "New York",
  "region": "NY",
  "postalCode": "10013-5001",
  "country": "US",
  "latitude": 40.71439,
  "longitude": -73.99878,
  "telephone": "+12126029988",
  "canonicalUrl": "https://menupages.com/pings/22-mott-street-new-york",
  "itemId": "21889802",
  "section": "Most Popular",
  "itemName": "Pings signature BBQ Roast Pork",
  "rawPrice": "$22.95",
  "price": 22.95,
  "currency": "USD",
  "sourceUrl": "https://menupages.com/pings/22-mott-street-new-york",
  "scrapedAt": "2026-07-17T12:00:00.000Z"
}

Optional fields are omitted when MenuPages does not publish them.

Batch restaurant extraction

Add several URLs to startUrls to create a single tabular dataset across restaurants.

Each row repeats the relevant restaurant metadata. This makes CSV exports self-contained and avoids a second lookup table.

Duplicate input URLs are normalized and processed once per run.

Menu item deduplication

MenuPages may repeat an item in a promotional section such as “Most Popular” and in its regular category.

The Actor keeps the first observed instance for each canonical restaurant URL plus item ID.

This prevents repeated items from inflating exports or PPE charges.

Items without an HTML item ID use a deterministic section-and-name fallback.

Price normalization

rawPrice preserves the text shown on MenuPages.

price extracts a numeric value suitable for sorting, calculations, and comparisons.

currency is set to USD when the displayed value uses a dollar sign.

If no usable price is shown, price fields are omitted rather than invented.

How much does it cost to scrape MenuPages menus?

The Actor uses pay-per-event pricing:

• one Run started charge of $0.005 per run
• one Menu item extracted charge per unique saved menu item

Apify tier	Price per menu item
Free	$0.000029074
Bronze	$0.000025282
Silver	$0.00001972
Gold	$0.000015169
Platinum	$0.000010113
Diamond	$0.00001

At the Bronze rate, 1,000 unique menu items cost about $0.0253 plus the single $0.005 start charge.

Failed URL status rows are not charged as extracted menu items.

For the best value, batch multiple restaurant URLs into one run so the one-time start cost is shared.

Scheduling menu and price monitoring

Apify schedules can run the Actor daily, weekly, or at another interval.

A typical monitoring workflow is:

1. keep a stable list of competitor restaurant URLs
2. run the Actor on a schedule
3. export each run to a timestamped dataset or external database
4. compare records by canonicalUrl and itemId
5. alert when price, itemName, or section membership changes

The Actor returns scrapedAt on every row to support snapshot comparisons.

Integrations

Google Sheets

Use an Apify integration or automation platform to append each scheduled dataset to a sheet used by pricing analysts.

Webhooks

Send a webhook when a run finishes, then fetch the default dataset from your own application.

Make and Zapier

Trigger downstream workflows for menu enrichment, competitor tracking, or data delivery.

Cloud storage and databases

Export JSON or CSV into Amazon S3, Google Drive, PostgreSQL, BigQuery, Snowflake, or your preferred warehouse through Apify integrations or API code.

API usage with JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/menupages-restaurant-menu-scraper').call({
  startUrls: [
    { url: 'https://menupages.com/pings/22-mott-street-new-york' }
  ],
  maxItemsPerRestaurant: 200,
});

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

API usage with Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/menupages-restaurant-menu-scraper').call(run_input={
    'startUrls': [
        {'url': 'https://menupages.com/pings/22-mott-street-new-york'}
    ],
    'maxItemsPerRestaurant': 200,
})

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

API usage with cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~menupages-restaurant-menu-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [
      {"url": "https://menupages.com/pings/22-mott-street-new-york"}
    ],
    "maxItemsPerRestaurant": 200
  }'

Use the returned run ID to inspect status and retrieve the default dataset.

Use with Apify MCP and AI agents

Claude Code setup

Add Apify MCP over HTTP with the Actor preselected:

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

Claude Desktop setup

Add this entry to the mcpServers object in the Claude Desktop configuration:

{
  "mcpServers": {
    "apify-menupages": {
      "url": "https://mcp.apify.com/?tools=automation-lab/menupages-restaurant-menu-scraper"
    }
  }
}

Cursor setup

Add the same mcpServers JSON to Cursor’s MCP configuration, or add the HTTP server URL through Settings → MCP.

VS Code setup

Open the MCP server configuration in VS Code and add the Apify HTTP endpoint shown above. Authenticate with your Apify account when prompted.

Specific example prompts:

• “Extract the first 100 menu items from this MenuPages restaurant and group them by section.”
• “Compare normalized prices for these three MenuPages restaurants.”
• “Run the MenuPages competitor menu monitor and flag items whose price changed since yesterday.”

Error handling

When one URL fails, the Actor writes an explicit dataset row containing:

{
  "status": "error",
  "sourceUrl": "https://menupages.com/example/missing-location",
  "error": "MenuPages returned HTTP 404.",
  "scrapedAt": "2026-07-17T12:00:00.000Z"
}

Other valid URLs in the same batch continue processing.

If every requested URL fails, the run ends with a failed status after writing the error rows. This prevents empty or broken extraction from looking successful.

Tips for reliable runs

• Use exact restaurant-detail URLs copied from MenuPages.
• Keep the initial prefilled limit small for a quick validation run.
• Increase maxItemsPerRestaurant when you need the full menu.
• Batch URLs to reduce repeated start charges.
• Schedule snapshots at a consistent time for easier comparisons.
• Match records using canonicalUrl plus itemId.
• Inspect error rows before retrying stale restaurant URLs.
• Enable a proxy only after direct access shows a repeatable block.

Limitations

The Actor extracts data that MenuPages publishes on public restaurant pages at run time.

It does not discover restaurants by keyword, city, or cuisine in the current version; provide exact restaurant URLs.

It does not place orders, log into accounts, or collect private information.

Descriptions and prices may be absent for some items because the source page does not provide them.

MenuPages can change its HTML structure or remove stale restaurant pages. Clear error rows and failed-all behavior make those changes visible.

Is it legal to scrape MenuPages?

This Actor accesses public web pages and does not bypass login controls.

You are responsible for ensuring that your use complies with applicable laws, contractual obligations, website terms, and data-protection requirements.

Avoid collecting or using data in ways that infringe rights or create harmful outcomes. Use conservative schedules and reasonable batch sizes.

This documentation is informational and is not legal advice.

Troubleshooting

Why did my URL produce an error row?

Confirm that it is an HTTPS MenuPages restaurant-detail URL with both a restaurant slug and a location slug. Open it manually to check whether the restaurant still exists.

Why are some descriptions or prices missing?

MenuPages does not publish those values for every menu item. The Actor omits missing fields instead of guessing.

Why are there fewer rows than visible item placements?

The same item can appear in more than one section. The Actor intentionally deduplicates repeated MenuPages item IDs.

Why did the entire run fail?

The run fails when every requested restaurant fails extraction. Read the dataset error rows and logs, then update stale URLs or try an appropriate proxy configuration.

Can I scrape non-MenuPages websites?

No. Domain validation is intentionally strict. Use an actor designed for that source.

FAQ

Can I process multiple restaurants in one run?

Yes. Add every restaurant URL to startUrls. Each valid restaurant is processed independently.

Does it support scheduled price tracking?

Yes. Combine Apify schedules with dataset exports or webhooks and compare records by canonicalUrl and itemId.

Are repeated “Most Popular” entries charged twice?

No. Repeated stable item IDs are removed before output and charging.

Does it need a browser?

No. The useful restaurant and menu data is server-rendered, so the Actor uses a lightweight HTTP and Cheerio implementation.

Does it need a proxy?

Not normally. Proxy configuration is optional for transient blocking or organization-specific routing policies.

What export formats are available?

Apify datasets support JSON, JSONL, CSV, Excel, XML, RSS, and other formats.

Related restaurant data actors

• Grubhub Restaurant Menus Scraper — scrape Grubhub restaurant listings and menu items.
• DoorDash Scraper — collect restaurant and delivery marketplace data from DoorDash.
• Google Maps Scraper — discover restaurants and other places before sending exact URLs to source-specific workflows.

Choose this Actor when the source records you need are public MenuPages restaurant pages.

Support

If a valid public MenuPages restaurant URL stops working, open an issue from the Actor page and include:

• the source URL
• the run ID
• the expected result
• the actual error or missing field

A reproducible example helps us adapt quickly when the source changes.