# Apple Maps Scraper | Grid, Phones, Websites & Coordinates (`muzafferkadir/apple-maps-scraper`) Actor

Scrape Apple Maps business listings: search by keyword and location, or find nearby places. Returns name, address, phone, website, coordinates and more. No browser required.

- **URL**: https://apify.com/muzafferkadir/apple-maps-scraper.md
- **Developed by:** [Muzaffer Kadir YILMAZ](https://apify.com/muzafferkadir) (community)
- **Categories:** E-commerce, Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Apple Maps Scraper

Scrapes Apple Maps business listings for local lead generation, category research, and location-based market analysis. No browser required — it uses the MapKit API directly.

### Features

- Search one or more business categories across a whole area
- Collect business names, categories, phone numbers, websites, addresses, and coordinates
- **Automatic area sizing** — type a city, district, or street and the area is covered at the right zoom (no need to guess a radius)
- Grid tiling with adaptive splitting to get past Apple's ~20-results-per-search cap
- Return clean records with Apple Maps links and scrape timestamps

### How it works

A single Apple Maps search returns at most ~20 results. To cover a whole area, this Actor:

1. Geocodes your `location` and reads Apple's own boundary for it — a city is covered wide, a neighbourhood or street narrow.
2. Tiles that area into a grid and runs one local search per cell.
3. Splits dense (saturated) cells into smaller ones, the way a person zooms in and pans around.
4. Deduplicates and merges results, then keeps only places that fall inside the requested area.

### Getting more results — important

Apple returns only the most prominent matches for a generic keyword, and Apple Maps coverage varies by category and country. For maximum coverage:

- **Use several keywords**, including the local language and brands:
  `["cafe", "kahve", "kahvaltı", "Starbucks", "Espressolab"]`
- Categories Apple indexes well (pharmacies, restaurants, hotels, shops) return far more than niche ones.
- Result counts reflect what Apple Maps actually has for your area — the Actor does not invent far-away results to pad the list.

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | - | Business keywords to search (one or more) |
| `location` | string | - | Area center as text, e.g. `"Kadıköy, İstanbul"` |
| `lat` / `lng` | number | - | Area center as coordinates (alternative to `location`) |
| `maxItems` | number | `100` | Maximum number of places |
| `lang` | string | `en-US` | Result language, e.g. `tr-TR` |
| `radius` | number | *auto* | **Advanced.** Fixed radius in meters; leave empty for automatic area sizing |
| `boundingBox` | object | - | **Advanced.** Explicit area, overrides location/radius |
| `queryExpansion` | boolean | `true` | **Advanced.** Enable local-language keyword variants |
| `queryExpansions` | object | - | **Advanced.** Custom keyword variants |

Other advanced grid/cost controls (`cellSizeMeters`, `adaptiveGrid`, `saturationThreshold`, `maxGridDepth`, `maxCells`, …) are tuned by default — change them only if you understand the trade-offs.

### Examples

#### Search a whole district (automatic area)

```json
{
  "searchQueries": ["cafe", "kahve"],
  "location": "Kadıköy, İstanbul",
  "maxItems": 100,
  "lang": "tr-TR"
}
````

#### Maximum coverage with multiple keywords and brands

```json
{
  "searchQueries": ["cafe", "kahve", "kahvaltı", "Starbucks", "Espressolab", "Kahve Dünyası"],
  "location": "Beşiktaş, İstanbul",
  "maxItems": 200,
  "lang": "tr-TR"
}
```

#### Fixed radius around coordinates

```json
{
  "searchQueries": ["eczane"],
  "lat": 40.9907,
  "lng": 29.0289,
  "radius": 2000,
  "maxItems": 100,
  "lang": "tr-TR"
}
```

### Output

Each dataset item contains place data such as:

- Business name, category, address, phone number, and website
- Latitude, longitude, country, and Apple Maps URL
- Original search query and matched query
- Scrape timestamp

# Actor input Schema

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

What to look for, one keyword per line, e.g. cafe, eczane, dentist. Use the local language for best coverage (e.g. 'restoran' instead of 'restaurant' in Turkey). Add several keywords (and brands) to cover more places.

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

Area center as text, geocoded automatically, e.g. 'Kadıköy, İstanbul'. The search area is sized automatically from the place — a city is covered wide, a neighbourhood or street narrow. Leave empty if you provide coordinates or a bounding box.

## `lat` (type: `number`):

Center latitude (alternative to Location). Example: 40.9907.

## `lng` (type: `number`):

Center longitude (alternative to Location). Example: 29.0289.

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

Maximum total places to collect.

## `lang` (type: `string`):

Result language. Examples: tr-TR, de-DE, fr-FR.

## `radius` (type: `integer`):

Optional. How far around the center to cover, in meters. Leave empty to size the area automatically from the location; set a value to force a fixed radius instead.

## `boundingBox` (type: `object`):

Explicit area as { northLat, eastLng, southLat, westLng }. Overrides Location / coordinates / radius.

## `cellSizeMeters` (type: `integer`):

Initial size of each grid cell. Smaller cells can find more places but increase request count and cloud cost.

## `adaptiveGrid` (type: `boolean`):

Split saturated cells again. This can find more places in dense areas but increases request count and cloud cost.

## `saturationThreshold` (type: `integer`):

If a cell returns this many raw results, it is considered saturated and can be split. A lower value splits more aggressively.

## `maxGridDepth` (type: `integer`):

Maximum recursive split depth per cell. Higher values cover dense areas better but can multiply requests.

## `minCellSizeMeters` (type: `integer`):

Adaptive splitting stops below this cell size.

## `maxCells` (type: `integer`):

Hard cap on total searched cells including adaptive splits and query expansions. The scan stops early once maxItems is reached, so this mainly raises the ceiling for sparse or large areas. Higher values can improve coverage but increase runtime/cost.

## `maxCellsPerQueryVariant` (type: `integer`):

Optional cap per original/matched query variant. Prevents the first variant from using the whole maxCells budget.

## `queryExpansion` (type: `boolean`):

Try known local-language variants for generic keywords (e.g. cafe → kahve). This can find more places. Results keep originalQuery and matchedQuery.

## `queryExpansions` (type: `object`):

Optional extra variants by original query, e.g. { "market": \["A101", "BİM"] }.

## `mapkitToken` (type: `string`):

Provide your own MapKit access token to skip the automatic DuckDuckGo bootstrap. Leave empty to fetch one automatically.

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

Optional proxy. Use Apify Proxy to avoid per-IP rate limits on large grids.

## Actor input object example

```json
{
  "searchQueries": [
    "cafe",
    "eczane"
  ],
  "location": "Kadıköy, İstanbul",
  "maxItems": 100,
  "lang": "en-US",
  "cellSizeMeters": 1200,
  "adaptiveGrid": true,
  "saturationThreshold": 20,
  "maxGridDepth": 2,
  "minCellSizeMeters": 250,
  "maxCells": 150,
  "queryExpansion": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `places` (type: `string`):

All places collected across the searched area.

# 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": [
        "cafe",
        "kahve"
    ],
    "location": "Kadıköy, İstanbul"
};

