# Google Maps Scraper — Leads, Emails, Reviews (`scrapeify/google-maps-scraper`) Actor

Scrape Google Maps business listings without an API key. Extract names, phones, emails, websites, ratings, reviews (5K/place), photos (200/place), GPS, opening hours, social profiles. Five input modes: keyword+location, URLs, Place IDs, GeoJSON, coordinate explore.

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

## Pricing

from $25.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.

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

## Google Maps Business Scraper — Extract Leads, Reviews, Contacts & Coordinates at Scale

Scrape **Google Maps** local business listings without a Google Places API key or API quota management. The Scrapeify Google Maps Scraper runs a **browser-based** crawler supporting five distinct input modes — keyword + location, direct URLs, Place IDs, GeoJSON area grids, and map exploration by coordinates — and returns structured business records: names, addresses, ratings, phone numbers, websites, coordinates, **reviews** (up to 5,000 per place), **photos** (up to 200), optional Q&A data, and optional contact enrichment from business websites.

Results export to Dataset rows, `RESULTS_CSV` (Excel-compatible UTF-8), `RESULTS_JSON`, and a run `OUTPUT` summary with validation metadata.

Built for sales teams running territory sweeps, agencies building local SEO reports, researchers mapping market coverage, and AI pipelines that need structured place data with review text.

---

### Features

| Capability | Detail |
|---|---|
| **Five input modes** | Keyword + location; Google Maps URLs; Place IDs (`ChIJ...`); GeoJSON polygon/point grid; coordinate explore mode |
| **Multi-query support** | Primary `query` + `searchTerms` array for batch keyword processing in one run |
| **Review depth** | Up to 5,000 reviews per place with sort (newest, relevant) and text filter |
| **Photo extraction** | Up to 200 photos per listing |
| **Contact enrichment** | Optional crawl of business websites for email addresses, phone numbers, and social profile URLs |
| **Post-filters** | Minimum rating; skip closed places; website present/absent filter; name keyword match |
| **Language selection** | `languageCode` for UI locale (e.g. `en`, `de`, `es`, `ja`) |
| **Explore mode** | Open Maps at lat/lng/zoom and scroll visible listings without a keyword |
| **Legacy aliases** | `searchStringsArray`, `locationQuery`, `mapsUrls`, `scrapeContacts`, `city/state` still normalized |
| **Multiple exports** | Dataset rows; `RESULTS_CSV`; `RESULTS_JSON`; `OUTPUT_VALIDATION`; `REVIEWS_ROWS` (flat review view) |
| **Result cap** | Up to 500 unique businesses per run (enforced by input validation) |

---

### Use Cases

#### Local Business Lead Generation
Territory sweeps for outbound sales. Pull phone numbers, websites, email addresses, and coordinates for every dentist, HVAC contractor, or restaurant within a ZIP code, city boundary, or custom GeoJSON polygon. Export to CSV for CRM import in minutes.

#### Local SEO & Competitive Analysis
Map which businesses rank in Google Maps for your target keywords in target markets. Track rating distributions, review counts, photo presence, and website adoption among competitors. Schedule weekly runs to detect ranking shifts.

#### Multi-Location Brand Monitoring
Track ratings, review volume, and listing health across franchise or chain locations. Detect stores with declining ratings or missing website links before they affect brand perception.

#### Market Coverage Research
Use GeoJSON input to define custom market boundaries (ZIP codes, postal areas, counties). Count businesses by category, analyze geographic density, and identify underserved market segments.

#### Review Sentiment & Intelligence
Pull up to 5,000 reviews per place. Feed `reviews[].text` into sentiment analysis, topic modeling, or LLM classifiers to extract service themes, recurring complaints, and competitive differentiators.

#### Real Estate & Site Selection
Analyze business density, competitor presence, and category mix around candidate sites. Pull POI data for any lat/lng with explore mode to understand the commercial environment.

#### AI-Powered Sales Enrichment
Enrich prospect lists with Maps-derived signals: rating, review count, website URL, email addresses from contact enrichment, and coordinates for territory assignment.

#### RAG & Semantic Search
Store `displayName`, `listSnippet`, and `reviews[].text` as retrieval chunks with `googleMapsUri` as citation metadata. Enable semantic place queries and AI-generated local market summaries.

#### Agency Reporting
Automate Google Maps data collection for client local SEO audits. Export CSV for client-ready reports. Schedule monthly runs to track client ranking improvements.

#### Competitive Intelligence
Monitor competitor review trajectories, Q&A activity, and photo freshness. Identify businesses with surging review counts indicating marketing campaigns or new openings.

---

### Why Choose This Actor

