# Google Maps Illinois Restaurants Scraper (`fermaja/google-maps-il-restaurants`) Actor

Turn Google Maps into a ready-to-use Illinois restaurant lead list: names, ratings, review counts, categories, full addresses, phone numbers, and websites across 39 major IL cities — no API key needed.

- **URL**: https://apify.com/fermaja/google-maps-il-restaurants.md
- **Developed by:** [Fermaja](https://apify.com/fermaja) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Illinois Restaurant Leads Scraper (Google Maps)

Turn Google Maps into a clean, ready-to-use dataset of Illinois restaurants. Point it at any city (or use the built-in list of 39 major Illinois cities) and get names, ratings, review counts, categories, full addresses, phone numbers, and websites — structured and exportable in one click.

No Google API key, no per-request billing surprises, no manual copy-pasting from Maps tabs.

### Why use this Actor

- **Statewide coverage out of the box.** Ships with a curated list of Illinois's 39 most populous cities — Chicago, Aurora, Naperville, Springfield, Rockford, Peoria, and more — so you get broad coverage with zero configuration.
- **Real contact data, not just pins.** Opens each listing's detail page to pull phone number and website alongside the standard rating/review/category fields most scrapers stop at.
- **Built for lead lists.** Output maps cleanly onto a spreadsheet: one row per restaurant, consistent columns, ready for CRM import or a cold-outreach list.
- **Tunable cost vs. depth.** Switch off contact-detail scraping for a near-instant, low-cost pass when you only need names and ratings (e.g. market sizing), or turn it on for full sales-ready records.
- **No fragile manual setup.** Runs entirely on Apify's infrastructure with built-in proxy handling — you don't manage browsers, IPs, or rate limits.

### What you get

| Field | Description |
|---|---|
| `name` | Restaurant name |
| `city` | The city/town searched (from your input list) |
| `category` | Google's listing category, e.g. "Italian restaurant", "Gastropub" |
| `rating` | Average star rating (0–5) |
| `reviewsCount` | Number of Google reviews |
| `priceLevel` | Price indicator (`$`–`$$$$`) when available |
| `address` | Full street address |
| `phone` | Phone number |
| `website` | Business website |
| `googleMapsUrl` | Direct link back to the Google Maps listing |

### Input options

| Option | Default | What it does |
|---|---|---|
| `searchTerm` | `restaurants` | The Google Maps search query, e.g. `pizza`, `vegan restaurants`, `sports bars` |
| `cities` | 39 major IL cities | Which cities/towns to search — replace with your own list to focus on a region |
| `maxPlacesPerCity` | `10` | Cap on listings collected per city |
| `maxCities` | `1` | Cap on how many cities from the list to run — defaults to a fast 1-city smoke test; raise it (or clear it) to cover more cities |
| `scrapeContactDetails` | `true` | `true` = visit each listing for phone/website/address (higher quality, more page loads). `false` = fast feed-only pass (name/rating/category only) |
| `maxConcurrency` | `5` | Parallel browser pages — raise for speed, lower to control resource use |

### Use cases

- **Sales & lead generation** — build a call list of restaurants in a target city or across the whole state.
- **Market research** — gauge restaurant density, categories, and average ratings by city before entering a market.
- **Local SEO / marketing agencies** — audit a client's competitive set (ratings, review counts, categories) in their service area.
- **Delivery & POS platform expansion** — identify unlisted or under-served restaurants in a new territory.

### Example output

```json
{
  "name": "The Gage",
  "city": "Chicago, IL",
  "category": "American restaurant",
  "priceLevel": null,
  "rating": 4.6,
  "reviewsCount": 5257,
  "address": "24 S Michigan Ave, Chicago, IL 60603",
  "phone": "(312) 372-4243",
  "website": "thegagechicago.com",
  "googleMapsUrl": "https://www.google.com/maps/place/The+Gage/..."
}
```

Results are available as JSON, CSV, Excel, XML, or RSS directly from the Actor's dataset — no extra transformation step needed.

### Cost estimate

Pricing follows standard Apify compute-unit billing (no separate per-result fee). As a reference point, a full run across all 39 default cities at 30 places/city (~1,100 restaurants) with contact-detail scraping enabled typically costs a few dollars in compute units — comfortably within the free plan's monthly credit for occasional use. Disable `scrapeContactDetails` for a much cheaper, faster pass when full contact info isn't needed.

### FAQ

**Does this need a Google API key?**
No. It reads Google Maps' public search results directly — no API key, no Google Cloud billing account.

**Can I search outside Illinois?**
Yes. The `cities` input accepts any city/region string (e.g. `"Austin, TX"`); the Illinois list is just the default.

**Why is `priceLevel` sometimes empty?**
Google doesn't expose a price indicator for every listing, especially outside dense downtown areas — this is a Google data gap, not a scraper limitation.

**Will running this get my IP blocked?**
The Actor runs through Apify's infrastructure, not your own IP.

# Actor input Schema

## `searchTerm` (type: `string`):

The Google Maps search query to run in each city, e.g. 'restaurants'.

## `cities` (type: `array`):

Google Maps has no single 'search the whole state' mode, so the Actor runs one search per city/town and merges results. Defaults to a curated list of Illinois's most populous cities; override with your own list to narrow or widen coverage.

## `maxPlacesPerCity` (type: `integer`):

Maximum number of restaurant listings to collect per city search.

## `maxCities` (type: `integer`):

Caps how many cities from the list are actually searched. Defaults to 1 city so a default run finishes quickly; raise it (or leave blank) to cover more of Illinois.

## `scrapeContactDetails` (type: `boolean`):

When enabled, opens each place's detail panel to also collect phone number, website, full address, and opening hours. Roughly doubles the number of page loads.

## `maxConcurrency` (type: `integer`):

Maximum number of browser pages running in parallel.

## Actor input object example

```json
{
  "searchTerm": "restaurants",
  "cities": [
    "Chicago, IL",
    "Aurora, IL",
    "Naperville, IL",
    "Joliet, IL",
    "Rockford, IL",
    "Springfield, IL",
    "Elgin, IL",
    "Peoria, IL",
    "Champaign, IL",
    "Waukegan, IL",
    "Cicero, IL",
    "Bloomington, IL",
    "Arlington Heights, IL",
    "Evanston, IL",
    "Decatur, IL",
    "Schaumburg, IL",
    "Bolingbrook, IL",
    "Palatine, IL",
    "Skokie, IL",
    "Des Plaines, IL",
    "Orland Park, IL",
    "Tinley Park, IL",
    "Oak Lawn, IL",
    "Berwyn, IL",
    "Mount Prospect, IL",
    "Normal, IL",
    "Wheaton, IL",
    "Hoffman Estates, IL",
    "Oak Park, IL",
    "Downers Grove, IL",
    "Elmhurst, IL",
    "Glenview, IL",
    "DeKalb, IL",
    "Moline, IL",
    "Belleville, IL",
    "Urbana, IL",
    "Crystal Lake, IL",
    "Quincy, IL",
    "Rock Island, IL",
    "Park Ridge, IL"
  ],
  "maxPlacesPerCity": 10,
  "maxCities": 1,
  "scrapeContactDetails": true,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("fermaja/google-maps-il-restaurants").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("fermaja/google-maps-il-restaurants").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 '{}' |
apify call fermaja/google-maps-il-restaurants --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fermaja/google-maps-il-restaurants"
        }
    }
}
```

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/ifLkfa8DCmQ0geMr9/builds/9ySN8wbSDDWrt1GLU/openapi.json