// Run the Actor and wait for it to finish
const run = await client.actor("muzafferkadir/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": [
        "cafe",
        "kahve",
    ],
    "location": "Kadıköy, İstanbul",
}

# Run the Actor and wait for it to finish
run = client.actor("muzafferkadir/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": [
    "cafe",
    "kahve"
  ],
  "location": "Kadıköy, İstanbul"
}' |
apify call muzafferkadir/apple-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple Maps Scraper | Grid, Phones, Websites & Coordinates",
        "description": "Scrape Apple Maps business listings: search by keyword and location, or find nearby places. Returns name, address, phone, website, coordinates and more. No browser required.",
        "version": "1.0",
        "x-build-id": "hFbbKhESpQDSFQI1C"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muzafferkadir~apple-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muzafferkadir-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/muzafferkadir~apple-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-muzafferkadir-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/muzafferkadir~apple-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-muzafferkadir-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"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "What to look for, one keyword per line, e.g. cafe, eczane, dentist. Use the local language for best coverage (e.g. 'restoran' instead of 'restaurant' in Turkey). Add several keywords (and brands) to cover more places.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Area center as text, geocoded automatically, e.g. 'Kadıköy, İstanbul'. The search area is sized automatically from the place — a city is covered wide, a neighbourhood or street narrow. Leave empty if you provide coordinates or a bounding box."
                    },
                    "lat": {
                        "title": "Center latitude",
                        "type": "number",
                        "description": "Center latitude (alternative to Location). Example: 40.9907."
                    },
                    "lng": {
                        "title": "Center longitude",
                        "type": "number",
                        "description": "Center longitude (alternative to Location). Example: 29.0289."
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum total places to collect.",
                        "default": 100
                    },
                    "lang": {
                        "title": "Language",
                        "type": "string",
                        "description": "Result language. Examples: tr-TR, de-DE, fr-FR.",
                        "default": "en-US"
                    },
                    "radius": {
                        "title": "Radius (meters)",
                        "minimum": 100,
                        "type": "integer",
                        "description": "Optional. How far around the center to cover, in meters. Leave empty to size the area automatically from the location; set a value to force a fixed radius instead."
                    },
                    "boundingBox": {
                        "title": "Bounding box",
                        "type": "object",
                        "description": "Explicit area as { northLat, eastLng, southLat, westLng }. Overrides Location / coordinates / radius."
                    },
                    "cellSizeMeters": {
                        "title": "Grid cell size (meters)",
                        "minimum": 200,
                        "type": "integer",
                        "description": "Initial size of each grid cell. Smaller cells can find more places but increase request count and cloud cost.",
                        "default": 1200
                    },
                    "adaptiveGrid": {
                        "title": "Adaptive grid",
                        "type": "boolean",
                        "description": "Split saturated cells again. This can find more places in dense areas but increases request count and cloud cost.",
                        "default": true
                    },
                    "saturationThreshold": {
                        "title": "Saturation threshold",
                        "minimum": 1,
                        "type": "integer",
                        "description": "If a cell returns this many raw results, it is considered saturated and can be split. A lower value splits more aggressively.",
                        "default": 20
                    },
                    "maxGridDepth": {
                        "title": "Max adaptive depth",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum recursive split depth per cell. Higher values cover dense areas better but can multiply requests.",
                        "default": 2
                    },
                    "minCellSizeMeters": {
                        "title": "Minimum cell size (meters)",
                        "minimum": 50,
                        "type": "integer",
                        "description": "Adaptive splitting stops below this cell size.",
                        "default": 250
                    },
                    "maxCells": {
                        "title": "Max grid cells",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on total searched cells including adaptive splits and query expansions. The scan stops early once maxItems is reached, so this mainly raises the ceiling for sparse or large areas. Higher values can improve coverage but increase runtime/cost.",
                        "default": 150
                    },
                    "maxCellsPerQueryVariant": {
                        "title": "Max cells per query variant",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional cap per original/matched query variant. Prevents the first variant from using the whole maxCells budget."
                    },
                    "queryExpansion": {
                        "title": "Query expansion",
                        "type": "boolean",
                        "description": "Try known local-language variants for generic keywords (e.g. cafe → kahve). This can find more places. Results keep originalQuery and matchedQuery.",
                        "default": true
                    },
                    "queryExpansions": {
                        "title": "Custom query expansions",
                        "type": "object",
                        "description": "Optional extra variants by original query, e.g. { \"market\": [\"A101\", \"BİM\"] }."
                    },
                    "mapkitToken": {
                        "title": "MapKit token",
                        "type": "string",
                        "description": "Provide your own MapKit access token to skip the automatic DuckDuckGo bootstrap. Leave empty to fetch one automatically."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. Use Apify Proxy to avoid per-IP rate limits on large grids.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
