# Global Nightlife Search (`lentic_clockss/global-nightlife-search`) Actor

Find bars, clubs, karaoke and KTV venues, live music spots, lounges, massage spas, and nightlife businesses worldwide by city, with optional review text and adult-oriented categories off by default.

- **URL**: https://apify.com/lentic\_clockss/global-nightlife-search.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Lead generation, Other, Travel
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## Global Nightlife Search

**Find bars, clubs, karaoke venues, massage spas, lounges, and nightlife businesses worldwide by city.**

- Search nightlife venues across one city or many cities
- Choose venue types from a simple form: bars, clubs, karaoke, KTV, live music, massage, spa, casino, and lounge
- Get names, categories, addresses, phones, websites, ratings, reviews, hours, and coordinates
- Include review text for venue quality checks, with reviewer personal details anonymized by default
- Keep adult-oriented nightlife categories off by default unless you explicitly opt in and confirm you are 18+ and local rules allow it
- Export to Excel, CSV, JSON, Google Sheets, Make, Zapier, n8n, or your CRM
- Simple pricing: $0.005 per Actor start and $0.001 per result, reviews included

If you have been checking city nightlife venues one by one, this Actor turns that manual work into a clean venue dataset you can use for lead lists, market research, expansion planning, or review monitoring.

### Examples

Small ready-to-edit inputs are in:

- [One-city nightlife list](./examples/one-city-nightlife/README.md)
- [Multi-city comparison](./examples/multi-city-comparison/README.md)
- [Review monitoring](./examples/review-monitoring/README.md)

### What You Can Do With It

#### 1. Build a nightlife venue list for one city

Use this when you need a practical list of bars, clubs, lounges, and related venues in a city.

You fill in a few fields in the Apify input form:

| What | Example |
| --- | --- |
| Cities | `Makati, Philippines` |
| Venue categories | Bars and pubs, Nightclubs, Lounges |
| Max venues per city | `20` |
| Include reviews? | Yes |
| Reviews per venue | `3` |

Click Start. The Actor searches public map results, removes duplicates, adds contact fields, and gives you a clean table:

| Venue | Type | Phone | Website | Rating | Reviews | Address |
| --- | --- | --- | --- | --- | --- | --- |
| Sample Cocktail Bar | Cocktail bar | +63 ... | example.com | 4.5 | 312 | Makati, Metro Manila |
| Sample Lounge | Lounge | +63 ... | example.com | 4.3 | 188 | Makati, Metro Manila |

Download the result as Excel or CSV, or send it to a spreadsheet or CRM through Apify integrations.

<details>
<summary>For developers: example input</summary>

