# Google Maps Business Leads Scraper — Email, Phone & Socials (`haketa/google-maps-contacts-scraper`) Actor

Scrape Google Maps businesses by search query and enrich into leads: name, phone, website, rating, address, category, coordinates + email and social profiles from each website. Local B2B lead-gen. Independent tool, not affiliated with or endorsed by Google.

- **URL**: https://apify.com/haketa/google-maps-contacts-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation, Business
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 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

## 📍 Google Maps Business Leads Scraper — Email, Phone & Socials

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue?logo=apify\&logoColor=white)](https://apify.com/haketa/google-maps-contacts-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained-Active-brightgreen)](#-changelog)
[![Data Quality](https://img.shields.io/badge/Deduplicated-100%25-success)](#-key-features)
[![Output Formats](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-orange)](#-data-fields--output-structure)
[![Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B%20Unlocked-blueviolet)](#-at-a-glance)
[![Enrichment](https://img.shields.io/badge/Enrichment-Email%20%7C%20Socials%20%7C%20Phone-success)](#-contact-enrichment-pipeline)

Turn Google Maps searches into structured, outreach-ready B2B sales lead lists. Extract local business listings across any industry and geographic territory — capturing verified company names, primary categories, Google star ratings, total review counts, formatted physical addresses, GPS coordinates, local and international phone numbers, and website URLs.

When contact enrichment is enabled, the actor automatically navigates to each business's website and extracts **direct email addresses** (including mailto links and contact page crawling) alongside verified social media profiles across **Facebook, Instagram, LinkedIn, Twitter/X, and YouTube**.

Export directly to **JSON, CSV, Excel, or API** — or feed real-time prospect data directly into your CRM, cold outreach workflows, Google Sheets, Zapier, or Make.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Data Source** | Google Maps Local Business Directory & Live Company Websites |
| **Search Syntax** | Standard search queries (`"<category> in <city, state/country>"`) |
| **Pagination Model** | Deep pagination per query (20 places/page, set `0` for auto/unlimited) |
| **Contact Enrichment** | In-depth website crawling for verified email addresses & social media profiles |
| **Supported Socials** | LinkedIn, Facebook, Instagram, Twitter / X, YouTube |
| **Throughput Speed** | ~40–60 enriched leads per minute (~15–30s on prefill runs) |
| **Deduplication** | Automatic deduplication by Google Place ID (0% duplicates) |
| **Export Formats** | Dataset (JSON, CSV, XML, Excel) & Key-Value Store `OUTPUT` mirror |
| **Proxy Requirement** | Apify Proxy Datacenter (enabled by default, fully supported) |
| **Default Sample Run** | Automatic dual-market sample (Miami & Seattle) when run with `{}` |

***

### 🔎 Why scrape Google Maps for business leads?

Google Maps is the world's most expansive, continuously updated directory of local commerce. Every brick-and-mortar store, professional service firm, contractor, clinic, and independent agency maintains a verified presence with hours, phone numbers, and operational websites.

However, a standard Google Maps listing alone is insufficient for scalable B2B outbound campaigns:

1. **Missing Direct Email Contacts:** Google Maps displays phone numbers and physical locations, but hides direct emails.
2. **Missing Social Media Profiles:** Sales teams require LinkedIn company profiles and Instagram handles to multi-thread outreach across channels.
3. **Manual Data Entry Bottleneck:** Visiting hundreds of individual websites, parsing footers, and copying contact info manually takes dozens of rep hours per campaign.

This scraper solves the entire lead generation pipeline in a single automated step: it queries Google Maps, extracts every business record, and visits each corresponding website in parallel to harvest verified emails and social channels.

#### Primary Use Cases:

- **High-Velocity Cold Email & Calling:** Generate hyper-targeted lists of local contractors, dental clinics, accountants, or restaurants with validated phone numbers and email addresses.
- **Agency Client Acquisition:** Discover local businesses with subpar review counts, missing social links, or incomplete websites to pitch web design, SEO, and reputation management services.
- **Territory Planning & Market Penetration:** Map competitive density and service saturation across target cities or metropolitan areas.
- **CRM Enrichment & Hygiene:** Cleanse and update existing client accounts with verified geographic coordinates, active domains, and refreshed phone numbers.
- **Local Marketplace Seeding:** Populate vertical directories and local discovery platforms with structured, categorized business data.

***

### ✨ Key features

- 🎯 **Natural Language Query Flexibility:** Search in any natural format (`"plumbers in Austin TX"`, `"coffee shops in Seattle"`, `"law firms in London"`). Run multiple queries concurrently in a single batch.
- ⚡ **Deep Multi-Page Pagination (1,000+ Results):** Automatically paginates through consecutive 20-listing result sets without hitting arbitrary stopping limits.
- 📧 **Automated Multi-Source Email Extraction:** Scrapes direct `mailto:` links, scans full homepage HTML, and intelligently crawls secondary `/contact` and `/about` subpages if the homepage lacks an email.
- 📱 **Multi-Platform Social Profile Harvesting:** Detects and verifies profile links across LinkedIn (company & personal pages), Facebook, Instagram, Twitter/X, and YouTube.
- 🧹 **Robust Deduplication Engine:** In-memory caching by Google Place ID prevents duplicate records even when executing overlapping geographic or category searches.
- 🌍 **Global Coverage:** Operates across all international Google Maps locales, languages, and country domains.
- 🚀 **Parallel HTTP Architecture:** Concurrently crawls up to 6 websites simultaneously, maintaining rapid execution speeds while adhering to proxy rotation standards.

***

### 📥 Input parameters

The actor features user-friendly, sensible defaults. All properties can be customized via the web console or JSON API payload.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | `array` | `["dentists in Miami FL", "coffee shops in Seattle WA"]` | Search terms in `<what> in <where>` format. Each query is processed independently. |
| `includeEmails` | `boolean` | `true` | When true, crawls each business website to extract emails and social media profiles. |
| `maxPagesPerQuery` | `integer` | `0` | Maximum pages to paginate per query (20 businesses/page). Set `0` for auto/unlimited governed by `maxItems`. |
| `maxItems` | `integer` | `0` | Total maximum businesses to scrape across all queries (`0` = no limit; prefilled to `50` for fast validation). |
| `proxyConfiguration` | `object` | `{ "useApifyProxy": true }` | Proxy configuration. Apify Datacenter proxies are enabled by default. |

***

### 📊 Data fields & output structure

Every record represents a unique local business enriched with both Google Maps directory metadata and website contact intelligence.

#### 🏢 Core Directory Data (from Google Maps)

| Field | Type | Coverage | Description |
|---|---|---|---|
| `placeId` | `string` | 🟢 High (100%) | Unique Google Place ID identifier |
| `name` | `string` | 🟢 High (100%) | Official registered business name |
| `category` | `string` | 🟢 High (>98%) | Primary business classification category |
| `categories` | `string` | 🟢 High (>95%) | Full array of secondary industry categories |
| `rating` | `string` | 🟢 High (>90%) | Google Maps average star rating (1.0–5.0) |
| `reviewCount` | `string` | 🟢 High (>90%) | Total number of published customer reviews |
| `phone` | `string` | 🟢 High (>95%) | Local formatted telephone number |
| `phoneIntl` | `string` | 🟢 High (>95%) | International formatted telephone number with country code |
| `website` | `string` | 🟢 High (>85%) | Clean destination website URL |
| `websiteDomain` | `string` | 🟢 High (>85%) | Extracted root domain name |
| `address` | `string` | 🟢 High (100%) | Complete street address, city, state, and postal code |
| `latitude` | `string` | 🟢 High (100%) | WGS84 geographic latitude coordinate |
| `longitude` | `string` | 🟢 High (100%) | WGS84 geographic longitude coordinate |
| `googleMapsUrl` | `string` | 🟢 High (100%) | Direct permalink to Google Maps place page |
| `query` | `string` | 🟢 High (100%) | Originating search query term |
| `scrapedAt` | `string` | 🟢 High (100%) | ISO 8601 scrape timestamp |

#### ✉️ Contact & Social Media Intelligence (from Website Enrichment)

| Field | Type | Coverage | Description |
|---|---|---|---|
| `email` | `string` | 🟡 Conditional (~50–70%) | Primary detected email address for outreach |
| `emails` | `string` | 🟡 Conditional (~50–70%) | Array of all verified unique email addresses discovered |
| `facebook` | `string` | 🟡 Conditional (~40–60%) | Extracted Facebook company page handle or URL |
| `instagram` | `string` | 🟡 Conditional (~40–60%) | Extracted Instagram business profile handle |
| `linkedin` | `string` | 🟡 Conditional (~30–50%) | Extracted LinkedIn company page or professional profile |
| `twitter` | `string` | 🟡 Conditional (~20–40%) | Extracted Twitter / X handle |
| `youtube` | `string` | 🟡 Conditional (~15–30%) | Extracted YouTube channel link |

***

### 💡 Example output record

```json
{
  "placeId": "ChIJN1t_tDeuEmsRUsoyG83frY4",
  "name": "Biscayne Dental Center",
  "category": "Dentist",
  "categories": [
    "Dentist",
    "Cosmetic Dentist",
    "Dental Clinic",
    "Emergency Dental Service"
  ],
  "rating": 4.9,
  "reviewCount": 482,
  "phone": "(305) 555-0142",
  "phoneIntl": "+1 305-555-0142",
  "website": "https://www.biscaynedentalcenter.com",
  "websiteDomain": "biscaynedentalcenter.com",
  "address": "14400 Biscayne Blvd, North Miami, FL 33181, United States",
  "latitude": 25.9084,
  "longitude": -80.1542,
  "email": "info@biscaynedentalcenter.com",
  "emails": [
    "info@biscaynedentalcenter.com",
    "appointments@biscaynedentalcenter.com"
  ],
  "facebook": "biscaynedental",
  "instagram": "biscaynedentalmiami",
  "linkedin": "company/biscayne-dental-center",
  "twitter": "biscaynedental",
  "googleMapsUrl": "https://www.google.com/maps/place/?q=place_id:ChIJN1t_tDeuEmsRUsoyG83frY4",
  "query": "dentists in Miami FL",
  "scrapedAt": "2026-11-10T16:42:00.000Z"
}
```

***

### 🎯 Practical input recipes

#### Recipe 1: Local Contractor Outreach Campaign

Extract plumbers across multiple metropolitan areas with email enrichment:

```json
{
  "searchQueries": [
    "plumbers in Dallas TX",
    "plumbing contractors in Fort Worth TX",
    "commercial plumbing in Arlington TX"
  ],
  "includeEmails": true,
  "maxItems": 300
}
```

#### Recipe 2: High-Speed Directory Extraction (Without Enrichment)

Extract high-volume directory listings at maximum speed without visiting websites:

```json
{
  "searchQueries": [
    "coffee shops in Brooklyn NY",
    "bakeries in Manhattan NY",
    "cafes in Queens NY"
  ],
  "includeEmails": false,
  "maxPagesPerQuery": 0,
  "maxItems": 1000
}
```

#### Recipe 3: Niche B2B Legal & Professional Services

Audit law firms with direct partners and practice leads:

```json
{
  "searchQueries": [
    "corporate law firms in Chicago IL",
    "intellectual property attorneys in Chicago IL"
  ],
  "includeEmails": true,
  "maxItems": 150
}
```

#### Recipe 4: International Real Estate Agencies

Map real estate brokerages in major European capitals:

```json
{
  "searchQueries": [
    "real estate agencies in London UK",
    "immobilier in Paris France",
    "agencias inmobiliarias in Madrid Spain"
  ],
  "includeEmails": true,
  "maxItems": 250
}
```

#### Recipe 5: High-Density Hospitality & Restaurants

Harvest restaurant leads across target neighborhoods:

```json
{
  "searchQueries": [
    "italian restaurants in Brooklyn NY",
    "french bistros in Manhattan NY"
  ],
  "includeEmails": true,
  "maxPagesPerQuery": 0,
  "maxItems": 200
}
```

#### Recipe 6: Local Fitness & Wellness Studios

Generate prospects for gym and wellness equipment sales:

```json
{
  "searchQueries": [
    "yoga studios in Los Angeles CA",
    "crossfit gyms in San Diego CA"
  ],
  "includeEmails": true,
  "maxItems": 150
}
```

***

### 💡 Optimization & best practices

- **Query Structuring:** Format queries as `"<industry/trade> in <city, state/country>"`. For large metropolitan regions, break queries down by borough, neighborhood, or postal code to uncover long-tail listings.
- **Speed vs. Depth Trade-Off:** If you only require business phone numbers, addresses, and ratings, set `includeEmails: false`. This boosts scraping throughput to several hundred listings per minute.
- **Managing High-Volume Leads:** When targeting 1,000+ businesses across a state, pass 10–20 specific city queries and keep `maxPagesPerQuery: 0` so the engine auto-exhausts each locality before moving to the next.
- **Filtering by Review Thresholds:** Use post-processing filters in CSV or Python to isolate established businesses (e.g., `rating >= 4.0` and `reviewCount >= 50`) or target struggling businesses for reputation management pitches (`rating < 4.0`).
- **Enrichment Coverage Expectations:** Expect phone numbers and physical addresses on >95% of listings. Email and social coverage typically reaches 50–70% of listings with active domains, as some businesses do not publish public email addresses on their websites.

***

### 🚀 How to use & integrate

1. **Configure Search Scope:** Input your desired search queries into the console.
2. **Toggle Enrichment:** Keep `includeEmails: true` for full contact intelligence, or disable for raw directory records.
3. **Execute Run:** Launch directly via Apify Console or trigger via API:
   ```bash
   curl --request POST \
     --url "https://api.apify.com/v2/acts/haketa~google-maps-contacts-scraper/runs?token=YOUR_API_TOKEN" \
     --header 'Content-Type: application/json' \
     --data '{"searchQueries": ["dentists in Miami FL"], "includeEmails": true, "maxItems": 50}'
   ```
4. **Export & Automate:**
   - **Sales Engagement:** Import CSV directly into Apollo, Lemlist, Instantly, or HubSpot.
   - **Spreadsheets:** Automatically sync new leads to Google Sheets via Apify integration.
   - **Webhooks:** Trigger instant webhook notifications to your backend whenever a batch finishes.

***

### ❓ Frequently asked questions

##### Is scraping Google Maps legal?

Yes. The actor extracts publicly available commercial directory information and public website data displayed openly by businesses for discovery. Ensure your outreach complies with applicable communications regulations (such as CAN-SPAM, GDPR, and CASL).

##### Do I need a Google Cloud API key?

No. You do not need a Google Cloud account, billing setup, or Google Places API key. The actor operates completely independently.

##### How many leads can I extract in a single run?

You can extract hundreds to thousands of leads. By supplying multiple neighborhood or city queries, you can scale to 10,000+ records seamlessly.

##### Why do some businesses lack an email address?

Emails are extracted directly from the business's public website. If a business does not have a website, or uses a contact form exclusively without displaying a plain-text email or `mailto:` link, the email field remains blank while preserving all phone and address data.

##### How does deduplication work?

The scraper tracks Google Place IDs across all search queries in a run. If the same business appears under multiple related searches, it is stored only once in the dataset.

##### Can I target businesses in non-English speaking countries?

Yes. You can write search queries in any language (e.g., `"restaurantes en Madrid"`, `"coiffeur à Paris"`, `"zahnarzt in Berlin"`). Google Maps returns local listings matching the target language and geography.

##### How fast does website enrichment run?

Website crawling executes concurrently across 6 parallel threads. Enriching 50 businesses typically completes in approximately 20–45 seconds.

##### What phone number formats are returned?

The actor extracts both the standard local display format in `phone` (e.g. `(305) 555-0142`) and the international E.164 standardized telephone format in `phoneIntl` (e.g. `+1 305-555-0142`), allowing direct integration with VoIP dialers and SMS automation platforms.

##### How does the scraper avoid false-positive email addresses?

The email parser filters out image asset names (e.g., `.png`, `.jpg`), web font assets, tracking pixels, platform CDN addresses (such as `wixpress.com`, `sentry.io`), and generic placeholder addresses (`example.com`).

##### What happens if a target website is slow or down?

Each website fetch has a strict 15-second timeout and 2 retries. If a website fails to load or times out, the business listing is preserved intact with all directory fields populated, and the actor proceeds immediately to the next record without halting the run.

##### Can I schedule recurring lead generation runs?

Yes. You can use Apify's built-in Scheduler to automatically run fresh searches weekly or monthly, piping newly opened businesses directly into your CRM or Google Sheet.

##### What export formats are supported?

You can download your lead dataset in JSON, CSV, Excel (XLSX), XML, or HTML table format directly from the Apify Console. You can also query the dataset via the Apify REST API in real time.

***

### 🛠️ Step-by-step code integration examples

#### Python Integration with Apify Client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

## Run Google Maps Leads Scraper
run = client.actor("haketa/google-maps-contacts-scraper").call(
    run_input={
        "searchQueries": ["dentists in Miami FL"],
        "includeEmails": True,
        "maxItems": 50,
    }
)

## Fetch results from dataset
dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items
for item in dataset_items:
    print(f"Business: {item.get('name')} | Phone: {item.get('phone')} | Email: {item.get('email')}")
```

#### Node.js / JavaScript Integration

```javascript
import { ApifyClient } from 'apify-client';

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

const run = await client.actor('haketa/google-maps-contacts-scraper').call({
    searchQueries: ['dentists in Miami FL'],
    includeEmails: true,
    maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} enriched business leads.`);
```

***

### 🔗 Related lead generation scrapers

- [Bing Maps Business Leads Scraper](https://apify.com/haketa/bing-maps-contacts-scraper) — Extract business leads with emails from Bing Maps.
- [EPA ECHO Compliance Scraper](https://apify.com/haketa/epa-echo-scraper) — Extract US industrial facilities, compliance status, and penalties.
- [ProPublica Nonprofit Scraper](https://apify.com/haketa/propublica-nonprofit-scraper) — IRS Form 990 nonprofit leads, executive compensation, and grants.
- [Google News Scraper](https://apify.com/haketa/google-news-scraper) — Live news search, headlines, and sentiment tracking.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Deep Pagination Unlocked:** Fully unlocked continuous multi-page pagination for 1,000+ businesses; `maxPagesPerQuery: 0` now executes as unlimited pagination governed by `maxItems`.
- **Fast Prefill Optimization:** Adjusted prefill limits to 50 records for rapid sub-30s sample verification with full email enrichment.
- **Default Fallback Robustness:** Added safe fallback defaults (Miami dentists, Seattle coffee) ensuring runs with empty input payloads execute reliably with ~50 sample leads.
- **Enhanced Contact Parsing:** Upgraded regex patterns to improve email extraction from contact and about subpages while filtering tracking pixels and asset URLs.

#### v1.1 (2026-10)

- **Multi-Query Support:** Added concurrent multi-query processing with unified dataset aggregation.
- **Place ID Deduplication:** Introduced in-memory place ID indexing to eliminate duplicate business records across overlapping queries.

#### v1.0 (2026-09)

- Initial release featuring Google Maps directory parsing and multi-channel email/social enrichment.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/google-maps-contacts-scraper/changelog.md

# Actor input Schema

## `searchQueries` (type: `array`):

Google Maps searches in the form "<what> in <where>" (e.g. "restaurants in Austin TX", "plumbers in London", "dentists in Miami"). Each is searched separately.

## `includeEmails` (type: `boolean`):

For each business with a website, fetch the site and extract email addresses and social profiles (Facebook/Instagram/LinkedIn/Twitter/YouTube). Slower but turns listings into leads.

## `maxPagesPerQuery` (type: `integer`):

Result pages to paginate per query (20 businesses per page). 0 = auto/unlimited governed by maxItems.

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

Maximum businesses across all queries. 0 = no limit.

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

Apify Proxy. Enabled by default.

## Actor input object example

```json
{
  "searchQueries": [
    "dentists in Miami FL",
    "coffee shops in Seattle WA"
  ],
  "includeEmails": true,
  "maxPagesPerQuery": 0,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `placeId` (type: `string`):

Google place ID

## `name` (type: `string`):

Business name

## `category` (type: `string`):

Primary category

## `rating` (type: `string`):

Star rating

## `reviewCount` (type: `string`):

Review count

## `phone` (type: `string`):

Phone number

## `phoneIntl` (type: `string`):

International phone

## `email` (type: `string`):

Primary email (enriched)

## `emails` (type: `string`):

All emails found

## `website` (type: `string`):

Website URL

## `address` (type: `string`):

Full address

## `latitude` (type: `string`):

Latitude

## `longitude` (type: `string`):

Longitude

## `facebook` (type: `string`):

Facebook (enriched)

## `instagram` (type: `string`):

Instagram (enriched)

## `linkedin` (type: `string`):

LinkedIn (enriched)

## `twitter` (type: `string`):

Twitter/X (enriched)

## `googleMapsUrl` (type: `string`):

Google Maps URL

## `query` (type: `string`):

Search query

## `scrapedAt` (type: `string`):

ISO timestamp

# 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 = {
    "searchQueries": [
        "dentists in Miami FL",
        "coffee shops in Seattle WA"
    ],
    "includeEmails": true,
    "maxPagesPerQuery": 0,
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/google-maps-contacts-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 = {
    "searchQueries": [
        "dentists in Miami FL",
        "coffee shops in Seattle WA",
    ],
    "includeEmails": True,
    "maxPagesPerQuery": 0,
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/google-maps-contacts-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 '{
  "searchQueries": [
    "dentists in Miami FL",
    "coffee shops in Seattle WA"
  ],
  "includeEmails": true,
  "maxPagesPerQuery": 0,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/google-maps-contacts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/google-maps-contacts-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/njZV8J2S9Sufe1Z1X/builds/yrZbciVCuwLCCUHUU/openapi.json