# Restaurant Contact Scraper (`scrapido/restaurant-contact-scraper`) Actor

🍽️ Restaurant Contact Scraper gathers restaurant and eatery listings from Google Maps—name, address, city, state, ZIP, phone & place ID. 📧 Emails and social links from every site. 🍕 Ideal for POS vendors, suppliers & food tech sales.

- **URL**: https://apify.com/scrapido/restaurant-contact-scraper.md
- **Developed by:** [Scrapido](https://apify.com/scrapido) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

### Restaurant Contact Scraper

**Restaurant Contact Scraper** is an Apify actor that automates restaurant data extraction to solve one painful problem: finding the right restaurant contact information (emails, phone numbers, and social links) at scale without manual copy-paste. Built for marketers, lead gen teams, analysts, and researchers, it turns web research into export-ready results fast—so you can improve ROI and move campaigns forward quickly. 🚀

### What is Restaurant Contact Scraper? 🔍

Restaurant Contact Scraper is an automated web scraping tool (an Apify actor) designed to scrape restaurant contact information from publicly available web sources associated with businesses you target. It focuses on extracting emails, phone numbers, and social media profiles—then saves everything into a structured Apify dataset so you can use it for restaurant lead generation, contact enrichment, and outreach workflows.

If you need a restaurant email extractor that scales beyond manual research, this restaurant contact scraper is built for efficiency. Use it as a restaurant lead generation tool to quickly build contact lists from local business directory scraping, then feed the data into CRMs or email tools for scraping automation and follow-up at speed.

### What Data Does a Restaurant Contact Scraper Collect? 📊

Restaurant Contact Scraper captures structured business identity and contact details—so you can go from “restaurant search” to usable leads in one pipeline. It collects contact info and supporting business context like ratings, reviews, coordinates, and source status.

| Data Category | Fields Extracted | Description |
|---|---|---|
| Contact | `scraped_emails`, `scraped_phones` | Extracted email addresses and phone numbers associated with the restaurant’s online presence |
| Identity | `name`, `website`, `place_id` | Restaurant business name and website link (plus a place identifier when available) |
| Address & Location | `full_address`, `city`, `state`, `zip`, `country_code`, `lat`, `long` | Structured address fields plus latitude/longitude for mapping and geo-segmentation |
| Discovery & Result Tracking | `emails_found`, `pages_scraped`, `scrape_status` | Counts and status that help you assess coverage and run success |
| Social Presence | `scraped_social_media` | Social media profiles/links found alongside the restaurant contact info |

### What Do Results from Restaurant Contact Scraper Look Like? 👀

Each result is a structured record saved to your Apify dataset (one row per business result produced by the actor). Here’s a realistic example:

```json
{
  "name": "Saffron Spice Indian Cuisine",
  "website": "https://www.saffronspice.com",
  "phone": "+1 305-555-0198",
  "full_address": "1820 Collins Ave Miami FL 33139 US",
  "city": "Miami",
  "state": "FL",
  "zip": "33139",
  "country_code": "US",
  "scraped_emails": [
    "reservations@saffronspice.com",
    "info@saffronspice.com"
  ],
  "scraped_phones": [
    "+1 305-555-0198"
  ],
  "scraped_social_media": [
    "https://www.instagram.com/saffronspice.miami/",
    "https://www.facebook.com/saffronspice.miami/"
  ],
  "emails_found": 2,
  "pages_scraped": 7,
  "avg_rating": 4.6,
  "total_reviews": 312,
  "lat": "25.785445",
  "long": "-80.131375",
  "place_id": "ChIJD7fiBh9u5kcR4fJyo8aK4Vg",
  "scrape_status": "success"
}
```

The dataset is exported from Apify Console in JSON (default) and can be downloaded as CSV as well.

#### Core Features: Restaurant Contact Scraper ⚡

| Feature | Benefit |
|---|---|
| ✅ **Location-based restaurant targeting** | Use `googleMapsLocation` to focus on specific regions for lead generation |
| ✅ **Search term driven extraction** | Set `googleMapsSearchTerm` (e.g., “Restaurant”, “coffee shops”, “dentists”) to match your niche |
| ✅ **Business result cap** | Use `maxBusinesses` to control volume and cost for restaurant lead generation |
| ✅ **Per-location vs global limits** | With `scrapeMaxBusinessesPerLocation`, you can cap per region or combine into one total |
| ✅ **Extract emails, phones, and social links** | Pulls `scraped_emails`, `scraped_phones`, and `scraped_social_media` for better contact coverage |
| ✅ **Structured output for CRM import** | Fields like `full_address`, `city`, `state`, and coordinates support downstream enrichment |
| ✅ **Proxy support for reliability** | Built-in proxy support helps keep scraping automation stable under load |
| ✅ **Data cleaning and deduplication-friendly structure** | Output fields are ready for filtering, normalization, and deduplication in your pipeline |
| ✅ **Status and counts included** | `emails_found`, `pages_scraped`, and `scrape_status` make it easy to audit output |

### Getting Started with Restaurant Contact Scraper 🚀

1. **Open Apify Store** — Go to [apify.com/store](https://apify.com/store) and search **Restaurant Contact Scraper**
2. **Click Try for Free** — Sign in or create an Apify account
3. **Open the Input Tab** — Configure your restaurant search settings
4. **Set Your Search Term** — Use `googleMapsSearchTerm` to describe your restaurant niche
5. **Choose One or More Locations** — Add cities/regions in `googleMapsLocation`
6. **Cap the Run** — Set `maxBusinesses` to control how many businesses are collected
7. **(Optional) Enable Per-Location Capping** — Turn on `scrapeMaxBusinessesPerLocation` if you want a fixed cap per location
8. **Run and Export** — Start the actor and download results from the dataset tab

First results are typically fast, and you can iterate quickly by adjusting the search term, location set, and caps.

### Ways to Use Restaurant Contact Scraper 💡

- 🎯 **Restaurant lead generation** — Build segmented business contact lists for outreach and prospecting
- 📣 **Email and phone number extraction** — Enrich your CRM with `scraped_emails` and `scraped_phones`
- 🤝 **Local market research** — Compare restaurant contact availability across locations using structured outputs
- 📊 **Data pipelines** — Feed results into BI dashboards and automated workflows with clean fields
- 🔗 **Social media outreach support** — Use `scraped_social_media` links to expand your omnichannel approach
- ⚙️ **Compliance-minded data work** — Focus on publicly available sources and track `scrape_status` for auditability

#### Input Parameters — Restaurant Contact Scraper

Provide input via the Apify Console form or `input.json`.

```json
{
  "googleMapsSearchTerm": "Restaurant",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `googleMapsSearchTerm` | string | ✅ Yes | `Restaurant` | The business type or niche you want to scrape for email extraction (for example, “coffee shops” or “dentists”) |
| `googleMapsLocation` | array | ✅ Yes | `["New York"]` | Target geographic location(s) to focus the extraction on (for example, “Miami, Florida” as a single string value) |
| `maxBusinesses` | integer | No | `5` | Target number of businesses to find (1–1000). The scraper stops when this target is reached |
| `scrapeMaxBusinessesPerLocation` | boolean | No | `false` | If enabled, collect up to `maxBusinesses` results per location; if disabled, combine locations up to one total limit |
| `proxyConfiguration` | object | No | (see example) | Proxy settings for scraping. Recommended for larger-scale scraping automation |

### Output Format — Restaurant Contact Scraper

The actor saves results into your Apify dataset using this schema:

```json
{
  "name": "Saffron Spice Indian Cuisine",
  "website": "https://www.saffronspice.com",
  "phone": "+1 305-555-0198",
  "full_address": "1820 Collins Ave Miami FL 33139 US",
  "city": "Miami",
  "state": "FL",
  "zip": "33139",
  "country_code": "US",
  "scraped_emails": [
    "reservations@saffronspice.com",
    "info@saffronspice.com"
  ],
  "scraped_phones": [
    "+1 305-555-0198"
  ],
  "scraped_social_media": [
    "https://www.instagram.com/saffronspice.miami/",
    "https://www.facebook.com/saffronspice.miami/"
  ],
  "emails_found": 2,
  "pages_scraped": 7,
  "avg_rating": 4.6,
  "total_reviews": 312,
  "lat": "25.785445",
  "long": "-80.131375",
  "place_id": "ChIJD7fiBh9u5kcR4fJyo8aK4Vg",
  "scrape_status": "success"
}
```

| Field | Label | Format | Description |
|---|---|---|---|
| `name` | Business Name | text | Restaurant business name |
| `website` | Website | link | Restaurant website URL discovered from the business listing |
| `phone` | Phone | text | Phone number captured for the business listing |
| `full_address` | Address | text | Full concatenated address string |
| `city` | City | text | City extracted from the listing/address |
| `state` | State | text | State extracted from the listing/address |
| `zip` | zip | text | ZIP/postal code extracted from the listing/address |
| `country_code` | country\_code | text | Country code extracted from the listing/address |
| `scraped_emails` | Emails Found | array | List of extracted email addresses |
| `scraped_phones` | Phone Numbers | array | List of extracted phone numbers found from the associated website content |
| `scraped_social_media` | Social Media | array | List of extracted social media links |
| `emails_found` | # Emails | number | Count of scraped emails |
| `pages_scraped` | Pages Scraped | number | Number of pages processed during website scraping |
| `avg_rating` | Rating | number | Average rating value |
| `total_reviews` | Reviews | number | Total review count |
| `lat` | lat | text | Latitude value as text |
| `long` | long | text | Longitude value as text |
| `place_id` | place\_id | text | Place identifier associated with the business listing |
| `scrape_status` | Status | text | Scraping outcome status for the record (e.g., success/failed/no\_website/error) |

### Why Choose This Restaurant Contact Scraper? 🏆

If you’re looking for restaurant data extraction that produces structured output you can act on immediately, Restaurant Contact Scraper is a strong choice. It combines business contact information scraping (emails, phone numbers, and social media) with helpful metadata like ratings, reviews, and coordinates—so your restaurant lead generation outputs are usable, not just “found.” With proxy support for reliable scraping automation and dataset-ready fields for data cleaning and deduplication, it’s built for repeatable workflows. For questions, reach out via <scrapidocontact@gmail.com>.

### How Many Results Can You Scrape? 📈

Use `maxBusinesses` (1–1000) to cap the number of businesses the actor targets. If you set `scrapeMaxBusinessesPerLocation` to `true`, the scraper aims for `maxBusinesses` per location; otherwise it combines across locations up to one total limit. Actual email/phone/social coverage depends on what’s publicly listed for each business, but your dataset will include `emails_found`, `pages_scraped`, and `scrape_status` to help you judge quality quickly.

### Legal Guidelines for Scraping Restaurant ⚖️

Restaurant Contact Scraper collects information only from **publicly available sources**. No private or authenticated pages are used. Users are responsible for following applicable laws (including privacy requirements) and for respecting each website’s terms of service and relevant platform policies, especially for marketing communications. Always comply with GDPR/CCPA and local spam regulations when using scraped restaurant contact information. For data removal requests, contact <scrapidocontact@gmail.com>.

### FAQ — Restaurant Contact Scraper ❓

#### How does the Restaurant Contact Scraper identify data?

It uses your `googleMapsSearchTerm` and `googleMapsLocation` inputs to discover restaurant business listings, then scrapes associated publicly available web content to extract emails, phone numbers, and social media links. The actor also provides summary fields like `emails_found`, `pages_scraped`, and `scrape_status` so you can evaluate each record.

#### What restaurant niches can I scrape with Restaurant Contact Scraper?

You can target a broad range of restaurant-related niches by changing `googleMapsSearchTerm`. The actor is designed for contact information extraction for businesses matching your niche phrase, such as “Restaurant” by default or other restaurant-adjacent categories you provide.

#### What do `scraped_emails` and `emails_found` mean?

`scraped_emails` is the array of extracted email addresses for that business. `emails_found` is the numeric count reflecting how many emails were extracted, which helps you quickly filter for high-yield records during restaurant lead generation.

#### Why might some businesses have fewer results?

Not every restaurant has publicly listed contact details in the same places. Some may provide emails but not phone numbers, while others may have websites without extractable emails. Use `pages_scraped` and `scrape_status` to understand whether scraping succeeded and how much content was processed.

#### How do proxies help with reliability?

Proxy support is included to improve scraping automation stability and reduce the chance of interruptions when making many requests across domains. This is particularly useful for larger runs where rate limiting handling and consistency matter.

#### How can I get help or request changes?

If you need support, have a bug report, or want a feature request, contact <scrapidocontact@gmail.com>. We’ll review feedback and help you get the best results from Restaurant Contact Scraper.

### Conclusion 🏁

Restaurant Contact Scraper is a practical, dataset-first way to automate restaurant contact information scraping—turning business listings into structured contact records with emails, phones, social links, and location context. If you’re building restaurant lead generation lists, enrichments, or research datasets, you can ship cleaner leads faster and iterate confidently with `scrape_status`, counts, and export-ready fields. ✅

### Multiple Email Type

**Email Types** keeps only the kinds of mailbox you want. Every row records what
it was classified as in `emailType`.

| Type | What it matches |
| --- | --- |
| Personal | Free webmail (Gmail, Outlook, Yahoo, iCloud, ...) |
| Business | Company domains — free webmail and institutions excluded |
| Education | `.edu`, `.ac.uk`, `.edu.au` and other academic suffixes |
| Government | `.gov`, `.mil`, `.gov.uk`, `.gc.ca`, ... |
| Non-profit | `.org`, `.ngo`, `.org.uk`, ... |

A business found with no email at all is unaffected — whether those rows are
wanted is already governed by the existing email-only setting.

### Multiple Phone Type

**Phone Types** does the same for numbers, checked against the line's *real*
type rather than a guess. Numbers on ranges where mobile and landline cannot be
told apart are kept rather than dropped, since discarding them would lose good
leads.

### Outreach links

| Field | Meaning |
| --- | --- |
| `telLink` | A clickable `tel:` link for the primary number |
| `whatsappLink` | A `wa.me` chat link, or empty for a landline or an invalid number |
| `whatsappCapable` | Whether the line could support WhatsApp |
| `phoneContacts` | Every kept number with its own type, links and validity |

`whatsappCapable` never claims the person uses WhatsApp — only that the number
is of a kind that could. Turn the links off with **Include WhatsApp links**; the
capability flag is still reported.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').

## `googleMapsLocation` (type: `array`):

Target geographic location for the email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of businesses to find (1-1000). The scraper will stop when this target is reached.

## `scrapeMaxBusinessesPerLocation` (type: `boolean`):

If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.

## `validateEmails` (type: `boolean`):

Run DNS/MX validation and confidence scoring on every email found, and include the results (confidence score, validation status, role-based/catch-all flags) in the output.

## `minRating` (type: `integer`):

Skip businesses rated below this (1-5 stars). Leave at 0 for no filter.

## `minReviews` (type: `integer`):

Skip businesses with fewer than this many Google reviews. Leave at 0 for no filter.

## `requireWebsite` (type: `boolean`):

Skip businesses with no website listed on Google Maps (they can't be crawled for contact info anyway).

## `leadMode` (type: `string`):

Business Contacts (default) returns the business's generic contact info (info@, main phone, socials). Decision-Maker Finder instead looks for a named person with a job title (e.g. "Jane Smith, Owner") on the business's team/about pages — a best-effort heuristic, not guaranteed on every site.

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

Proxy settings for scraping. Recommended for large-scale scraping.

## `emailTypes` (type: `array`):

Which kinds of mailbox to keep. Pick as many as you like; leave empty for every type. A business with no email at all is unaffected by this - whether those rows are wanted is governed by the existing email-only setting.

## `phoneTypes` (type: `array`):

Which kinds of line to keep. Leave empty for every type. Numbers on ranges where mobile and landline cannot be told apart are always kept rather than silently dropped.

## `includeWhatsappLinks` (type: `boolean`):

Add a ready-made wa.me chat link for numbers on a line WhatsApp can run on. The link means the number is in a form WhatsApp accepts - not proof that an account exists.

## Actor input object example

```json
{
  "googleMapsSearchTerm": "Restaurant",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "validateEmails": false,
  "minRating": 0,
  "minReviews": 0,
  "requireWebsite": false,
  "leadMode": "Business Contacts",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "emailTypes": [
    "Business"
  ],
  "phoneTypes": [
    "Mobile",
    "Landline"
  ],
  "includeWhatsappLinks": true
}
```

# Actor output Schema

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

No description

# 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 = {
    "googleMapsSearchTerm": "Restaurant",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    },
    "emailTypes": [
        "Business"
    ],
    "phoneTypes": [
        "Mobile",
        "Landline"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapido/restaurant-contact-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 = {
    "googleMapsSearchTerm": "Restaurant",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
    "emailTypes": ["Business"],
    "phoneTypes": [
        "Mobile",
        "Landline",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapido/restaurant-contact-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 '{
  "googleMapsSearchTerm": "Restaurant",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "emailTypes": [
    "Business"
  ],
  "phoneTypes": [
    "Mobile",
    "Landline"
  ]
}' |
apify call scrapido/restaurant-contact-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapido/restaurant-contact-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/mrrzgseoh2voWjKew/builds/BWBTOJemviuYYa8V3/openapi.json