# Google Maps Scraper (`reefapi/google-maps-places-scraper`) Actor

Scrape any Google Maps place as clean JSON — business search, full place details, public reviews, nearby search, photos, hours and geocoding: name, address, phone, website, rating, review count, coordinates. Optional email + lead enrichment (emails, phones, socials) per business. No proxies, no

- **URL**: https://apify.com/reefapi/google-maps-places-scraper.md
- **Developed by:** [ReefAPI](https://apify.com/reefapi) (community)
- **Categories:** Lead generation, Travel, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Google Maps Scraper — Business Data, Reviews, Geocoding & B2B Leads as JSON

> 📮 **Need help, hit a problem, want a new feature, or a field that's missing from the output?** Email **support@reefapi.com** or open an issue on the **Issues** tab of this Actor — we reply fast and take feature requests seriously.

Extract any **Google Maps place** as clean, structured JSON — **business search, full place details, public reviews, nearby search, photos and geocoding** — plus optional **B2B lead enrichment (emails, extra phones & social profiles)**. Get name, address, phone, website, rating, review count, coordinates, categories and hours. **No proxies, no CAPTCHAs, no login, no cookies to provide** — you just send a query and get the data. Fast (typically 1–4s), ~99% success, flat JSON.

### What is the Google Maps Scraper?

The Google Maps Scraper is a no-code **Google Maps data API** that turns Maps searches into downloadable datasets. Instead of paying per call for the official Places API and stitching endpoints together, you send a query (`"coffee shop Times Square"`) or a place and get back clean JSON: business name, full address, phone, website, rating, review count, categories, opening hours and coordinates. It's the fastest way to **scrape Google Maps** for **local lead generation**, store-locator data, local-SEO tracking and market research. Turn on the lead-gen add-on and it becomes a **Google Maps email extractor**, visiting each business's website to pull emails and social profiles — one call from a search term to a ready-to-use B2B contact list.

### 📧 Turn places into leads (optional)

Set **`include_contacts: true`** and, for each business with a website, the scraper visits the site and extracts **email addresses, extra phone numbers and social links** (LinkedIn / Instagram / Facebook / X) — merged straight into each place. One run takes you from "coffee shops in Austin" to a contact list. (Off by default; adds a little time per result.)

### What can this Google Maps Scraper do?

- 🔎 **Search places** — free-text / business search → list of matching places with rating, address and coordinates.
- 📍 **Single place detail** — full profile for one place (hours, phone, website, rating, coordinates).
- ⭐ **Public place reviews** — review text, rating and metadata for a place (up to thousands).
- 🧭 **Nearby search** — places of a given type/category around a lat/lng point.
- 🖼️ **Place photos** — image CDN URLs for a place.
- 🆔 **Place by Google id** — look up a place directly by its Google `place_id` / `fid` / `cid`.
- 🌐 **Geocode address → coordinates** — turn an address or place name into lat/lng + formatted address.
- 📧 **Lead enrichment** — add emails, extra phones and social links per business (`include_contacts`).
- 🔁 **Monitor a place for changes** — freshness snapshot to detect when a listing changes.

### What data can I extract?

A `place/search` call returns one record per business. Key fields (from real output):

| Field | What it is |
|---|---|
| `name` | Business name |
| `rating` | Average star rating |
| `review_count` | Total number of reviews |
| `category_primary` / `categories` | Primary category + full category list |
| `address` / `locality` | Full address + city/postcode line |
| `latitude` / `longitude` | Exact coordinates |
| `website` / `domain` | Business website + bare domain |
| `phone` / `phone_display` | Phone in E.164 + formatted form |
| `hours_today` | Today's opening hours |
| `photos` / `photo_count` / `thumbnail` | Photo URLs, count and thumbnail |
| `fid` / `place_id` / `cid` / `entity_id` | Google identifiers (use to fetch detail/reviews) |
| `maps_url` | Direct Google Maps link |
| `emails` / socials* | Extracted contacts (*only when `include_contacts: true`) |

> Field availability can vary — not every business publishes a website, phone or hours, and Google can change its layout. Core fields (name, address, coordinates, categories, Maps id) are present for real places.

### How do I scrape Google Maps?

1. Open the Actor and go to the **Input** tab.
2. Pick an **Action** (Search places is the default).
3. Enter a **Query** (e.g. `specialty coffee Times Square`) and, ideally, a **lat/lng** to bias the search. For geocoding, enter an **Address**; for nearby, a **Place type** + coordinates.
4. Optionally tick **Include contact emails & socials** to enrich results into leads.
5. Click **Start**, then download the results as **JSON, CSV or Excel** from the **Dataset** tab.

### Input

```json
{ "action": "place/search", "query": "specialty coffee Times Square", "lat": "40.7589", "lng": "-73.9881", "maxResults": 10 }
````

- `action` (required) — e.g. `place/search`, `place/detail`, `place/reviews`, `place/nearby`, `geocode`.
- `query` — business name / type / free text (ideally with a place hint).
- `type` — category/keyword for `place/nearby` (e.g. `coffee shop`).
- `address` — address to geocode.
- `lat` / `lng` — coordinates to bias the search (strongly recommended).
- `include_contacts` — add emails, extra phones & socials per business.
- `max_reviews` — how many reviews to return for `place/reviews`.
- `params` — advanced JSON (maxResults, radius, sort, fid, cid, place\_id, lang, region, cursor, …).

### Output

Real `place/search` response (trimmed to one representative place):

```json
{
  "fid": "0x89c258534ee007d3:0xe0bd7e6a43f66106",
  "place_id": "0x89c258534ee007d3:0xe0bd7e6a43f66106",
  "cid": "16194238829966024966",
  "entity_id": "/g/11gcm0vmlz",
  "name": "Bluestone Lane Times Square Coffee Shop",
  "rating": 4.1,
  "review_count": null,
  "category_primary": "Coffee shop",
  "categories": ["Coffee shop", "Bar", "Cafe"],
  "address": "11 Times Sq, New York, NY 10036",
  "locality": "New York, NY 10036",
  "latitude": 40.7564652,
  "longitude": -73.9897858,
  "website": "https://bluestonelane.com/coffee-shops/11-times-square-new-york/",
  "domain": "bluestonelane.com",
  "phone": "+17183746858",
  "phone_display": "(718) 374-6858",
  "hours_today": ["7 AM-5 PM"],
  "photos": ["https://lh4.googleusercontent.com/-DsGwvv6gSi8/…/photo.jpg"],
  "photo_count": 1,
  "thumbnail": "https://lh4.googleusercontent.com/-DsGwvv6gSi8/…/photo.jpg",
  "maps_url": "https://www.google.com/maps?cid=16194238829966024966"
}
```

`geocode` returns `{query, latitude, longitude, formatted_address, locality, name, fid}`; `place/reviews` returns a `place{}` object plus the review list.

### Use cases

- **Local lead generation** — build lists of businesses by type and area, enriched with emails and socials.
- **Local SEO & rank tracking** — monitor a business's rating, review count and category over time.
- **Store locators & maps apps** — power nearby-search and geocoding features with fresh data.
- **Review monitoring** — pull public reviews for reputation analysis and sentiment.
- **Address normalization** — geocode messy addresses into clean coordinates + formatted address.
- **Market research** — map competitors, categories and ratings across a city or region.

### FAQ

**Is there an official Google Maps API?**
Yes — the Google Places API — but it's metered per call, gated behind billing and API keys, and splits the data you want across several endpoints. This Actor gives you the same public place data as clean JSON without key management, and adds lead enrichment the official API doesn't offer.

**Why scrape Google Maps?**
Google Maps is the world's largest business directory. Its place, rating, review, category and contact data powers lead generation, local SEO, store locators and market research at a scale you can't get through the front end.

**How much does it cost?**
Billed on Apify's pay-as-you-go model, benchmarked to be competitive with other Google Maps scrapers. See the **Pricing** section on this Actor's page for the current rate.

**Can I integrate it?**
Yes — run it from the Apify **API** or the **Python / Node.js clients**, and connect the output to **Make, Zapier, n8n, Google Sheets, Slack, webhooks** or your CRM via Apify integrations.

**Is it legal to scrape Google Maps?**
This Actor reads publicly available business listings (no login, no accounts). Business data is generally fine to collect; reviews and enriched contacts can contain personal data, so handle it responsibly and per GDPR/CCPA. Not legal advice.

***

Unofficial — not affiliated with Google. Public data only.

# Actor input Schema

## `action` (type: `string`):

Which Google Maps operation to run.

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

Business name / type / free text — ideally with a place hint (for place/search, place/detail, place/reviews, place/photos). e.g. 'specialty coffee Times Square'.

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

Category/keyword for place/nearby. e.g. 'coffee shop', 'pharmacy'.

## `address` (type: `string`):

Address or place name to geocode (for geocode action).

## `lat` (type: `string`):

Latitude to bias the search (strongly recommended). e.g. 40.7589.

## `lng` (type: `string`):

Longitude to bias the search (pair with lat). e.g. -73.9881.

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

How many places to return for Search / Nearby (up to 200).

## `include_contacts` (type: `boolean`):

For Search / Single place detail: also fetch each business's website and extract EMAILS, extra phone numbers and social links (LinkedIn/Instagram/Facebook/X) — turns Google Maps results into ready-to-use B2B leads. Adds some time per result; leave off if you don't need contacts.

## `max_reviews` (type: `integer`):

How many reviews to return for place/reviews (1–2000).

## `params` (type: `object`):

Any additional parameters as key/value JSON (maxResults, radius, sort, fid, cid, place\_id, lang, region, cursor, …). Merged into the request.

## Actor input object example

```json
{
  "action": "place/search",
  "maxResults": 20,
  "include_contacts": false
}
```

# Actor output Schema

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

The list of Google Maps places scraped (one item per place, with optional contact emails/socials).

# 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 = {
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("reefapi/google-maps-places-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "maxResults": 20 }

# Run the Actor and wait for it to finish
run = client.actor("reefapi/google-maps-places-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 '{
  "maxResults": 20
}' |
apify call reefapi/google-maps-places-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Scraper",
        "description": "Scrape any Google Maps place as clean JSON — business search, full place details, public reviews, nearby search, photos, hours and geocoding: name, address, phone, website, rating, review count, coordinates. Optional email + lead enrichment (emails, phones, socials) per business. No proxies, no",
        "version": "0.1",
        "x-build-id": "cdC6m6kWtSS4aYTyk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reefapi~google-maps-places-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reefapi-google-maps-places-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/reefapi~google-maps-places-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reefapi-google-maps-places-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/reefapi~google-maps-places-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reefapi-google-maps-places-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": [
                    "action"
                ],
                "properties": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "place/search",
                            "place/detail",
                            "place/reviews",
                            "place/nearby",
                            "place/photos",
                            "place/by-id",
                            "geocode",
                            "place/freshness"
                        ],
                        "type": "string",
                        "description": "Which Google Maps operation to run.",
                        "default": "place/search"
                    },
                    "query": {
                        "title": "Query",
                        "type": "string",
                        "description": "Business name / type / free text — ideally with a place hint (for place/search, place/detail, place/reviews, place/photos). e.g. 'specialty coffee Times Square'."
                    },
                    "type": {
                        "title": "Place type (nearby)",
                        "type": "string",
                        "description": "Category/keyword for place/nearby. e.g. 'coffee shop', 'pharmacy'."
                    },
                    "address": {
                        "title": "Address (geocode)",
                        "type": "string",
                        "description": "Address or place name to geocode (for geocode action)."
                    },
                    "lat": {
                        "title": "Latitude",
                        "type": "string",
                        "description": "Latitude to bias the search (strongly recommended). e.g. 40.7589."
                    },
                    "lng": {
                        "title": "Longitude",
                        "type": "string",
                        "description": "Longitude to bias the search (pair with lat). e.g. -73.9881."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "type": "integer",
                        "description": "How many places to return for Search / Nearby (up to 200)."
                    },
                    "include_contacts": {
                        "title": "Include contact emails & socials (lead-gen add-on)",
                        "type": "boolean",
                        "description": "For Search / Single place detail: also fetch each business's website and extract EMAILS, extra phone numbers and social links (LinkedIn/Instagram/Facebook/X) — turns Google Maps results into ready-to-use B2B leads. Adds some time per result; leave off if you don't need contacts.",
                        "default": false
                    },
                    "max_reviews": {
                        "title": "Max reviews",
                        "type": "integer",
                        "description": "How many reviews to return for place/reviews (1–2000)."
                    },
                    "params": {
                        "title": "Advanced parameters",
                        "type": "object",
                        "description": "Any additional parameters as key/value JSON (maxResults, radius, sort, fid, cid, place_id, lang, region, cursor, …). Merged into the request."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