- **No Google API key** — uses the consumer Maps experience; no quota management
- **Five discovery modes** — one actor for keyword searches, URL lists, Place ID lookups, geo-area coverage, and coordinate exploration
- **Depth on demand** — list-only mode for speed; detail + contact enrichment when full signals are needed
- **Production outputs** — Dataset + CSV + JSON cover BI, engineering, and client-reporting workflows
- **Schema validation** — `OUTPUT_VALIDATION` and `outputValidation` in run summary catch data quality issues early
- **Apify-native** — standard storage, logging, scheduling, and REST API integration

---

### Quick Start

1. Open the Scrapeify **Google Maps Scraper** on Apify Console.
2. Choose your input mode:
   - **Keyword**: enter `query` (e.g. `dentist`) and `location` (e.g. `Austin, TX, USA`)
   - **URLs**: paste `startUrls` (full Google Maps search or place links)
   - **Place IDs**: enter `placeIds` list
   - **GeoJSON**: paste a polygon or point + radius in `customGeolocation`
   - **Explore**: enable `exploreMapInsteadOfSearch` and set `mapCenter`
3. Set `maxResults` (1–500). Enable `scrapePlaceDetailPage` for phones, reviews, and full addresses.
4. After the run: export **Dataset** or download **RESULTS_CSV** from Storage → Key-value store.

> **Tip:** Always start with `maxResults: 20` and validate that the filter combination returns the expected business types before scaling to 500.

---

### Input Schema

```json
{
  "query": "dentist",
  "location": "Austin, TX, USA",
  "maxResults": 50,
  "languageCode": "en",
  "scrapePlaceDetailPage": true,
  "maxReviews": 100,
  "reviewsSort": "newest",
  "enrichContactsFromWebsite": true,
  "website": "withWebsite",
  "skipClosedPlaces": true,
  "minRating": 4.0
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `query` | string | — | Primary search phrase (e.g. `coffee shop`) |
| `searchTerms` | array | — | Additional search phrases — each becomes its own Maps search |
| `location` | string | — | City or region appended to keyword searches |
| `startUrls` | array | — | Full Google Maps search or place URLs |
| `placeIds` | array | — | Place IDs (typically start with `ChIJ`) |
| `customGeolocation` | object | — | GeoJSON Point + radiusKm, Polygon, or MultiPolygon |
| `exploreMapInsteadOfSearch` | boolean | `false` | Open Maps at `mapCenter` and scroll visible listings |
| `mapCenter` | object | — | `{ "lat": number, "lng": number, "zoom": 1–21 }` |
| `maxResults` | integer | 100 | Unique businesses to collect (1–500) |
| `languageCode` | string | `en` | Maps UI locale |
| `scrapePlaceDetailPage` | boolean | — | Load place detail pages for phones, reviews, full address |
| `maxReviews` | integer | — | Reviews per place, up to 5,000 |
| `reviewsSort` | string | — | `newest` or `relevant` |
| `maxImages` | integer | — | Photos per place, up to 200 |
| `enrichContactsFromWebsite` | boolean | — | Crawl business websites for emails, phones, social URLs |
| `website` | string | — | Filter: `withWebsite`, `withoutWebsite`, or omit |
| `skipClosedPlaces` | boolean | — | Exclude permanently closed listings |
| `minRating` | number | — | Minimum star rating filter (0–5) |
| `categories` | array | — | Post-filter: keep rows mentioning these keywords in name/snippet |

**Legacy aliases accepted:** `searchStringsArray`, `locationQuery`, `mapsUrls`, `scrapeContacts`, `city`, `state`, `country`.

***

### Output Schema

#### Dataset Row (one row per business)

```json
{
  "position": 1,
  "displayName": "Austin Smile Dental Group",
  "rating": 4.8,
  "userRatingsTotal": 342,
  "formattedAddress": "1234 South Congress Ave, Austin, TX 78704",
  "internationalPhoneNumber": "+1 512-555-0100",
  "websiteUri": "https://austinsmiledental.com",
  "latitude": 30.2672,
  "longitude": -97.7431,
  "googleMapsUri": "https://www.google.com/maps/place/?q=place_id:ChIJXXXXXXXX",
  "listSnippet": "Family and cosmetic dentistry in South Austin.",
  "priceLevel": null,
  "primaryType": "dentist",
  "categories": ["Dentist", "Cosmetic Dentist"],
  "openingHours": {
    "weekdayDescriptions": ["Monday: 8:00 AM – 5:00 PM", "..."]
  },
  "reviews": [
    {
      "reviewId": "abc123def456",
      "stars": 5,
      "text": "Friendly staff and painless cleanings. Best dentist I've had.",
      "publishTime": "2026-04-15T00:00:00Z",
      "reviewerName": "Alex M.",
      "reviewerPhotoUrl": null
    }
  ],
  "photos": ["https://lh3.googleusercontent.com/p/..."],
  "emails": "hello@austinsmiledental.com",
  "socialLinks": {
    "facebook": "https://www.facebook.com/austinsmiledental",
    "instagram": null
  },
  "reservationLinks": []
}
```

| Field | Type | Description |
|---|---|---|
| `position` | integer | Search result position |
| `displayName` | string | Business name |
| `rating` | number | Star rating (1.0–5.0) |
| `userRatingsTotal` | integer | Total review count |
| `formattedAddress` | string | Full formatted address |
| `internationalPhoneNumber` | string | Phone in E.164 format |
| `websiteUri` | string | Business website URL |
| `latitude` / `longitude` | number | Geographic coordinates |
| `googleMapsUri` | string | Stable place URL with Place ID |
| `reviews` | array | Review objects with text, stars, date, reviewer |
| `photos` | array | Image URLs |
| `emails` | string | Email(s) found via website enrichment |
| `socialLinks` | object | Facebook, Instagram, YouTube, TikTok, X links if found |

#### Run Summary (`OUTPUT` key in default KV store)

```json
{
  "ok": true,
  "query": "dentist",
  "searchTerms": ["dentist"],
  "categories": [],
  "maxResults": 50,
  "returnedCount": 48,
  "meta": {
    "listingsScanned": 52,
    "detailPagesLoaded": 48,
    "reviewsCollected": 4800
  },
  "outputValidation": {
    "passed": true,
    "warnings": []
  },
  "scrapedAt": "2026-05-07T04:00:00.000Z",
  "note": "Full rows are in Dataset and RESULTS_CSV."
}
```

| Field | Type | Description |
|---|---|---|
| `ok` | boolean | `true` if places returned |
| `returnedCount` | integer | Actual places after post-filters |
| `meta` | object | Diagnostics: listings scanned, detail pages, reviews collected |
| `outputValidation` | object | Schema/data quality check results |
| `scrapedAt` | string | ISO 8601 timestamp |

**Additional KV keys:** `RESULTS_CSV` (UTF-8 with BOM), `RESULTS_JSON`, `OUTPUT_VALIDATION`, `REVIEWS_ROWS` (flat review export when `includeReviewsDatasetView` enabled).

***

### API Examples

#### cURL

```bash
curl "https://api.apify.com/v2/acts/scrapeify~google-maps-scraper-advance/runs?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "query": "coffee shop",
    "location": "Brooklyn, NY",
    "maxResults": 25,
    "scrapePlaceDetailPage": true,
    "enrichContactsFromWebsite": true
  }'
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("scrapeify/google-maps-scraper").call(
    run_input={
        "query": "coffee shop",
        "location": "Brooklyn, NY",
        "maxResults": 25,
        "scrapePlaceDetailPage": True,
        "maxReviews": 50,
        "enrichContactsFromWebsite": True,
    }
)

