# Apple Maps Scraper — Businesses, Phones, Websites & Hours (`straightforward_hydra/apple-maps-scraper`) Actor

Scrape local businesses from Apple Maps. Export name, phone number, website, address, coordinates and opening hours to JSON, CSV or Excel. Find leads Google Maps lists miss.

- **URL**: https://apify.com/straightforward\_hydra/apple-maps-scraper.md
- **Developed by:** [Dev D](https://apify.com/straightforward_hydra) (community)
- **Categories:** Lead generation, Automation, AI
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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.

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

## Apple Maps Scraper — extract local business data, phone numbers & opening hours

Scrape local businesses from **Apple Maps** and export them to JSON, CSV, or Excel. For any search term and any area, you get the business **name, phone number, website, full address, coordinates, and opening hours**.

Everybody scrapes Google Maps. Apple Maps is a large, well-maintained business directory that almost nobody exports — so it surfaces leads that Google-only lists miss, and the businesses in it are far less likely to have been contacted already.

### What you can use it for

- **Lead generation** — build prospect lists of local businesses with phone numbers and websites.
- **Local SEO and listing audits** — check how businesses appear on Apple Maps.
- **Market research** — map the density of a business type across a city.
- **Data for AI agents** — feed structured local business data into your LLM pipeline.

### What you get for every business

| Field | Description |
| --- | --- |
| `name` | Business name |
| `telephone` | Phone number |
| `website` | Business website |
| `address` | Full formatted address |
| `street`, `city`, `region`, `post_code`, `country`, `country_code` | Address components |
| `latitude`, `longitude` | Coordinates |
| `timezone` | IANA timezone |
| `maps_url` | Link to the place on Apple Maps |
| `opening_hours` | Opening times per day (optional) |
| `amenities` | Apple Pay, Wi-Fi, credit cards accepted (optional) |

### Input

```json
{
  "searchQueries": ["dentist", "orthodontist"],
  "location": "Austin, Texas",
  "radiusKm": 5,
  "maxPlaces": 500,
  "includeOpeningHours": true
}
````

| Input | Description |
| --- | --- |
| `searchQueries` | What to search for, exactly as you'd type it into Apple Maps |
| `location` | Centre of the search area, as free text |
| `radiusKm` | How far out from the centre to search (1–50 km) |
| `maxPlaces` | Hard cap on results — this is also your cost ceiling |
| `includeOpeningHours` | Adds opening hours and amenity flags |

### Output sample

```json
{
  "name": "Swish Dental",
  "telephone": "+15127131099",
  "website": "https://www.swishsmiles.com/",
  "address": "201 W 5th St, Unit 175, Austin, TX 78701, United States",
  "city": "Austin",
  "region": "Texas",
  "post_code": "78701",
  "country_code": "US",
  "latitude": 30.2673281,
  "longitude": -97.744828,
  "timezone": "America/Chicago",
  "opening_hours": {
    "MONDAY": "09:00-18:00",
    "TUESDAY": "08:00-17:30",
    "WEDNESDAY": "08:00-17:30",
    "THURSDAY": "08:00-17:30",
    "FRIDAY": "08:00-17:30"
  },
  "amenities": {
    "ACCEPTS_APPLE_PAY": true,
    "HAS_FREE_WIFI": true,
    "ACCEPTS_CREDIT_CARDS": true
  }
}
```

### How many results will I get?

Apple returns at most 10 results per search, no matter what you ask for. To cover an area properly, this scraper lays a grid of search points across your radius and de-duplicates the results — so a single run returns hundreds of unique businesses rather than ten.

**Radius drives your result count.** A 3 km radius covers a neighbourhood; 25 km covers a metro area.

### Pricing

You pay per unique business returned. A search that finds nothing costs you nothing.

### FAQ

**Which countries are covered?**
Apple Maps business data is strongest in the United States, United Kingdom, Canada, Australia, and Europe, and is good across most developed markets. Coverage in South Asia and parts of Africa is thin — expect few results there.

**Is there an official Apple Maps API for this?**
Apple's own API is aimed at displaying maps inside apps, not exporting business listings in bulk. This actor gives you the data as a plain dataset you can download or pipe straight into a CRM.

**Can I use this with an AI agent or MCP?**
Yes. Run it via the Apify API and it returns clean structured JSON, so it plugs straight into an LLM pipeline.

**Why not just scrape Google Maps?**
You should do both. Apple Maps holds businesses that Google-based lead lists routinely miss, and the contacts in it are much less saturated.

**Do I get email addresses?**
No. Apple Maps publishes phone numbers and websites, not emails. Feed the `website` column into an email finder if you need addresses.

### Notes

Only publicly visible business listing data is collected — no personal data. What you do with the output is your responsibility: if you contact these businesses, follow the marketing laws that apply to you (GDPR, CAN-SPAM, and so on).

# Actor input Schema

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

What to look for, as you would type it into Apple Maps. Each query is searched across the whole area.

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

Centre of the search area, as free text. Coverage is strongest in the US, UK and Europe.

## `radiusKm` (type: `integer`):

How far out from the centre to search. Bigger radius means more grid points, more places, and a longer run.

## `maxPlaces` (type: `integer`):

Stop once this many unique businesses have been found. This is also your cost ceiling — you are charged per place.

## `includeOpeningHours` (type: `boolean`):

Fetch opening hours plus amenity flags (Apple Pay, Wi-Fi, credit cards). Adds one extra request per batch of 10 places.

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

Language for names and addresses, as a BCP-47 tag.

## `concurrency` (type: `integer`):

Parallel requests to Apple Maps. Raise for speed, lower if you start seeing rate limits.

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

Recommended. Rotating datacenter proxies avoid rate limits on larger runs.

## Actor input object example

```json
{
  "searchQueries": [
    "dentist",
    "coffee shop"
  ],
  "location": "Austin, Texas",
  "radiusKm": 5,
  "maxPlaces": 100,
  "includeOpeningHours": false,
  "language": "en-US",
  "concurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": [
        "dentist"
    ],
    "location": "Austin, Texas"
};

// Run the Actor and wait for it to finish
const run = await client.actor("straightforward_hydra/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": ["dentist"],
    "location": "Austin, Texas",
}

# Run the Actor and wait for it to finish
run = client.actor("straightforward_hydra/apple-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 '{
  "searchQueries": [
    "dentist"
  ],
  "location": "Austin, Texas"
}' |
apify call straightforward_hydra/apple-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple Maps Scraper — Businesses, Phones, Websites & Hours",
        "description": "Scrape local businesses from Apple Maps. Export name, phone number, website, address, coordinates and opening hours to JSON, CSV or Excel. Find leads Google Maps lists miss.",
        "version": "0.1",
        "x-build-id": "Q99JkpwJITVkLlRHL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/straightforward_hydra~apple-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-straightforward_hydra-apple-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/straightforward_hydra~apple-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-straightforward_hydra-apple-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/straightforward_hydra~apple-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-straightforward_hydra-apple-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",
                "required": [
                    "searchQueries",
                    "location"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "What to look for, as you would type it into Apple Maps. Each query is searched across the whole area.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Centre of the search area, as free text. Coverage is strongest in the US, UK and Europe."
                    },
                    "radiusKm": {
                        "title": "Radius (km)",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How far out from the centre to search. Bigger radius means more grid points, more places, and a longer run.",
                        "default": 5
                    },
                    "maxPlaces": {
                        "title": "Maximum places",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop once this many unique businesses have been found. This is also your cost ceiling — you are charged per place.",
                        "default": 100
                    },
                    "includeOpeningHours": {
                        "title": "Include opening hours and amenities",
                        "type": "boolean",
                        "description": "Fetch opening hours plus amenity flags (Apple Pay, Wi-Fi, credit cards). Adds one extra request per batch of 10 places.",
                        "default": false
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language for names and addresses, as a BCP-47 tag.",
                        "default": "en-US"
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Parallel requests to Apple Maps. Raise for speed, lower if you start seeing rate limits.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Recommended. Rotating datacenter proxies avoid rate limits on larger runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
