# Google Maps Scraper: Places, Phones, Emails, Reviews (`transparent_meteorite/google-maps-places-scraper`) Actor
Scrape Google Maps places by keyword and location: name, address, phone, website, rating, review count, hours, categories, coordinates, place URL. Optional website emails and socials, up to 5 reviews. No login. $1.50 per 1,000 places.
- **URL**: https://apify.com/transparent_meteorite/google-maps-places-scraper.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation, Travel, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.75 / 1,000 place scrapeds
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 Scraper: Places, Phones, Emails, Reviews
[](https://console.apify.com/actors/djgBif3RPBznx5s4K/input)
| Price per 1,000 places | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| **This Actor** | **$1.50** | **$1.50** | **$1.50** | **$0.75** |
| Most-used alternative | $4.00 | $3.00 | $2.00 | $1.50 |
Pay per event, no monthly rental. Prices read from each Actor's public Apify pricing on 2026-10-13; check the Pricing tab for the current figure.
Search Google Maps by keyword and location and get a clean table of businesses: **name, address, phone, website, rating, review count, opening hours, categories, coordinates and the Google Maps link**. Turn on one switch to add **emails and social profiles** from each business website, and another to add **up to 5 reviews** per place.
No Google account, no API key, no browser extension. **$1.50 per 1,000 places.**
### Run in 30 seconds
1. Type a search term, for example `dentist`.
2. Type a location, for example `Denver, CO`.
3. Click **Start**. 20 places arrive in under a minute. Download as CSV, Excel or JSON.
Leave everything empty and the actor runs a small demo search (`coffee shop` in `Detroit, MI`) so you can see the output first.
### What you get for each place
| Field | Example |
|---|---|
| `title` | Decent Detroit |
| `categoryName` / `categories` | Coffee shop |
| `address` | 14834 Kercheval Ave, Detroit, MI 48215 |
| `street`, `city`, `postalCode`, `state`, `countryCode`, `neighborhood` | 14834 Kercheval Ave, Detroit, 48215, Michigan, US, Riverbend |
| `phone` / `phoneUnformatted` | (313) 499-8236 / +13134998236 |
| `website` / `domain` | https://www.instagram.com/decentdetroit / instagram.com |
| `totalScore` | 4.9 |
| `reviewsCount` | 121 |
| `priceLevel` | $1-10 (when Google shows it) |
| `openingHours` | Monday 7 AM-4 PM ... Sunday 8 AM-1 PM |
| `openNowText`, `permanentlyClosed`, `temporarilyClosed` | Closed ยท Opens 7 AM Wed / false / false |
| `location` | { lat: 42.38016, lng: -82.94337 } |
| `placeId`, `cid`, `fid`, `kgmid` | ChIJMxsyZgDVJIgRwb_5TSUPNdw, 15867605515006230465 ... |
| `url`, `cidUrl`, `reviewsUrl` | Google Maps links that open the place |
| `imageUrl` | Main photo |
| `claimedByOwner`, `ownerName` | true, Decent Detroit |
| `additionalInfo` | Accessibility, service options, payments, amenities |
| `timezone` | America/Detroit |
| `searchString`, `searchLocation`, `rank` | coffee shop, Detroit, MI, 1 |
| `placesTags` | Highlights such as LGBTQ+ friendly, Women-owned |
| `imagesCount` | 66 |
| `reviewsDistribution` | { oneStar: 1, twoStar: 1, threeStar: 1, fourStar: 3, fiveStar: 115 } (detail page) |
| `reviewsTags` | "People often mention": \[{ title: pastries, count: 17 }, ...] (detail page) |
**With "Find emails and social profiles" on:** `emails`, `websitePhones`, `socials` (Facebook, Instagram, LinkedIn, X/Twitter, YouTube, TikTok, Pinterest, Yelp), `contactsFound`.
**With "Image URLs per place" > 0:** `imageUrls` (full-size photo links). **With "Order-online links" on:** `orderBy` (the order-online links Google shows for restaurants). Both are free extras; no extra event.
**With reviews on (1-5):** `reviews` with `stars`, `text`, `reviewerName`, `publishedAt`, `publishedAtText`, `reviewerUrl`.
Field names follow the most widely used Google Maps actor on Apify, so existing spreadsheets, Zapier/Make flows and scripts keep working when you switch.
### Pricing
Pay only for what is delivered. No monthly fee from this actor.
| Event | Free / Starter / Scale | Business, Platinum, Diamond | When it is charged |
|---|---|---|---|
| Place scraped | $0.0015 ($1.50 / 1,000) | $0.00075 ($0.75 / 1,000) | Each place delivered after your filters |
| Website contacts found | $0.001 | $0.00037 | Only when the website crawl actually finds an email or social profile |
| Review scraped | $0.0003 | $0.00009 | Each review delivered (optional, 0-5 per place) |
| Actor start | $0.00005 | $0.00005 | Once per run |
Every tier is at or below the most-used Google Maps actor's price for the same event. Places on your skip list, filtered-out places and dropped reviews are never charged.
Examples: 1,000 dentists = **$1.50**. 1,000 dentists with emails where 600 have one = $1.50 + $0.60 = **$2.10**. Set **Max total charge** on the run and the actor stops cleanly at your budget.
### Input options
| Option | What it does |
|---|---|
| Search terms | One or many, like `plumber`, `roofing contractor`, `vegan restaurant` |
| Location / More locations / ZIP codes | Each term runs in each location as "term in location" |
| City / County / State / Postal code | Structured location fields, joined into one area |
| Skip these places | Place IDs, CIDs or Maps URLs you already have: dropped before delivery, never charged |
| Google Maps URLs | Paste search URLs or place URLs (including `?cid=` links) |
| Place IDs | Look up known places directly (refresh a list) |
| Max places per search | 1-120 (Google's own cap per search) |
| Max places in total | Hard stop for the whole run |
| Language / Country | `en`, `de`, `es` ... and `us`, `gb`, `ca` ... |
| Only these categories | Drop places whose category does not contain your words |
| Name must match search | For brand searches: contains or equals |
| Minimum rating / Minimum review count | Quality filters |
| Website: with / without | "Without a website" = web design leads |
| Only places with a phone, Skip closed places | Cleaner call lists |
| Find emails and social profiles | Crawls the place's own website (home + up to 2 contact/about pages) |
| Reviews per place | 0-5 reviews |
| Review order / Only reviews newer than / Only reviews containing | Sort, date and keyword filters on the returned reviews (dropped reviews are not charged) |
| Image URLs per place | Full-size photo links, free |
| Order-online links | Restaurant ordering links, free |
| Only new places (monitor mode) | Returns and charges only places earlier runs did not return |
### Getting more than 120 places
Google Maps itself stops at about 120 results for one search. To cover a whole city, add **More locations** (neighborhoods) or **ZIP codes**: each one is a fresh search of up to 120, and duplicates across searches are removed automatically (you are never charged twice for the same place in a run).
### Monitor new businesses
Turn on **Only new places**, then schedule the actor daily or weekly. Each run remembers the place IDs it has already returned and gives you only new ones, charged only for new ones. Use **Monitor key** to keep separate lists for separate schedules.
### Use it from code, Make, Zapier or an AI agent
```bash
curl "https://api.apify.com/v2/acts/transparent_meteorite~google-maps-places-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"searchStringsArray":["dentist"],"locationQuery":"Denver, CO","maxCrawledPlacesPerSearch":50,"website":"withoutWebsite"}'
```
**MCP (Claude, Cursor, any MCP client):** add the Apify MCP server with this actor enabled:
```json
{ "mcpServers": { "apify": { "url": "https://mcp.apify.com/?actors=transparent_meteorite/google-maps-places-scraper" } } }
```
Then ask: "Find 30 roofing contractors in Tampa without a website and give me their phone numbers."
### How it works and limits (honest list)
- It reads the same public data the Google Maps website shows to any visitor who is not logged in. No login, no cookies from your account, no CAPTCHA solving.
- Up to about **120 places per search** (Google's limit). Split big areas as described above.
- **Reviews: up to 5 per place**, the ones Google shows on the public place page. If you need every review of a place, this is not the right tool.
- Emails come only from the business's own website. Many small businesses publish none; you are charged for contacts only when something is found.
- Google can rate limit any single IP. The actor rotates proxy sessions and switches to residential proxy automatically when that happens; very large runs take longer, they do not fail silently. The run summary (`OUTPUT`) lists per-search counts, filters and any warnings.
- Google's robots.txt asks automated agents to stay away from parts of `/maps/`. This actor makes the same requests the Maps web page makes for a visitor, at a modest rate. You are responsible for how you use the data (for example, follow anti-spam law when you contact businesses).
### Related actors
More tools from the same publisher that fit this workflow:
- [Local Business Leads](https://apify.com/transparent_meteorite/local-business-leads): find local businesses with no website from OpenStreetMap, a cheap complement to Maps data
- [Website Email Extractor](https://apify.com/transparent_meteorite/website-contact-extractor): pull emails, phones and socials from each business website
- [Company Enrichment by Domain](https://apify.com/transparent_meteorite/company-enrichment-by-domain): enrich a domain with socials, emails and tech stack
- [Website Tech Stack Detector](https://apify.com/transparent_meteorite/website-tech-stack-detector): detect the CMS, frameworks and hosting behind any site
- [Shopify Leads & Store Scraper](https://apify.com/transparent_meteorite/shopify-store-leads): Shopify store leads with apps, products and contacts
- [WHOIS & Domain Lookup](https://apify.com/transparent_meteorite/domain-intelligence-lookup): WHOIS/RDAP, DNS, subdomains and SSL for a domain
Use from AI agents: every actor here is callable through the Apify MCP server (mcp.apify.com).
### FAQ
**Do I need a Google API key?** No.
**How fast is it?** About 20 places in 5-15 seconds per search page; contacts and reviews add a few seconds per place (run in parallel).
**Which countries work?** Any country Google Maps covers. Set Language and Country for local names and formats.
**Why are some phones or websites empty?** The business did not list one on Google Maps. Use "Only places with a phone" to skip them.
**Can I get the place's full description and amenities?** Turn on "Open each place page" (no extra charge, slower).
**Is this the official Google Places API?** No. It is an independent tool that reads public Google Maps pages. Not affiliated with Google.
### Who uses this scraper and why
- **Web design and SEO freelancers** search a trade in one city with the Website filter set to "Only places WITHOUT a website". The result is a call list of working businesses that have a phone number and no site, which is the cleanest cold-outreach list a small agency can build.
- **Sales teams selling to local businesses** (payments, insurance, software, equipment) build territory lists by category and ZIP code, keep only places with a rating and a phone, and push the table into a CRM.
- **Market researchers** compare how many competitors of a type exist in each neighborhood, their average `totalScore` and their `reviewsCount`, using the `location` coordinates to plot them.
- **Franchise and retail planners** check the density of a category around a candidate address before signing a lease.
- **Lead-gen and local-SEO agencies** refresh a client's competitor list monthly with monitor mode, so only newly listed businesses are returned.
- **Data teams** use the Google place identifiers (`placeId`, `cid`) as stable keys to join this table with their own records.
### Input fields explained
The input form is grouped into sections. Every field is optional; the actor runs a small demo search when nothing is filled in.
**What and where.** `searchStringsArray` takes one or many search terms. `locationQuery` is added to each term as "term in location". `locations` and `postalCodes` add more areas, and each extra area repeats every search term, so 3 terms across 4 ZIP codes is 12 searches. The structured fields `city`, `county`, `state` and `postalCode` are joined into one area string, which is handy when the values come from a spreadsheet column.
**Limits.** `maxCrawledPlacesPerSearch` accepts 1 to 120 and defaults to 20. `maxCrawledPlaces` is a hard stop for the whole run; 0 means no overall limit. The Max total charge setting on the run is a third, money-based brake.
**URLs and place IDs.** `startUrls` accepts Google Maps search URLs and place URLs, including `?cid=` links. `placeIds` takes `ChIJ...` identifiers to refresh a list you already hold. `skipPlaces` takes place IDs, CIDs or Maps URLs that you do not want delivered or charged again.
**Language and filters.** `language` (default `en`) controls names, categories and hours. `countryCode` (default `us`) biases results. `categoryFilterWords` keeps only places whose category contains one of your words. `searchMatching` has three values: `all`, `only_includes` and `only_exact`. `placeMinimumStars` is a select from 2 to 4.5, and `minReviews` is a plain count. `website` is `allPlaces`, `withWebsite` or `withoutWebsite`. `onlyWithPhone` and `skipClosedPlaces` are booleans that default to off.
**Extras.** `scrapeContacts` crawls the business website for emails, extra phones and social links. `maxReviews` returns 0 to 5 reviews. `scrapePlaceDetailPage` opens each place page for the description and the full attribute list. `maxImages` returns up to 100 photo links when available. `scrapeOrderOnline` adds ordering links for restaurants. `reviewsSort`, `reviewsStartDate` and `reviewsFilterString` shape the returned reviews.
**Monitoring and proxy.** `onlyNew` and `monitorKey` control monitor mode. `proxyConfiguration` defaults to Apify Proxy and escalates by itself when Google rate limits an exit.
### Worked examples
**1. Web design leads: plumbers in Tampa with a phone and no website**
```json
{
"searchStringsArray": ["plumber"],
"locationQuery": "Tampa, FL",
"maxCrawledPlacesPerSearch": 60,
"website": "withoutWebsite",
"onlyWithPhone": true,
"skipClosedPlaces": true
}
```
**2. Whole-city coverage with ZIP codes**
```json
{
"searchStringsArray": ["dentist"],
"postalCodes": ["80202", "80203", "80205", "80206"],
"maxCrawledPlacesPerSearch": 120,
"placeMinimumStars": "four",
"minReviews": 20
}
```
**3. Competitor review sampling**
```json
{
"searchStringsArray": ["vegan restaurant"],
"locationQuery": "Portland, OR",
"maxCrawledPlacesPerSearch": 10,
"maxReviews": 5,
"reviewsSort": "newest",
"reviewsStartDate": "2026-01-01"
}
```
A trimmed output record for a place looks like this. Only fields listed in the table above are used.
```json
{
"title": "Decent Detroit",
"categoryName": "Coffee shop",
"address": "14834 Kercheval Ave, Detroit, MI 48215",
"phone": "(313) 499-8236",
"phoneUnformatted": "+13134998236",
"website": "https://www.instagram.com/decentdetroit",
"domain": "instagram.com",
"totalScore": 4.9,
"reviewsCount": 121,
"location": { "lat": 42.38016, "lng": -82.94337 },
"searchString": "coffee shop",
"rank": 1
}
```
### Tips to keep runs fast and cheap
1. Start with `maxCrawledPlacesPerSearch` at 10 to check that the category and location return what you expect, then raise it.
2. Put quality filters in the input instead of filtering the spreadsheet afterwards. Places removed by filters are not delivered and not charged.
3. Use `skipPlaces` with the place IDs from your previous export so that a refresh only pays for new rows.
4. Turn on `scrapeContacts` only for lists you will actually contact. It adds a website crawl per place and a few seconds of runtime.
5. Prefer ZIP codes over one huge city search when you need more than 120 places. Duplicates across searches are removed within the run.
6. For recurring jobs, use `onlyNew` with a `monitorKey` per schedule instead of re-exporting the whole list.
7. Set Max total charge on every scheduled run so a typo in the input cannot grow into a large bill.
### Call it with the Apify API in Python
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/google-maps-places-scraper").call(run_input={
"searchStringsArray": ["roofing contractor"],
"locationQuery": "Austin, TX",
"maxCrawledPlacesPerSearch": 30,
"website": "withoutWebsite",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item["title"], item.get("phone"))
```
The run summary is stored in the key-value store under the key `OUTPUT` and contains per-search counts, filters applied and warnings. Read it after unattended runs to see why a search returned fewer places than expected.
### More questions
**How do I get leads for one trade across a whole state?** Run the trade as the search term and list the state's largest cities in `locations`. Each city is its own search of up to 120 places.
**Does the scraper return the same field names as other Google Maps scrapers on Apify?** The field names follow the most widely used one, so existing mappings keep working. Fields that Google does not show for a place are simply absent.
**Can I filter by category after the run?** You can, but `categoryFilterWords` removes unrelated places before delivery, so you do not pay for them.
**What does `rank` mean?** It is the position of the place in the search results for that search term and location.
**Why did my search return fewer places than I asked for?** Google returned fewer matches for that area, or filters removed some. The `OUTPUT` summary lists how many were filtered and why.
**Can I scrape a single place by URL?** Yes. Paste a place URL or a `?cid=` link into `startUrls`, or use `placeIds`.
**Can I schedule it?** Yes. Use an Apify schedule with `onlyNew` turned on to receive only newly listed places each time.
**Is the data stored by the actor?** Results go to your own run dataset. The only state kept between runs is the list of place IDs for monitor mode, in a named key-value store in your account.
# Actor input Schema
## `searchStringsArray` (type: `array`):
What to search for, like you would type it into Google Maps: "dentist", "coffee shop", "roofing contractor". Each term is searched in every location below. Leave empty with no URLs to run a small demo search.
## `locationQuery` (type: `string`):
City, county, state, ZIP or address, for example "Austin, TX" or "Manchester, UK". Added to each search as " in ". Leave empty if your search terms already contain a place.
## `locations` (type: `array`):
Extra cities or neighborhoods to cover. Each one runs every search term again (Google returns up to 120 places per search, so split big cities into neighborhoods or ZIP codes to get more).
## `postalCodes` (type: `array`):
ZIP or postal codes to search, one per line. Works like extra locations.
## `city` (type: `string`):
Optional. Structured location, same as the market leader: city, county, state and postal code are joined into one area (for example "Austin, TX"). Leave empty to use the fields above.
## `county` (type: `string`):
Optional. Joined with city/state/postal code into one location.
## `state` (type: `string`):
Optional. For example "TX" or "Ontario".
## `postalCode` (type: `string`):
Optional. One postal code, joined with the fields above. For many ZIP codes use "ZIP / postal codes" instead (each becomes its own search).
## `maxCrawledPlacesPerSearch` (type: `integer`):
How many places to take from each search (term x location). Google Maps shows at most 120 results per search.
## `maxCrawledPlaces` (type: `integer`):
Stop the whole run after this many places. 0 = no overall limit (the per-search limit and your max charge still apply).
## `startUrls` (type: `array`):
Paste Google Maps search URLs (https://www.google.com/maps/search/...) or place URLs (https://www.google.com/maps/place/... or ?cid=...).
## `placeIds` (type: `array`):
Google place IDs (ChIJ...) to look up directly, for example to refresh a list you already have.
## `skipPlaces` (type: `array`):
Place IDs (ChIJ...), CIDs or Google Maps URLs you already have. They are dropped before delivery, so you are not charged for them.
## `language` (type: `string`):
Language code for names, categories and hours, for example en, de, es, fr.
## `countryCode` (type: `string`):
Two-letter country code that biases results, for example us, gb, ca, au, de.
## `categoryFilterWords` (type: `array`):
Keep only places whose category contains one of these words, for example "dentist" drops the dental lab and the pharmacy next door.
## `searchMatching` (type: `string`):
Use this when you search for a brand name and want to drop unrelated nearby places.
## `placeMinimumStars` (type: `string`):
Skip places rated below this. Leave empty for any rating.
## `minReviews` (type: `integer`):
Skip places with fewer reviews than this.
## `website` (type: `string`):
"Without a website" is the classic web-design lead list.
## `onlyWithPhone` (type: `boolean`):
Skip places that list no phone number.
## `skipClosed` (type: `boolean`):
Skip places Google marks as closed (permanently or temporarily). On by default. Closed places carry permanentlyClosed / temporarilyClosed flags when you turn this off.
## `skipClosedPlaces` (type: `boolean`):
Old name of skipClosed, still accepted. skipClosed wins when both are set.
## `scrapeContacts` (type: `boolean`):
Visits each place's own website (home page plus up to 2 contact/about pages) and adds emails, extra phones and Facebook, Instagram, LinkedIn, X, YouTube, TikTok, Pinterest and Yelp links. Charged per place only when at least one email or social profile is found.
## `maxReviews` (type: `integer`):
Adds up to 5 of the most relevant reviews per place (stars, text, reviewer, date). Google shows 5 on the public place page without login; this actor does not go past that. Charged per review delivered.
## `scrapePlaceDetailPage` (type: `boolean`):
Opens each place page to add the star histogram (reviewsDistribution), the place description and the full attribute list (accessibility, payments, service options). On by default; turn off for faster, search-only rows. No extra charge.
## `maxImages` (type: `integer`):
0 = off. Adds imageUrls (full-size photo links Google ships with the place; usually 1-10 from search, more with the detail page). Free; no extra event.
## `scrapeOrderOnline` (type: `boolean`):
Adds orderBy: the "Order online" links Google shows for restaurants and cafes. Free; no extra event.
## `reviewsSort` (type: `string`):
Order of the reviews returned with each place (applied to the reviews Google embeds in the place page).
## `reviewsStartDate` (type: `string`):
Optional. Drops reviews published before this date (YYYY-MM-DD). Dropped reviews are not charged.
## `reviewsFilterString` (type: `string`):
Optional keyword. Keeps only reviews whose text contains it (case-insensitive). Dropped reviews are not charged.
## `onlyNew` (type: `boolean`):
Remembers which places earlier runs already returned (same searches, or the same monitor key) and returns and charges only places that are new. Schedule it daily or weekly to catch newly opened businesses.
## `monitorKey` (type: `string`):
Optional name for the remembered list, so different schedules with the same searches keep separate lists.
## `proxyConfiguration` (type: `object`):
Apify Proxy is on by default. If Google rate limits an exit, the actor rotates sessions and moves to residential proxy automatically.
## Actor input object example
```json
{
"searchStringsArray": [
"coffee shop"
],
"locationQuery": "Detroit, MI",
"maxCrawledPlacesPerSearch": 20,
"maxCrawledPlaces": 0,
"language": "en",
"countryCode": "us",
"searchMatching": "all",
"minReviews": 0,
"website": "allPlaces",
"onlyWithPhone": false,
"skipClosed": true,
"scrapeContacts": false,
"maxReviews": 0,
"scrapePlaceDetailPage": true,
"maxImages": 0,
"scrapeOrderOnline": false,
"reviewsSort": "mostRelevant",
"onlyNew": false,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `overview` (type: `string`):
No description
## `summary` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"searchStringsArray": [
"coffee shop"
],
"locationQuery": "Detroit, MI",
"maxCrawledPlacesPerSearch": 20,
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/google-maps-places-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"searchStringsArray": ["coffee shop"],
"locationQuery": "Detroit, MI",
"maxCrawledPlacesPerSearch": 20,
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/google-maps-places-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 '{
"searchStringsArray": [
"coffee shop"
],
"locationQuery": "Detroit, MI",
"maxCrawledPlacesPerSearch": 20,
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call transparent_meteorite/google-maps-places-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/google-maps-places-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 ` 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/djgBif3RPBznx5s4K/builds/IypgRpl5anoQRMHgP/openapi.json