for place in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(place["displayName"], place.get("emails"), place.get("rating"))
```

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor("scrapeify/google-maps-scraper").call({
  query: "coffee shop",
  location: "Brooklyn, NY",
  maxResults: 25,
  scrapePlaceDetailPage: true,
  maxReviews: 50,
  enrichContactsFromWebsite: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Collected ${items.length} businesses with ${items.reduce((sum, p) => sum + (p.reviews?.length || 0), 0)} reviews`);
```

***

### Integration Examples

#### ChatGPT / Custom GPT

Return top N businesses as a JSON tool response. Include `googleMapsUri` for human-verifiable links. Let the model answer "best-rated plumber near me" style queries with grounded local data.

#### Claude Tool Use

```python
@tool
def search_local_businesses(query: str, location: str, max_results: int = 20) -> list:
    """Search Google Maps for local businesses with ratings, phones, and website contacts."""
    run = client.actor("scrapeify/google-maps-scraper").call(
        run_input={"query": query, "location": location, "maxResults": max_results,
                   "scrapePlaceDetailPage": True, "enrichContactsFromWebsite": True}
    )
    return client.dataset(run["defaultDatasetId"]).list_items().items
```

#### LangChain

Wrap as a LangChain tool returning a list of business dicts. Use in a retrieval chain for local market analysis, competitive benchmarking, or lead scoring agents.

#### CrewAI

`TerritoryResearchAgent` pulls business leads for a sales territory. `LeadScoringAgent` ranks by rating + review count + website presence. `OutreachAgent` drafts personalized emails using `emails` and `displayName`.

#### AutoGen

Multi-agent workflow: `UserProxyAgent` specifies market; `DataAgent` collects Maps data; `AnalysisAgent` clusters businesses by rating and review sentiment; `ReportAgent` summarizes findings.

#### n8n / Make.com / Zapier

HTTP module → trigger Apify run → iterate Dataset items → upsert into HubSpot, Salesforce, or Airtable by `googleMapsUri` (stable Place ID URL) as dedup key.

#### RAG Systems

Chunk `reviews[].text` with parent `displayName`, `rating`, and `googleMapsUri` as metadata. Index in Pinecone or Weaviate. Support queries like "what do customers complain about at competitor X?"

#### BI & Analytics

Schedule weekly CSV export to S3 via Apify integrations. Load into BigQuery or Redshift for rating trend analysis, geographic density mapping, and market share tracking.

***

### Frequently Asked Questions

**1. Do I need a Google Maps Platform API key?**
No. This actor uses the consumer Maps experience in a browser context — no API key, no quota management.

**2. What is the maximum businesses per run?**
500 unique businesses after post-filters. Set `maxResults` at or below 500.

**3. How many reviews can I collect per business?**
Up to 5,000 per listing when `maxReviews` is set to 5000. Google Maps may cap lower for some listings in practice.

**4. Can I scrape a whole city or custom geographic area?**
Yes — use `customGeolocation` with a GeoJSON Polygon or MultiPolygon. The actor samples grid points inside the shape.

**5. Why are email addresses sometimes empty?**
Contact enrichment depends on business websites having parseable email strings. Many businesses don't publish email addresses on their sites.

**6. Should I use residential proxies?**
Not mandatory, but Apify RESIDENTIAL proxy groups improve results when datacenter IPs see empty listing cards or blocking.

**7. What is `REVIEWS_ROWS` in the KV store?**
A flat, one-row-per-review export enabled by `includeReviewsDatasetView`. Useful for direct SQL ingestion without JSON parsing.

**8. How do I handle closed businesses appearing?**
Enable `skipClosedPlaces`. Some closure statuses only appear after loading the detail page — ensure `scrapePlaceDetailPage: true` is set.

**9. Can I mix keywords and direct URLs in one run?**
Yes — `startUrls` and `query` + `location` are normalized together.

**10. Is this GDPR compliant?**
Reviewer names and review text are personal data. Disable `scrapeReviewsPersonalData` if GDPR obligations require it.

**11. How does the GeoJSON grid mode work?**
The actor generates a grid of search points inside your polygon and runs Maps searches at each point. Coverage density depends on point spacing.

**12. What is explore mode useful for?**
Discovering businesses visible at a specific lat/lng/zoom without a keyword — useful for POI extraction and site selection analysis.

**13. Can I extract opening hours?**
Opening hours are in `openingHours.weekdayDescriptions` when available. Field presence varies by listing type and locale.

**14. How do I deduplicate across multiple runs?**
Key on `googleMapsUri` (contains stable Place ID) or the raw Place ID from the URL.

**15. Does the scraper support restaurants, hotels, and retail?**
Yes — any business category indexed in Google Maps. Use specific category keywords for best results.

**16. What social profiles can contact enrichment find?**
Facebook, Instagram, YouTube, TikTok, and X/Twitter links when present on the business website.

**17. How do I scrape multiple cities in one run?**
Use `searchTerms` array with multiple location-embedded queries (e.g. `["dentist Austin TX", "dentist Houston TX"]`), or run parallel actor instances per city.

**18. Does it handle hotel chains or multi-entity venues?**
Directory-style duplicates may appear. Normalize on Place ID for dedup when processing chain locations.

**19. Is there an API-compatible Places API field mapping?**
No — field coverage follows what the Maps UI exposes, not Google's Places API schema. Expect some field gaps.

**20. What does `outputValidation` contain?**
Schema and data quality check results — `passed` boolean and `warnings` array for issues like missing required fields.

**21. How large can `RESULTS_CSV` get?**
KV item size limits may truncate very large CSVs. The Dataset export is authoritative for full tables.

**22. Can I filter results by category after scraping?**
Yes — use the `categories` post-filter input. Keeps rows whose name or snippet matches any of the provided keywords.

**23. What does `enrichContactsFromWebsite` cost in run time?**
Each business website requires an additional HTTP fetch. Enabling this significantly increases run time for large `maxResults` values. Start with a small subset.

**24. Does the actor respect `robots.txt` for contact enrichment?**
The actor performs lightweight website crawls for contact data. Your use of enriched data must comply with applicable terms of service and privacy regulations.

**25. Is this affiliated with Google?**
No. This actor is not affiliated with, endorsed by, or connected to Google LLC. Comply with Google Maps Terms of Service and applicable laws in your jurisdiction.

***

### Best Practices

- **Start small** — validate filter combinations with `maxResults: 20` before geo-wide jobs
- **Proxies** — route through Apify RESIDENTIAL if datacenter IPs return empty listing cards
- **Detail cost** — enabling detail pages + reviews + contact enrichment significantly increases run time; batch by region
- **Deduplication** — key on `googleMapsUri` or Place ID downstream to avoid duplicates across overlapping geographic queries
- **Scheduling** — stagger heavy geo jobs to avoid peak concurrency; spread across time windows
- **Privacy** — disable `scrapeReviewsPersonalData` for GDPR-sensitive deployments
- **Validation** — check `outputValidation.passed` in `OUTPUT` as part of automated pipeline quality gates

***

### Performance & Scalability

| Factor | Guidance |
|---|---|
| **Throughput** | Browser-based; slower than HTTP scrapers — plan for minutes per 50 businesses with detail + enrichment |
| **Review volume** | Large `maxReviews` on many businesses multiplies run time linearly |
| **Contact enrichment** | One HTTP request per business website — adds latency, adds value |
| **Horizontal scaling** | Multiple parallel actor runs per city or keyword shard |
| **Memory** | `maxResults` cap keeps single-run memory predictable |
| **Large CSV** | Use Dataset export as authoritative source; KV CSV may truncate for 500-business runs |

***

### AI & Automation Workflows

**Lead scoring pipeline:** Pull 200 local businesses → score by rating × review count × website presence → sort top-50 → draft personalized outreach using `displayName`, `emails`, and `listSnippet`.

**Competitive review intelligence:** Pull reviews for top 10 competitors → embed `reviews[].text` → cluster by topic → identify unmet customer needs for product positioning.

**Territory mapping:** Pull businesses in GeoJSON polygons for 5 sales territories → assign `latitude`/`longitude` to reps → update CRM territory assignments automatically.

**Market entry analysis:** Pull all businesses in target category within new market boundary → analyze rating distribution, review density, and website adoption → grade market attractiveness.

***

### Error Handling

| Scenario | Behavior |
|---|---|
| Invalid input | Error push + `OUTPUT.ok: false` with descriptive message |
| No results after crawl | Structured `no_places` message; `OUTPUT.returnedCount = 0` |
| Partial enrichment failure | Empty contact fields on affected rows — run continues |
| KV size exceeded | `RESULTS_CSV` may truncate; use Dataset export |
| Proxy blocking | Empty listing cards in crawl; switch to RESIDENTIAL proxy groups |

***

### Trust & Reliability

Scrapeify builds this actor for operations teams that need **repeatable, structured Maps-derived tables**. The architecture includes:

- Explicit result caps and validation hooks
- Multiple export paths for BI and engineering handoff
- Legacy input key normalization for backwards-compatible migrations
- `OUTPUT_VALIDATION` for automated pipeline quality checks

***

### Related Scrapeify Actors

Explore the full Scrapeify suite — chain these actors together for end-to-end automation pipelines:

| Actor | What it does |
|---|---|
| [Amazon Scraper](https://apify.com/scrapeify/amazon-scraper) | ASINs, prices, sponsored flags across 23 marketplaces |
| [Instagram Ad Library Scraper](https://apify.com/scrapeify/instagram-ad-library-scraper) | Instagram-only ads from Meta Ad Library |
| [Meta Ad Library Scraper](https://apify.com/scrapeify/meta-ad-library-scraper) | Facebook & Instagram ads with sort options |
| [WhatsApp Ad Scraper](https://apify.com/scrapeify/whatsapp-ad-scraper) | Click-to-WhatsApp ad creatives |
| [YouTube Video Downloader](https://apify.com/scrapeify/youtube-video-downloader) | Videos & audio to Apify Key-Value Store |
| [Meta Brand & Page ID Finder](https://apify.com/scrapeify/facebook-page-id-finder) | Resolve brand names to numeric Page IDs |
| [Google News Scraper](https://apify.com/scrapeify/google-news-scraper) | Headlines, sources, article URLs (up to 2K) |

***

*Google Maps is a trademark of Google LLC. This actor is not affiliated with or endorsed by Google.*

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "SoftwareApplication",
      "name": "Scrapeify Google Maps Scraper",
      "applicationCategory": "DeveloperApplication",
      "applicationSubCategory": "Local Business Data API",
      "operatingSystem": "Cloud (Apify Platform)",
      "description": "Scrape Google Maps business listings without a Places API key. Extract names, phones, emails, websites, ratings, reviews (up to 5,000 per place), photos (up to 200), GPS coordinates, and social profiles. Five input modes: keyword + location, URLs, Place IDs, GeoJSON, or coordinate explore.",
      "url": "https://apify.com/scrapeify/google-maps-scraper",
      "featureList": [
        "Five input modes including GeoJSON polygon coverage",
        "Up to 500 businesses per run",
        "Up to 5,000 reviews per place",
        "Up to 200 photos per place",
        "Optional website contact enrichment for emails and social profiles",
        "Multi-language UI support"
      ],
      "offers": {
        "@type": "Offer",
        "category": "SaaS"
      },
      "publisher": {
        "@type": "Organization",
        "name": "Scrapeify"
      }
    },
    {
      "@type": "FAQPage",
      "mainEntity": [
        {
          "@type": "Question",
          "name": "Do I need a Google Maps Platform API key?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "No. This actor uses the consumer Maps experience in a browser context — no API key, no quota management."
          }
        },
        {
          "@type": "Question",
          "name": "What is the maximum number of businesses per run?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "500 unique businesses after post-filters. Set maxResults at or below 500."
          }
        },
        {
          "@type": "Question",
          "name": "How many reviews can I collect per business?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "Up to 5,000 per listing when maxReviews is set to 5000. Google Maps may cap lower for some listings in practice."
          }
        },
        {
          "@type": "Question",
          "name": "Can I scrape a whole city or custom geographic area?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "Yes — use customGeolocation with a GeoJSON Polygon or MultiPolygon. The actor samples grid points inside the shape."
          }
        },
        {
          "@type": "Question",
          "name": "Why are email addresses sometimes empty in the output?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "Contact enrichment depends on business websites having parseable email strings. Many businesses don't publish email addresses publicly."
          }
        },
        {
          "@type": "Question",
          "name": "Is this Google Maps scraper GDPR compliant?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "Reviewer names and review text are personal data. Disable scrapeReviewsPersonalData if GDPR obligations require it. Apply your data retention policies."
          }
        }
      ]
    }
  ]
}
</script>

# Actor input Schema

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

What to find on Maps (e.g. coffee shop). For several phrases use "Additional search queries".

## `searchTerms` (type: `array`):

Extra phrases — each becomes its own Maps search (same location applies).

## `location` (type: `string`):

City or region appended to keyword searches (e.g. Austin, TX, USA). Compose one string here instead of splitting into city/state fields.

## `startUrls` (type: `array`):

Full Maps search or place links.

## `placeIds` (type: `array`):

Place IDs from Google (often start with ChIJ…).

## `customGeolocation` (type: `object`):

Point (+ optional radiusKm), Polygon, or MultiPolygon. Searches grid points inside the shape.

## `exploreMapInsteadOfSearch` (type: `boolean`):

Open the map at Map center below and scroll visible listings.

## `mapCenter` (type: `object`):

{ "lat": number, "lng": number, "zoom": optional 1–21 }.

## `maxResults` (type: `integer`):

Stop after this many unique businesses (1–500).

## `languageCode` (type: `string`):

UI locale, e.g. en, de, es.

## `categories` (type: `array`):

After scraping, keep rows whose name/snippet mentions one of these.

## `minRating` (type: `number`):

Drop rows below this rating when stars are visible in the list.

## `searchMatching` (type: `string`):

How place names match your keywords. “Exact phrase” mode is omitted here — Maps titles rarely equal a typed query verbatim (Unicode, apostrophes, brands); use substring match or plain API-only `only_exact` if you know the precise title.

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

Usually needs opening place details (automatic when filtering by website).

## `skipClosedPlaces` (type: `boolean`):

Remove permanently/temporarily closed listings seen in UI.

## `scrapePlaceDetailPage` (type: `boolean`):

Slower — phone, website, address. Turns on automatically for reviews/images/extras.

## `maxReviews` (type: `integer`):

0 = skip (up to 5000 subject to Maps UI).

## `reviewsSort` (type: `string`):

Best-effort from the Reviews menu.

## `reviewsFilterString` (type: `string`):

Keep reviews whose text includes this phrase.

## `scrapeReviewsPersonalData` (type: `boolean`):

If off, reviewerName is omitted.

## `maxImages` (type: `integer`):

0 = skip (cap 200).

## `scrapeImageAuthors` (type: `boolean`):

When scraping photos, include author or alt text metadata when Maps exposes it.

## `includeWebResults` (type: `boolean`):

Extract links from the Web results section on the place page when present.

## `scrapeDirectories` (type: `boolean`):

Extract extra Maps-related place links (e.g. directory-style listings inside a venue).

## `maxQuestions` (type: `integer`):

If this key is present, Q\&A runs. 0 = light heuristic pass.

## `scrapeTableReservationProvider` (type: `boolean`):

Best-effort scrape of reservation provider name or booking URL from place page text.

## `enrichContactsFromWebsite` (type: `boolean`):

After a site URL is found, fetch emails/phones/social links.

## `enrichSocialFacebook` (type: `boolean`):

If a Facebook URL was discovered, load public meta (title/description) for a short preview.

## `enrichSocialInstagram` (type: `boolean`):

If an Instagram URL was discovered, load public meta for a short preview.

## `enrichSocialYoutube` (type: `boolean`):

If a YouTube URL was discovered, load public meta for a short preview.

## `enrichSocialTiktok` (type: `boolean`):

If a TikTok URL was discovered, load public meta for a short preview.

## `enrichSocialTwitter` (type: `boolean`):

If an X/Twitter URL was discovered, load public meta for a short preview.

## `includeReviewsDatasetView` (type: `boolean`):

Also writes REVIEWS\_ROWS JSON to key-value store.

## Actor input object example

```json
{
  "query": "coffee shop",
  "location": "Austin, TX, USA",
  "startUrls": [
    "https://www.google.com/maps/search/restaurants/@40.7,-74.0,12z"
  ],
  "exploreMapInsteadOfSearch": false,
  "mapCenter": {
    "lat": 40.7128,
    "lng": -74.006,
    "zoom": 14
  },
  "maxResults": 100,
  "languageCode": "en",
  "searchMatching": "all",
  "website": "allPlaces",
  "skipClosedPlaces": false,
  "scrapePlaceDetailPage": false,
  "reviewsSort": "newest",
  "scrapeReviewsPersonalData": true,
  "scrapeImageAuthors": false,
  "includeWebResults": false,
  "scrapeDirectories": false,
  "scrapeTableReservationProvider": false,
  "enrichContactsFromWebsite": false,
  "enrichSocialFacebook": false,
  "enrichSocialInstagram": false,
  "enrichSocialYoutube": false,
  "enrichSocialTiktok": false,
  "enrichSocialTwitter": false,
  "includeReviewsDatasetView": false
}
```

# 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 = {
    "query": "coffee shop",
    "location": "Austin, TX, USA",
    "startUrls": [
        "https://www.google.com/maps/search/restaurants/@40.7,-74.0,12z"
    ],
    "mapCenter": {
        "lat": 40.7128,
        "lng": -74.006,
        "zoom": 14
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeify/google-maps-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 = {
    "query": "coffee shop",
    "location": "Austin, TX, USA",
    "startUrls": ["https://www.google.com/maps/search/restaurants/@40.7,-74.0,12z"],
    "mapCenter": {
        "lat": 40.7128,
        "lng": -74.006,
        "zoom": 14,
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeify/google-maps-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 '{
  "query": "coffee shop",
  "location": "Austin, TX, USA",
  "startUrls": [
    "https://www.google.com/maps/search/restaurants/@40.7,-74.0,12z"
  ],
  "mapCenter": {
    "lat": 40.7128,
    "lng": -74.006,
    "zoom": 14
  }
}' |
apify call scrapeify/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper — Leads, Emails, Reviews",
        "description": "Scrape Google Maps business listings without an API key. Extract names, phones, emails, websites, ratings, reviews (5K/place), photos (200/place), GPS, opening hours, social profiles. Five input modes: keyword+location, URLs, Place IDs, GeoJSON, coordinate explore.",
        "version": "0.8",
        "x-build-id": "w7L0wWFjbbT8sar8p"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeify~google-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeify-google-maps-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/scrapeify~google-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeify-google-maps-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/scrapeify~google-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeify-google-maps-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",
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "What to find on Maps (e.g. coffee shop). For several phrases use \"Additional search queries\"."
                    },
                    "searchTerms": {
                        "title": "Additional search queries",
                        "type": "array",
                        "description": "Extra phrases — each becomes its own Maps search (same location applies).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region appended to keyword searches (e.g. Austin, TX, USA). Compose one string here instead of splitting into city/state fields."
                    },
                    "startUrls": {
                        "title": "Google Maps URLs",
                        "type": "array",
                        "description": "Full Maps search or place links.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeIds": {
                        "title": "Place IDs",
                        "type": "array",
                        "description": "Place IDs from Google (often start with ChIJ…).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "customGeolocation": {
                        "title": "GeoJSON area or point",
                        "type": "object",
                        "description": "Point (+ optional radiusKm), Polygon, or MultiPolygon. Searches grid points inside the shape."
                    },
                    "exploreMapInsteadOfSearch": {
                        "title": "Explore map here (no keyword)",
                        "type": "boolean",
                        "description": "Open the map at Map center below and scroll visible listings.",
                        "default": false
                    },
                    "mapCenter": {
                        "title": "Map center",
                        "type": "object",
                        "description": "{ \"lat\": number, \"lng\": number, \"zoom\": optional 1–21 }."
                    },
                    "maxResults": {
                        "title": "Max places",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Stop after this many unique businesses (1–500).",
                        "default": 100
                    },
                    "languageCode": {
                        "title": "Maps language",
                        "type": "string",
                        "description": "UI locale, e.g. en, de, es.",
                        "default": "en"
                    },
                    "categories": {
                        "title": "Post-filter keywords",
                        "type": "array",
                        "description": "After scraping, keep rows whose name/snippet mentions one of these.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minRating": {
                        "title": "Minimum stars (0–5)",
                        "type": "number",
                        "description": "Drop rows below this rating when stars are visible in the list."
                    },
                    "searchMatching": {
                        "title": "Name vs queries",
                        "enum": [
                            "all",
                            "only_includes"
                        ],
                        "type": "string",
                        "description": "How place names match your keywords. “Exact phrase” mode is omitted here — Maps titles rarely equal a typed query verbatim (Unicode, apostrophes, brands); use substring match or plain API-only `only_exact` if you know the precise title.",
                        "default": "all"
                    },
                    "website": {
                        "title": "Website filter",
                        "enum": [
                            "allPlaces",
                            "withWebsite",
                            "withoutWebsite"
                        ],
                        "type": "string",
                        "description": "Usually needs opening place details (automatic when filtering by website).",
                        "default": "allPlaces"
                    },
                    "skipClosedPlaces": {
                        "title": "Skip closed",
                        "type": "boolean",
                        "description": "Remove permanently/temporarily closed listings seen in UI.",
                        "default": false
                    },
                    "scrapePlaceDetailPage": {
                        "title": "Open each place page",
                        "type": "boolean",
                        "description": "Slower — phone, website, address. Turns on automatically for reviews/images/extras.",
                        "default": false
                    },
                    "maxReviews": {
                        "title": "Max reviews per place",
                        "minimum": 0,
                        "type": "integer",
                        "description": "0 = skip (up to 5000 subject to Maps UI)."
                    },
                    "reviewsSort": {
                        "title": "Review sort",
                        "enum": [
                            "newest",
                            "mostRelevant",
                            "highestRanking",
                            "lowestRanking"
                        ],
                        "type": "string",
                        "description": "Best-effort from the Reviews menu.",
                        "default": "newest"
                    },
                    "reviewsFilterString": {
                        "title": "Review text contains",
                        "type": "string",
                        "description": "Keep reviews whose text includes this phrase."
                    },
                    "scrapeReviewsPersonalData": {
                        "title": "Reviewer names",
                        "type": "boolean",
                        "description": "If off, reviewerName is omitted.",
                        "default": true
                    },
                    "maxImages": {
                        "title": "Max photos per place",
                        "minimum": 0,
                        "type": "integer",
                        "description": "0 = skip (cap 200)."
                    },
                    "scrapeImageAuthors": {
                        "title": "Photo author / alt",
                        "type": "boolean",
                        "description": "When scraping photos, include author or alt text metadata when Maps exposes it.",
                        "default": false
                    },
                    "includeWebResults": {
                        "title": "Web results block",
                        "type": "boolean",
                        "description": "Extract links from the Web results section on the place page when present.",
                        "default": false
                    },
                    "scrapeDirectories": {
                        "title": "Related / directory links",
                        "type": "boolean",
                        "description": "Extract extra Maps-related place links (e.g. directory-style listings inside a venue).",
                        "default": false
                    },
                    "maxQuestions": {
                        "title": "Q&A pairs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "If this key is present, Q&A runs. 0 = light heuristic pass."
                    },
                    "scrapeTableReservationProvider": {
                        "title": "Reservation hints",
                        "type": "boolean",
                        "description": "Best-effort scrape of reservation provider name or booking URL from place page text.",
                        "default": false
                    },
                    "enrichContactsFromWebsite": {
                        "title": "Crawl website for contacts",
                        "type": "boolean",
                        "description": "After a site URL is found, fetch emails/phones/social links.",
                        "default": false
                    },
                    "enrichSocialFacebook": {
                        "title": "Facebook preview",
                        "type": "boolean",
                        "description": "If a Facebook URL was discovered, load public meta (title/description) for a short preview.",
                        "default": false
                    },
                    "enrichSocialInstagram": {
                        "title": "Instagram preview",
                        "type": "boolean",
                        "description": "If an Instagram URL was discovered, load public meta for a short preview.",
                        "default": false
                    },
                    "enrichSocialYoutube": {
                        "title": "YouTube preview",
                        "type": "boolean",
                        "description": "If a YouTube URL was discovered, load public meta for a short preview.",
                        "default": false
                    },
                    "enrichSocialTiktok": {
                        "title": "TikTok preview",
                        "type": "boolean",
                        "description": "If a TikTok URL was discovered, load public meta for a short preview.",
                        "default": false
                    },
                    "enrichSocialTwitter": {
                        "title": "X / Twitter preview",
                        "type": "boolean",
                        "description": "If an X/Twitter URL was discovered, load public meta for a short preview.",
                        "default": false
                    },
                    "includeReviewsDatasetView": {
                        "title": "Flat reviews file (KV)",
                        "type": "boolean",
                        "description": "Also writes REVIEWS_ROWS JSON to key-value store.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
