# Apple Maps Scraper – Business Leads (`aerodynamic_tripod/apple-maps-scraper`) Actor

Scrape Apple Maps businesses at scale for lead generation and local SEO. Get names, phones, websites, addresses, coordinates, listing completeness scores, and opportunities such as missing websites or phone numbers.

- **URL**: https://apify.com/aerodynamic\_tripod/apple-maps-scraper.md
- **Developed by:** [SearchShark Tools](https://apify.com/aerodynamic_tripod) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🍎 Apple Maps Scraper - Business Leads & Local SEO

**Apple Maps Scraper** lets you extract **structured local business data from Apple Maps** using business keywords and a location.

Generate **local business leads**, research markets, discover competitors, identify incomplete business listings, and collect public contact information **without manually searching Apple Maps**.

- 🎯 **Generate business leads:** collect business names, phone numbers, websites, addresses, and coordinates
- 🌐 **Find businesses without official websites:** distinguish official websites from social-media and directory URLs
- 📊 **Analyze local markets:** discover businesses operating around a city, state, region, or postal area
- 🧩 **Measure listing completeness:** get an explainable completeness score for every business
- 💡 **Spot opportunities:** automatically flag missing websites, missing phone numbers, and businesses without an official website
- 🧹 **Get cleaner data:** Apple Place ID-based deduplication prevents repeated grid results from polluting your Dataset
- 📍 **Expand geographic coverage:** automatically search multiple nearby Apple Maps search points when more results are requested
- ⚡ **Automate workflows:** export structured results to Apify Dataset, API, integrations, CRMs, or downstream applications

***

### 📦 What data does Apple Maps Scraper extract?

| | |
| --- | --- |
| 🏢 **Business name** | 🆔 **Apple Place ID** |
| 🔢 **Apple MUID** | 🏷 **Category** |
| 📍 **Full address** | 🛣 **Street address** |
| 🏙 **City** | 🗺 **State / region** |
| 📮 **Postal code** | 🌎 **Country** |
| 📌 **Latitude & longitude** | ☎️ **Phone number** |
| 🌐 **Website / public URL** | 🧭 **Website type** |
| ✅ **Has website** | 🏠 **Has official website** |
| ☎️ **Has phone** | ⚠️ **Missing fields** |
| 📊 **Listing completeness score** | 💡 **Opportunity tags** |
| 🍎 **Apple Maps URL** | 🔍 **Source query** |
| 🌍 **Source location** | 🔗 **Matched queries** |
| 🕒 **Scrape timestamp** | |

> **Missing data is returned as `null`, `false`, or an empty array where appropriate.**
>
> The Actor does **not invent business information that Apple Maps does not expose**.

***

### 🚀 Features

Apple Maps Scraper is designed for **lead generation**, **local SEO research**, and **local-business intelligence**.

- **Multiple search queries:** run up to 20 keywords or business categories in one Actor run
- **One location per run:** apply the same location to all queries
- **Up to 500 unique businesses per run**
- **Automatic geographic grid search:** expand around the selected location when more results are requested
- **Apple ID-based deduplication:** repeated businesses discovered from multiple search points are merged
- **Cross-query provenance:** preserve queries that matched the same business in `matchedQueries`
- **Branch-safe identity:** businesses with different Apple Place IDs remain separate
- **Official website detection:** distinguish likely official domains from social profiles and directory pages
- **Opportunity detection:** identify businesses with missing contact information or no official website
- **Explainable completeness score:** score listings using important lead-generation fields
- **Structured business data:** predictable normalized output
- **API-friendly results:** every result follows a consistent Dataset schema
- **HTTP-first architecture:** normal searches do not require browser automation
- **Apple Maps links:** preserve the original Apple Maps place URL for verification and follow-up

***

## ⬇️ Input

You can configure Apple Maps Scraper directly from the **Apify Console** or send input programmatically through the **Apify API**.

### 🔎 Search queries

Add one or more business keywords, categories, or search terms.

Example:

```text
plumber
electrician
HVAC contractor
roofing contractor
```

You can provide:

```text
Minimum: 1 search query
Maximum: 20 search queries
```

Search queries are processed in order.

Because `maxResults` is a **global limit for the entire Actor run**, the Actor stops once that number of unique businesses has been collected.

For stronger coverage, use business categories that are meaningfully different from each other.

***

### 📍 Location

Enter the location that should be used as the center of the Apple Maps search.

Example:

```text
Los Angeles, California
```

Other examples:

```text
Phoenix, Arizona
Miami, Florida
Austin, Texas
London, United Kingdom
Sydney, Australia
San Francisco, CA
```

The Actor resolves the location to geographic coordinates and searches Apple Maps around that area.

The current version supports **one location per Actor run**.

***

### 🔢 Maximum results

Set the maximum total number of unique businesses to collect.

```text
Minimum: 1
Default: 50
Maximum: 500
```

Example:

```text
Search queries:
plumber
electrician
HVAC contractor

Maximum results:
100
```

The Actor will collect up to:

```text
100 unique businesses total
```

across the run.

> `maxResults` is a **maximum, not a guarantee**.

Apple Maps may expose fewer unique businesses for a particular query and area.

The Actor stops naturally when available search coverage is exhausted instead of generating fake or duplicate records.

***

### 🌐 Language

Choose the Apple Maps locale used for the search.

Default:

```text
en-US
```

Examples:

```text
en-US
en-GB
fr-FR
de-DE
```

***

### 🌎 Country code

Limit the Apple Maps search context using a two-letter country code.

Default:

```text
US
```

Examples:

```text
US
GB
CA
AU
DE
FR
```

***

### 🧪 Example input

```json
{
  "searchQueries": [
    "plumber",
    "electrician"
  ],
  "location": "Los Angeles, California",
  "maxResults": 100,
  "language": "en-US",
  "countryCode": "US"
}
```

***

## ⬆️ Output

Results are stored in the Actor's default **Apify Dataset**.

You can access results from:

```text
Output
Storage
Apify API
Integrations
Dataset exports
```

Each Dataset row represents **one unique Apple Maps business**.

If the same Apple Maps business is discovered through multiple search queries, those queries can be preserved in:

```text
matchedQueries
```

instead of creating duplicate rows.

***

### 📊 Example result

```json
{
  "name": "SPRO CoffeeLab",
  "category": "Cafe",
  "appleMapsUrl": "https://maps.apple.com/place?q=SPRO%20CoffeeLab&auid=15583125537627173874",
  "placeId": "ID842621D1095F3F2",
  "muid": "15583125537627173874",
  "address": "525 Golden Gate Ave, San Francisco, CA 94102, United States",
  "streetAddress": "525 Golden Gate Ave",
  "city": "San Francisco",
  "region": "CA",
  "postalCode": "94102",
  "country": "United States",
  "latitude": 37.7809295,
  "longitude": -122.4191742,
  "phone": "+14158440650",
  "website": "https://www.sprocoffeelab.com",
  "websiteType": "official",
  "sourceQuery": "coffee shops",
  "sourceLocation": "San Francisco, CA",
  "hasWebsite": true,
  "hasOfficialWebsite": true,
  "hasPhone": true,
  "missingFields": [],
  "listingCompletenessScore": 100,
  "opportunityTags": [],
  "matchedQueries": [
    "coffee shops"
  ],
  "scrapedAt": "2026-09-07T06:25:10.383Z"
}
```

***

## 🌐 Website intelligence

Apple Maps may expose a business URL, but that URL is not always the business's own official website.

For lead generation, this distinction matters.

Apple Maps Scraper classifies returned URLs into:

```text
official
social
directory
none
```

### `official`

A URL that does not match a recognized social-network or business-directory domain.

Example:

```text
https://exampleplumbing.com
```

Result:

```json
{
  "websiteType": "official",
  "hasOfficialWebsite": true
}
```

***

### `social`

A URL pointing to a recognized social platform such as:

```text
Instagram
Facebook
TikTok
X / Twitter
LinkedIn
YouTube
```

Example:

```text
https://www.instagram.com/examplebusiness/
```

Result:

```json
{
  "websiteType": "social",
  "hasWebsite": true,
  "hasOfficialWebsite": false,
  "opportunityTags": [
    "NO_OFFICIAL_WEBSITE"
  ]
}
```

***

### `directory`

A URL pointing to a recognized business-directory or listing platform such as:

```text
Yelp
Tripadvisor
Foursquare
Yellow Pages
MapQuest
OpenTable
```

Example:

```text
https://www.yelp.com/biz/example
```

Result:

```json
{
  "websiteType": "directory",
  "hasWebsite": true,
  "hasOfficialWebsite": false,
  "opportunityTags": [
    "NO_OFFICIAL_WEBSITE"
  ]
}
```

***

### `none`

Apple Maps did not expose a usable business URL.

Example:

```json
{
  "website": null,
  "websiteType": "none",
  "hasWebsite": false,
  "hasOfficialWebsite": false,
  "opportunityTags": [
    "MISSING_WEBSITE"
  ]
}
```

> **Website classification is a domain-based heuristic.**
>
> `official` means the URL was not recognized as a known social or directory domain. It is not a guarantee that the business owns the website.

***

## 📊 Listing completeness score

Every result receives:

```text
listingCompletenessScore
```

The current score uses five important business-listing signals:

```text
Business name
Category
Address
Phone number
Official website
```

Each available signal contributes:

```text
20 points
```

Maximum:

```text
100
```

Example:

```text
Name             ✓
Category         ✓
Address          ✓
Phone            ✓
Official website ✗

Score: 80
```

This makes it easier to sort businesses by listing completeness and identify potential outreach opportunities.

> The score is a simple, explainable rule-based metric.
>
> It is not an AI-generated score and does not claim to measure overall business quality.

***

## 💡 Opportunity tags

The Actor automatically identifies useful lead-generation signals.

Current tags include:

```text
MISSING_PHONE
MISSING_WEBSITE
NO_OFFICIAL_WEBSITE
```

### `MISSING_PHONE`

Apple Maps did not expose a phone number.

### `MISSING_WEBSITE`

Apple Maps did not expose a usable website or public URL.

### `NO_OFFICIAL_WEBSITE`

Apple Maps exposed only a recognized social-media or directory URL rather than a likely official business website.

Example:

```json
{
  "name": "Example Cafe",
  "website": "https://www.instagram.com/example/",
  "websiteType": "social",
  "hasOfficialWebsite": false,
  "listingCompletenessScore": 80,
  "opportunityTags": [
    "NO_OFFICIAL_WEBSITE"
  ]
}
```

These fields are especially useful for:

```text
Web-design agencies
SEO agencies
Lead-generation companies
Local marketing teams
Sales prospecting
Business-directory research
```

***

## 🧹 Branch-safe deduplication

Apple Maps searches from nearby geographic points often return overlapping businesses.

The Actor removes repeated appearances using the strongest available identity signal:

```text
1. Apple Place ID
2. Apple MUID
3. Apple Maps URL
4. Business name + coordinates
```

### 🏪 Different branches remain separate

Different physical branches may share:

```text
Business name
Website
Phone number
Category
```

but still represent different Apple Maps places.

If Apple provides different Place IDs, the Actor keeps them as separate businesses.

Example:

```text
CoffeeShop — Address A — Apple ID A
CoffeeShop — Address B — Apple ID B
```

remain two separate Dataset rows.

***

## 🔍 Multiple search queries

You can provide several business categories in the same run.

Example:

```text
plumber
electrician
HVAC contractor
roofing contractor
```

If the same Apple Maps business appears for multiple processed queries, the Actor merges the duplicate business and keeps query provenance.

Example:

```json
{
  "name": "ABC Home Services",
  "sourceQuery": "plumber",
  "matchedQueries": [
    "plumber",
    "electrician"
  ]
}
```

`sourceQuery` is the query that first produced the saved business.

`matchedQueries` contains the search queries under which that business was observed before the run reached its result limit.

> Because `maxResults` applies to the entire run, later queries may not be processed if earlier searches already fill the requested maximum.

***

## 📍 Geographic grid search

A single Apple Maps search response may expose only a limited number of nearby results.

Apple Maps Scraper automatically expands the search across multiple nearby geographic search points when additional results are requested.

For example:

```text
Search center
↓
Nearby search cells
↓
Apple Maps results from each cell
↓
Deduplication
↓
Unique businesses
```

The center point is searched first.

For larger `maxResults` values, additional nearby search cells are generated automatically.

The Actor then:

```text
Searches each geographic point
Collects Apple Maps businesses
Deduplicates repeated places
Preserves unique branches
Stops when maxResults is reached
```

This allows the Actor to collect significantly more businesses than a single Apple Maps search response may return.

> Grid search improves coverage, but it does not guarantee that every business inside a geographic area will be discovered.

***

## ⚡ Performance

The scraper uses an **HTTP-first architecture**.

It communicates with Apple Maps search services directly instead of launching a full browser for normal searches.

This provides:

```text
Fast startup
Lower browser overhead
Lower memory requirements
Efficient grid searching
Structured API-friendly responses
```

The Actor stops processing when the requested number of unique businesses is reached.

Actual runtime depends on:

```text
Maximum results
Number of search queries
Available businesses
Geographic coverage required
Network conditions
```

***

## 🛡 Reliability

Apple Maps Scraper prioritizes clean, predictable output.

The Actor:

```text
Validates required search input
Uses Apple Place IDs for strong deduplication
Does not fabricate unavailable fields
Stops at the configured maximum
Returns null or false for unavailable information
Preserves source query and location
Records the scrape timestamp
Fails the run when a required network operation cannot be completed
```

The current version intentionally avoids silently manufacturing missing business data.

***

## 🔌 API & integrations

Apple Maps Scraper can be used programmatically through the **Apify API**.

You can connect results to workflows such as:

- Google Sheets
- Make
- Zapier
- CRMs
- Internal APIs
- Data warehouses
- Lead-generation systems
- Local SEO dashboards
- AI agents
- MCP workflows

Every Actor run stores structured results in the default **Apify Dataset**, making them easy to consume from another application.

***

## 💡 Example use cases

### 🎯 Local lead generation

Search:

```text
roofing contractor
HVAC contractor
plumber
electrician
```

Location:

```text
Phoenix, Arizona
```

Build a prospect list containing:

```text
Business name
Phone
Website
Website type
Official website status
Address
Category
Completeness score
Opportunity tags
Apple Maps URL
```

Businesses marked with:

```text
MISSING_WEBSITE
NO_OFFICIAL_WEBSITE
MISSING_PHONE
```

can be especially useful for outreach campaigns.

***

### 🌐 Web-design and SEO prospecting

Find local businesses that:

```text
Have no website
Only use Instagram
Only use Facebook
Only have a directory listing
Have incomplete Apple Maps contact information
```

Use:

```text
websiteType
hasOfficialWebsite
listingCompletenessScore
opportunityTags
```

to prioritize potential leads.

***

### 📊 Competitor research

Search your business category and analyze:

```text
Which businesses appear in the market
Business categories
Geographic distribution
Website coverage
Phone coverage
Official website adoption
Listing completeness
```

***

### 📍 Market research

Compare local business coverage for different categories.

Use results to identify:

```text
Market saturation
Local business concentration
Potential service gaps
Areas with weak website adoption
Categories with incomplete listings
```

***

### 🗂 Directory building

Collect structured business information for:

```text
Local directories
Industry databases
Marketplaces
Internal research tools
Business discovery applications
```

Use Apple Place IDs as strong business identifiers in your downstream processing.

***

## ⚠️ Current limitations

The current version focuses on **Apple Maps keyword + location business discovery**.

It does **not currently provide**:

```text
Multiple locations in one run
User-defined radius or bounding box
Apple Maps ratings
Review counts
Detailed review extraction
Full weekly opening hours
Business photos
Website email crawling
Employee/contact enrichment
Social-profile enrichment
Historical change tracking
Guaranteed discovery of every business in an area
Verified website ownership
```

Apple Maps does not expose every field for every business through the search data currently used by this Actor.

The Actor deliberately avoids claiming fields that cannot be determined reliably.

***

## ❓ FAQ

### How does Apple Maps Scraper work?

The Actor resolves your selected location and searches Apple Maps for your business queries.

It then:

```text
Gets Apple Maps search access
Resolves location coordinates
Creates geographic search points
Searches Apple Maps
Collects public business data
Normalizes business fields
Classifies website URLs
Scores listing completeness
Detects lead opportunities
Deduplicates Apple places
Stores results in an Apify Dataset
```

***

### How many businesses can I scrape?

The current configured maximum is:

```text
500 unique businesses per Actor run
```

Apple Maps may expose fewer results.

Requesting:

```text
500
```

does not guarantee that 500 unique businesses exist or will be discoverable around the selected location.

The Actor returns the businesses it can discover within its search coverage.

***

### Is the maximum applied per query?

No.

`maxResults` currently applies to the **entire Actor run**.

Example:

```text
Queries:
plumber
electrician

maxResults:
100
```

means:

```text
Up to 100 unique businesses total
```

not 100 businesses for each query.

***

### Can I search multiple business categories?

**Yes.**

You can provide up to:

```text
20 search queries
```

in one run.

Examples:

```text
plumber
electrician
restaurant
coffee shop
dentist
lawyer
```

***

### Can I search multiple locations in one run?

**Not in the current version.**

One location is applied to the Actor run.

For multiple cities, start separate Actor runs.

***

### Why are some fields null?

Apple Maps does not expose every field for every business.

The Actor deliberately returns:

```text
null
```

when a value cannot be determined from the available Apple Maps data.

It does not fabricate missing information.

***

### What does `websiteType` mean?

`websiteType` classifies the URL Apple Maps returned.

Possible values:

```text
official
social
directory
none
```

The classification uses known domain patterns.

It should be treated as a **lead-generation heuristic**, not a guarantee of website ownership.

***

### What is `hasOfficialWebsite`?

This field is:

```text
true
```

when the selected URL is classified as:

```text
official
```

and:

```text
false
```

when Apple Maps exposes:

```text
No URL
Social profile only
Directory page only
```

***

### How is the completeness score calculated?

The current score checks five signals:

```text
Name
Category
Address
Phone
Official website
```

Each contributes:

```text
20 points
```

Maximum:

```text
100
```

This gives users a simple way to identify weaker business listings.

***

### Why can two businesses have the same name?

Different physical branches can share a business name.

The Actor prioritizes Apple Place IDs when deduplicating.

For example:

```text
CoffeeShop — Location A — Place ID A
CoffeeShop — Location B — Place ID B
```

remain separate results.

***

### What is `matchedQueries`?

`matchedQueries` records search queries that discovered the same Apple Maps place before the result limit was reached.

Example:

```json
{
  "sourceQuery": "coffee",
  "matchedQueries": [
    "coffee",
    "cafe"
  ]
}
```

This provides useful search provenance while avoiding duplicate Dataset rows.

***

### Can I use Apple Maps Scraper through an API?

**Yes.**

The Actor can be started through the **Apify API**, and the resulting Dataset can be downloaded or consumed programmatically.

This makes it suitable for automated:

```text
Lead-generation systems
Local SEO workflows
Research pipelines
CRM imports
Business intelligence
AI applications
```

***

### Can I export the results?

**Yes.**

Apify Dataset results can be exported in supported formats such as:

```text
JSON
CSV
Excel
XML
HTML
```

***

### Is a browser required?

**No, not for the normal workflow.**

Apple Maps Scraper uses an HTTP-first search architecture.

It does not need to launch browser automation for standard business searches.

***

### Does the Actor scrape ratings and reviews?

**Not currently.**

The Apple Maps responses used by the current Actor do not reliably expose those fields in the verified workflow.

Rather than returning misleading information, those fields are intentionally excluded.

***

### Does the Actor scrape opening hours?

**Not currently.**

The verified Apple Maps responses used by the current version do not provide reliable full opening-hours data.

This may be explored in a future business-detail mode if a reliable source becomes available.

***

## 🧭 Recommended workflow

For strong lead-generation coverage, use **distinct business categories** instead of many nearly identical queries.

Good:

```text
plumber
electrician
HVAC contractor
roofing contractor
```

Less useful:

```text
plumber
plumbers
plumbing
plumbing company
plumbing companies
```

Semantically similar searches can produce heavily overlapping Apple Maps results.

Since the Actor deduplicates the same Apple place and `maxResults` applies globally, distinct categories usually produce more useful datasets.

For website or SEO prospecting, filter results using:

```text
hasOfficialWebsite = false
```

or:

```text
opportunityTags contains:
MISSING_WEBSITE
NO_OFFICIAL_WEBSITE
```

***

## 💬 Feedback & support

Found a bug or have a feature request?

Use the Actor's **Issues** tab on Apify.

Useful future additions may include:

```text
Multiple locations
Custom geographic radius
Bounding-box search
Business detail mode
Opening hours
Ratings and review counts
Website/contact enrichment
Historical listing tracking
Advanced opportunity filters
More local-search intelligence
```

***

### 🚀 Apple Maps business data without the manual searching

Enter your business keywords, choose a location, set your maximum results, and run the Actor.

Receive **structured Apple Maps business data** ready for:

```text
Lead generation
Local SEO
Prospecting
Market research
Business directories
APIs
Automation
AI workflows
```

Plus lead-focused signals that help identify:

```text
Businesses without websites
Businesses using only social profiles
Businesses using directory pages instead of official websites
Listings missing phone numbers
Incomplete local-business profiles
```

# Actor input Schema

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

Business types, categories, or keywords to search for.

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

City, region, ZIP/postal area, or address used as the search center.

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

Maximum number of unique businesses to save across all searches.

## `language` (type: `string`):

Apple Maps locale used for search results.

## `countryCode` (type: `string`):

Two-letter country code used to limit results.

## Actor input object example

```json
{
  "searchQueries": [
    "coffee shops"
  ],
  "location": "San Francisco, CA",
  "maxResults": 50,
  "language": "en-US",
  "countryCode": "US"
}
```

# Actor output Schema

## `businessLeads` (type: `string`):

Apple Maps business results stored in the default Dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "coffee shops"
    ],
    "location": "San Francisco, CA"
};

// Run the Actor and wait for it to finish
const run = await client.actor("aerodynamic_tripod/apple-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 = {
    "searchQueries": ["coffee shops"],
    "location": "San Francisco, CA",
}

# Run the Actor and wait for it to finish
run = client.actor("aerodynamic_tripod/apple-maps-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "coffee shops"
  ],
  "location": "San Francisco, CA"
}' |
apify call aerodynamic_tripod/apple-maps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,aerodynamic_tripod/apple-maps-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0YQqlOsJRGFKrbf6S/builds/juD5weneULtUiZlW3/openapi.json