```json
{
  "cities": ["Makati, Philippines"],
  "venueCategories": ["bars", "nightclubs", "lounges"],
  "includeAdultOrientedVenues": false,
  "confirmAdultUse": false,
  "coverageMode": "quick",
  "maxPlacesPerCity": 20,
  "maxTotalPlaces": 20,
  "includeReviews": true,
  "maxReviewsPerPlace": 3,
  "anonymizeReviewers": true,
  "language": "en",
  "country": "PH",
  "proxyCountry": "",
  "filters": {
    "minRating": 0,
    "minReviewCount": 0,
    "requirePhone": false,
    "requireWebsite": false,
    "openNow": false
  }
}
````

</details>

#### 2. Compare the same venue categories across many cities

Use this when you want to compare nightlife density or build city-by-city market lists.

| What | Example |
| --- | --- |
| Cities | `Manila, Philippines`, `Bangkok, Thailand`, `Singapore`, `Tokyo, Japan` |
| Venue categories | Bars and pubs, Karaoke / KTV, Massage and spa |
| Coverage | Standard |
| Max venues per city | `100` |

The output keeps the source city and venue group on every row:

| City | Venue group | Venue | Rating | Reviews | Contactable |
| --- | --- | --- | --- | --- | --- |
| Manila | Karaoke / KTV | Sample KTV | 4.2 | 96 | Yes |
| Bangkok | Massage and spa | Sample Spa | 4.6 | 421 | Yes |
| Tokyo | Bars and pubs | Sample Pub | 4.4 | 209 | Yes |

This makes it easy to filter by city, venue type, contactability, rating, or review count.

<details>
<summary>For developers: multi-city input</summary>

```json
{
  "cities": ["Manila, Philippines", "Bangkok, Thailand", "Singapore", "Tokyo, Japan"],
  "venueCategories": ["bars", "karaoke_ktv", "massage_spa"],
  "includeAdultOrientedVenues": false,
  "confirmAdultUse": false,
  "coverageMode": "standard",
  "maxPlacesPerCity": 100,
  "maxTotalPlaces": 300,
  "includeReviews": true,
  "maxReviewsPerPlace": 3,
  "anonymizeReviewers": true,
  "language": "en",
  "country": "",
  "proxyCountry": "",
  "filters": {
    "minRating": 4,
    "minReviewCount": 20,
    "requirePhone": false,
    "requireWebsite": false,
    "openNow": false
  }
}
```

</details>

#### 3. Find karaoke, KTV, and live music venues

Nightlife is not just bars and clubs. This Actor can search KTV, karaoke bars, live music venues, jazz bars, and performance venues.

| What | Example |
| --- | --- |
| Cities | `Quezon City, Philippines` |
| Venue categories | Karaoke / KTV, Live music venues |
| Include reviews? | Yes |
| Reviews per venue | `5` |

Reviews help you understand whether a place is active, what the atmosphere is like, and whether recent customers mention music, service, crowd, or pricing.

Reviewer personal information is anonymized by default:

| Venue | Rating | Review date | Review text | Reviewer |
| --- | --- | --- | --- | --- |
| Sample KTV | 5 | 2 weeks ago | Good sound system and private rooms. | Reviewer 1 |
| Sample Music Bar | 4 | 1 month ago | Great live band, crowded on weekends. | Reviewer 2 |

The Actor keeps useful review content but does not output reviewer avatar URLs, profile links, or full profile identity by default.

#### 4. Collect massage, spa, sauna, and wellness venues

Use this for public venue discovery around massage, spa, sauna, and wellness categories.

| What | Example |
| --- | --- |
| Cities | `Bangkok, Thailand` |
| Venue categories | Massage and spa |
| Minimum rating | `4.0` |
| Minimum reviews | `20` |
| Require phone? | Yes |

The result is a venue list ready for spreadsheet filtering:

| Venue | Category | Phone | Website | Rating | Reviews | Open now |
| --- | --- | --- | --- | --- | --- | --- |
| Sample Thai Massage | Massage spa | +66 ... | example.com | 4.7 | 812 | Yes |
| Sample Wellness Spa | Spa | +66 ... | example.com | 4.5 | 247 | Yes |

For broad city coverage, use Standard mode first. Use Deep mode only when you need wider coverage and are comfortable with longer runs.

#### 5. Monitor reviews and recent venue activity

Use this when you care about venue quality, recent customer sentiment, or competitor monitoring.

| What | Example |
| --- | --- |
| Cities | `Las Vegas, Nevada` |
| Venue categories | Bars and pubs, Nightclubs |
| Include reviews? | Yes |
| Reviews per venue | `5` |
| Schedule | Weekly or monthly |

Each run gives a fresh snapshot:

| Venue | Rating | Recent reviews | Monitoring flags | Sample review |
| --- | --- | --- | --- | --- |
| Sample Club | 4.1 | Yes | recent\_review\_activity | Long line but good music. |
| Sample Bar | 3.7 | Yes | low\_rating, recent\_review\_activity | Service was slow on Friday. |

You can run it on a schedule and compare results in Google Sheets, Airtable, Make, Zapier, n8n, or your own database.

#### 6. Adult-oriented nightlife categories

Adult-oriented nightlife search is available, but it is not enabled by default.

To use adult-oriented categories, you must turn on both settings:

| Setting | Default | What it means |
| --- | --- | --- |
| Include adult-oriented venues | Off | Adds adult-oriented nightlife search terms |
| 18+ and local-rules confirmation | Off | Confirms you are 18+ and allowed to search this category under the local rules that apply to you |

If you do not turn both on, the Actor skips adult-oriented searches.

This keeps normal nightlife searches clean. A user looking for bars, clubs, karaoke, massage, spa, lounges, and similar venues will not receive adult-oriented results unless they deliberately enable that category.

This Actor is not designed for illegal activity or evading local rules. Use it only for lawful public venue research.

### How To Use

1. Open the Actor on Apify.
2. Enter one or more cities.
3. Select venue categories.
4. Choose Quick, Standard, or Deep coverage.
5. Decide whether to include reviews.
6. Keep reviewer anonymization on unless you have a clear lawful reason to handle reviewer identity fields.
7. Click Start.
8. Download the results as Excel, CSV, or JSON.

You do not need to write code. The form is enough for normal use.

Developers can still call the Actor through API, Make, Zapier, n8n, or MCP.

### What You Get Back

Each venue record can include:

- Venue name
- Venue group used for the search
- Category
- City and country
- Address
- Phone
- Website
- Source map URL
- Latitude and longitude
- Rating
- Review count
- Price level when available
- Opening hours when available
- Source query used to find the venue
- Contactability flags
- Reviews when enabled

Review output keeps useful content and removes unnecessary personal identity fields by default.

Default review fields:

| Field | Meaning |
| --- | --- |
| Review rating | Star rating |
| Review text | The written review content |
| Relative date | Example: `2 weeks ago` |
| Language | Review language when available |
| Owner reply | Business reply when available |
| Reviewer label | Anonymous label such as `Reviewer 1` |

Not included by default:

- Reviewer avatar URL
- Reviewer profile URL
- Full reviewer identity

<details>
<summary>For developers: example output record</summary>

```json
{
  "place_id": "0x0000000000000000:0x1111111111111111",
  "name": "Sample Cocktail Bar",
  "venue_group": "bars",
  "category": "Cocktail bar",
  "city": "Makati, Philippines",
  "country": "Philippines",
  "address": "Sample Street, Makati, Metro Manila",
  "phone": "+63 2 0000 0000",
  "website": "https://example.com",
  "rating": 4.5,
  "review_count": 312,
  "review_count_scraped": 3,
  "latitude": 14.5547,
  "longitude": 121.0244,
  "google_maps_url": "https://www.google.com/maps/place/?q=place_id:sample",
  "has_phone": true,
  "has_website": true,
  "is_contactable": true,
  "reviews": [
    {
      "reviewer_label": "Reviewer 1",
      "rating": 5,
      "text": "Good drinks and friendly staff.",
      "relative_date": "2 weeks ago",
      "language": "en",
      "owner_reply": null
    }
  ]
}
```

</details>

### Data Source

Global Nightlife Search is based on public Google Maps place results. It is packaged as a nightlife-focused search workflow and is not an official Google product.

### Pricing

Same pricing as the existing Google Maps Scraper:

| Event | Price |
| --- | --- |
| Actor start | $0.005 |
| Result | $0.001 per venue |

Reviews are included in the venue result price.

Example:

| Run | Approximate cost |
| --- | --- |
| 20 venues | $0.025 |
| 100 venues | $0.105 |
| 500 venues | $0.505 |
| 1,000 venues | $1.005 |

Leave `proxyCountry` empty unless you specifically need residential proxy routing. Normal runs use no proxy by default because proxy routing can slow down or block Google Maps navigation.

Actual Apify platform usage can vary by run size, coverage mode, proxy use, and review depth.

### When To Use A General Map Search Instead

Use a general map scraper if you only need one custom search like:

- `dentists in Chicago`
- `hotels near Central Park`
- `restaurants in Shibuya Tokyo`
- `plumbers in Denver`

Use Global Nightlife Search when you want a guided form for nightlife categories, multi-city searches, venue groups, review context, and adult-oriented categories that stay off unless explicitly enabled.

### FAQ

#### Can I search more than one city?

Yes. Add multiple cities and the Actor runs the selected venue categories for each city.

#### Can I include reviews?

Yes. Review text is supported. Reviewer personal information is anonymized by default.

#### Are adult-oriented venues included by default?

No. They are off by default. You must enable adult-oriented venues and confirm you are 18+ and allowed to search that category under the local rules that apply to you.

#### Can I export to Excel?

Yes. Apify lets you download results as Excel, CSV, JSON, and other formats.

#### Can I automate this?

Yes. You can schedule runs in Apify or connect the Actor to Make, Zapier, n8n, Google Sheets, Airtable, or your own API workflow.

#### Does this use my Google account?

No. It does not need your Google login.

#### Can I use it for normal non-adult venues only?

Yes. Leave adult-oriented categories off. The default use case is standard public venue discovery for bars, clubs, karaoke, massage, spa, lounges, and similar businesses.

# Actor input Schema

## `cities` (type: `array`):

Cities or metro areas to search. Add country names for better matching, for example Makati, Philippines.

## `venueCategories` (type: `array`):

Nightlife categories to search in each city.

## `includeAdultOrientedVenues` (type: `boolean`):

Default is off. Enable only if you are 18+ and the local rules that apply to you allow searching this category.

## `confirmAdultUse` (type: `boolean`):

Required only for adult-oriented nightlife. Keep off unless you are 18+ and have confirmed the local rules allow this use.

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

Quick is best for small tests. Standard gives broader city coverage. Deep runs more searches and may take longer.

## `maxPlacesPerCity` (type: `integer`):

Maximum venue records to return for each city.

## `maxTotalPlaces` (type: `integer`):

Hard cap across all cities and categories. Keeps default runs small and predictable.

## `includeReviews` (type: `boolean`):

Scrape review text for each venue. Reviews are included in the venue price.

## `maxReviewsPerPlace` (type: `integer`):

Maximum number of reviews to scrape per venue.

## `anonymizeReviewers` (type: `boolean`):

Default is on. Keeps review text but removes reviewer avatar, profile URL, and full identity fields.

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

Language code for place and review results, for example en, ja, th, es, or fr.

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

Optional ISO-2 country hint for search and localization. Leave empty for automatic matching from the city names.

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

Optional ISO-2 proxy country. Leave empty to run without a proxy. Use only if you specifically need residential proxy routing.

## `filters` (type: `object`):

Optional venue filters applied after scraping.

## Actor input object example

```json
{
  "cities": [
    "Makati, Philippines"
  ],
  "venueCategories": [
    "bars",
    "nightclubs",
    "lounges"
  ],
  "includeAdultOrientedVenues": false,
  "confirmAdultUse": false,
  "coverageMode": "quick",
  "maxPlacesPerCity": 20,
  "maxTotalPlaces": 20,
  "includeReviews": true,
  "maxReviewsPerPlace": 3,
  "anonymizeReviewers": true,
  "language": "en",
  "country": "",
  "proxyCountry": "",
  "filters": {
    "minRating": 0,
    "minReviewCount": 0,
    "requirePhone": false,
    "requireWebsite": false,
    "openNow": false
  }
}
```

# Actor output Schema

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

One nightlife venue per dataset item, including contact fields, ratings, optional review text, and city/category context.

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

Final run summary written to the default key-value store, including city, category, venue, and review counters.

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

Live progress updates written during the run.

# 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 = {
    "cities": [
        "Makati, Philippines"
    ],
    "venueCategories": [
        "bars",
        "nightclubs",
        "lounges"
    ],
    "includeAdultOrientedVenues": false,
    "confirmAdultUse": false,
    "coverageMode": "quick",
    "maxPlacesPerCity": 20,
    "maxTotalPlaces": 20,
    "includeReviews": true,
    "maxReviewsPerPlace": 3,
    "anonymizeReviewers": true,
    "language": "en",
    "country": "",
    "proxyCountry": "",
    "filters": {
        "minRating": 0,
        "minReviewCount": 0,
        "requirePhone": false,
        "requireWebsite": false,
        "openNow": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/global-nightlife-search").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 = {
    "cities": ["Makati, Philippines"],
    "venueCategories": [
        "bars",
        "nightclubs",
        "lounges",
    ],
    "includeAdultOrientedVenues": False,
    "confirmAdultUse": False,
    "coverageMode": "quick",
    "maxPlacesPerCity": 20,
    "maxTotalPlaces": 20,
    "includeReviews": True,
    "maxReviewsPerPlace": 3,
    "anonymizeReviewers": True,
    "language": "en",
    "country": "",
    "proxyCountry": "",
    "filters": {
        "minRating": 0,
        "minReviewCount": 0,
        "requirePhone": False,
        "requireWebsite": False,
        "openNow": False,
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/global-nightlife-search").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 '{
  "cities": [
    "Makati, Philippines"
  ],
  "venueCategories": [
    "bars",
    "nightclubs",
    "lounges"
  ],
  "includeAdultOrientedVenues": false,
  "confirmAdultUse": false,
  "coverageMode": "quick",
  "maxPlacesPerCity": 20,
  "maxTotalPlaces": 20,
  "includeReviews": true,
  "maxReviewsPerPlace": 3,
  "anonymizeReviewers": true,
  "language": "en",
  "country": "",
  "proxyCountry": "",
  "filters": {
    "minRating": 0,
    "minReviewCount": 0,
    "requirePhone": false,
    "requireWebsite": false,
    "openNow": false
  }
}' |
apify call lentic_clockss/global-nightlife-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lentic_clockss/global-nightlife-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Global Nightlife Search",
        "description": "Find bars, clubs, karaoke and KTV venues, live music spots, lounges, massage spas, and nightlife businesses worldwide by city, with optional review text and adult-oriented categories off by default.",
        "version": "0.1",
        "x-build-id": "plrJNf30kT5iSXFv7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~global-nightlife-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-global-nightlife-search",
                "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/lentic_clockss~global-nightlife-search/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-global-nightlife-search",
                "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/lentic_clockss~global-nightlife-search/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-global-nightlife-search",
                "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": [
                    "cities",
                    "venueCategories",
                    "includeAdultOrientedVenues",
                    "confirmAdultUse",
                    "coverageMode",
                    "maxPlacesPerCity",
                    "maxTotalPlaces",
                    "includeReviews",
                    "maxReviewsPerPlace",
                    "anonymizeReviewers",
                    "language",
                    "country",
                    "proxyCountry",
                    "filters"
                ],
                "properties": {
                    "cities": {
                        "title": "Cities",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Cities or metro areas to search. Add country names for better matching, for example Makati, Philippines.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 200
                        },
                        "default": [
                            "Makati, Philippines"
                        ]
                    },
                    "venueCategories": {
                        "title": "Venue categories",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Nightlife categories to search in each city.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "bars",
                                "nightclubs",
                                "lounges",
                                "karaoke_ktv",
                                "live_music",
                                "massage_spa",
                                "sauna_wellness",
                                "casinos",
                                "adult_oriented"
                            ],
                            "enumTitles": [
                                "Bars and pubs",
                                "Nightclubs",
                                "Lounges",
                                "Karaoke / KTV",
                                "Live music venues",
                                "Massage and spa",
                                "Sauna and wellness",
                                "Casinos",
                                "Adult-oriented nightlife"
                            ]
                        },
                        "default": [
                            "bars",
                            "nightclubs",
                            "lounges"
                        ]
                    },
                    "includeAdultOrientedVenues": {
                        "title": "Include adult-oriented venues",
                        "type": "boolean",
                        "description": "Default is off. Enable only if you are 18+ and the local rules that apply to you allow searching this category.",
                        "default": false
                    },
                    "confirmAdultUse": {
                        "title": "I am 18+ and local rules allow this search",
                        "type": "boolean",
                        "description": "Required only for adult-oriented nightlife. Keep off unless you are 18+ and have confirmed the local rules allow this use.",
                        "default": false
                    },
                    "coverageMode": {
                        "title": "Coverage mode",
                        "enum": [
                            "quick",
                            "standard",
                            "deep"
                        ],
                        "type": "string",
                        "description": "Quick is best for small tests. Standard gives broader city coverage. Deep runs more searches and may take longer.",
                        "default": "quick"
                    },
                    "maxPlacesPerCity": {
                        "title": "Max venues per city",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum venue records to return for each city.",
                        "default": 20
                    },
                    "maxTotalPlaces": {
                        "title": "Max total venues",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap across all cities and categories. Keeps default runs small and predictable.",
                        "default": 20
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Scrape review text for each venue. Reviews are included in the venue price.",
                        "default": true
                    },
                    "maxReviewsPerPlace": {
                        "title": "Max reviews per venue",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per venue.",
                        "default": 3
                    },
                    "anonymizeReviewers": {
                        "title": "Anonymize reviewers",
                        "type": "boolean",
                        "description": "Default is on. Keeps review text but removes reviewer avatar, profile URL, and full identity fields.",
                        "default": true
                    },
                    "language": {
                        "title": "Language",
                        "minLength": 2,
                        "maxLength": 5,
                        "type": "string",
                        "description": "Language code for place and review results, for example en, ja, th, es, or fr.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "maxLength": 2,
                        "type": "string",
                        "description": "Optional ISO-2 country hint for search and localization. Leave empty for automatic matching from the city names.",
                        "default": ""
                    },
                    "proxyCountry": {
                        "title": "Proxy country",
                        "maxLength": 2,
                        "type": "string",
                        "description": "Optional ISO-2 proxy country. Leave empty to run without a proxy. Use only if you specifically need residential proxy routing.",
                        "default": ""
                    },
                    "filters": {
                        "title": "Filters",
                        "type": "object",
                        "description": "Optional venue filters applied after scraping.",
                        "properties": {
                            "minRating": {
                                "title": "Minimum rating",
                                "description": "0 means no minimum rating filter.",
                                "type": "number",
                                "minimum": 0,
                                "maximum": 5
                            },
                            "minReviewCount": {
                                "title": "Minimum review count",
                                "description": "0 means no minimum review-count filter.",
                                "type": "integer",
                                "minimum": 0
                            },
                            "requirePhone": {
                                "title": "Require phone",
                                "description": "Keep only venues with a phone number.",
                                "type": "boolean"
                            },
                            "requireWebsite": {
                                "title": "Require website",
                                "description": "Keep only venues with a website.",
                                "type": "boolean"
                            },
                            "openNow": {
                                "title": "Open now",
                                "description": "Keep only venues marked open now when this signal is available.",
                                "type": "boolean"
                            }
                        },
                        "default": {
                            "minRating": 0,
                            "minReviewCount": 0,
                            "requirePhone": false,
                            "requireWebsite": false,
                            "openNow": false
                        },
                        "additionalProperties": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
