# Soon-to-Open Businesses Leads Scraper (`automation-lab/soon-to-open-businesses-leads-scraper`) Actor

🚀 Find local businesses before they open. Scan Google Maps by category and city, verify explicit future opening dates, and export CRM-ready contact and location leads.

- **URL**: https://apify.com/automation-lab/soon-to-open-businesses-leads-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Soon-to-Open Businesses Leads Scraper

Find local businesses **before they open** using public Google Maps Business Profile signals.

This Actor searches business types across cities or regions, verifies an explicit future opening date, and exports CRM-ready contact and location data.

It is designed for sales teams that need timely prospects rather than another generic directory dump.

### What does Soon-to-Open Businesses Leads Scraper do?

The Actor turns Google Maps opening signals into structured business leads.

It can:

- 🔎 Search one or many business categories.
- 📍 Scan one or many cities, regions, or countries.
- 🔗 Accept precise Google Maps search URLs.
- ✅ Keep only profiles with a structured future opening date.
- 🧹 Deduplicate records by Google place ID or CID.
- 📤 Export JSON, CSV, Excel, XML, and RSS through Apify datasets.
- 🔄 Run on a schedule for repeated territory scans.

Ordinary search matches are rejected. A business must have an explicit Maps opening signal and a parsable date inside your configured future window.

### Who is this opening-soon leads scraper for?

#### Local marketing and web agencies

Contact new businesses while their brand, website, listings, and launch campaigns are still being planned.

#### POS, payment, and telecom sales teams

Identify restaurants, cafés, salons, and retailers before vendors are locked in.

#### Staffing and recruiting agencies

Watch for future employers that may soon need managers, service staff, clinicians, or contractors.

#### Equipment and commercial service vendors

Build prospect lists for furniture, kitchen equipment, signage, security, cleaning, insurance, and maintenance services.

#### Franchise and market researchers

Track new concepts and expansion activity across chosen territories.

### Why use this Actor instead of a generic Maps scraper?

A generic Maps scraper returns established businesses and leaves you to guess which ones are new.

This Actor applies a strict product-specific filter:

1. Generate category and geography searches.
2. Parse public Google Maps search data.
3. Read the structured opening slot.
4. Resolve the announced date.
5. Reject missing, unparseable, past, or too-distant dates.
6. Save only verified opening-soon leads.

That makes the output smaller, more timely, and immediately useful for prospecting.

### What data can I extract?

| Field | Description |
|---|---|
| `placeId` | Stable Google place identifier |
| `cid` | Numeric Google CID when available |
| `name` | Business name |
| `categories` | Google Maps business categories |
| `fullAddress` | Complete displayed address |
| `street` | Street address |
| `city` | City |
| `state` | State or region |
| `postalCode` | Postal code |
| `countryCode` | Country code |
| `latitude` | Latitude |
| `longitude` | Longitude |
| `phone` | Public phone number |
| `website` | Public business website |
| `domain` | Normalized website domain |
| `openingStatus` | `OPENING_SOON` |
| `openingDateText` | Original Maps date text, such as `Opens Aug 1` |
| `openingDate` | Normalized ISO date |
| `googleMapsUrl` | Direct Google Maps place URL |
| `query` | Business type or direct search query |
| `geography` | Requested location |
| `scrapedAt` | UTC extraction timestamp |

### How to find businesses opening soon

1. Open the Actor input page.
2. Enter business types such as `coffee shops`, `dentists`, or `gyms`.
3. Add cities or regions under **Locations**.
4. Choose a future opening window.
5. Keep the first run small, for example 10 leads.
6. Click **Start**.
7. Review the **Opening-soon business leads** dataset view.
8. Export or connect the dataset to your workflow.

Every business type is combined with every location.

Two types and three locations produce six Maps searches.

### Input example

```json
{
  "businessTypes": ["coffee shops", "restaurants"],
  "locations": ["Austin, Texas", "Dallas, Texas"],
  "maxItems": 50,
  "openingWindowDays": 180,
  "language": "en",
  "countryCode": "us"
}
````

For one precise Maps search, use a direct URL:

```json
{
  "startUrls": [
    { "url": "https://www.google.com/maps/search/TQM+Cafe+The+Colony+Texas?hl=en&gl=us" }
  ],
  "maxItems": 5,
  "openingWindowDays": 365,
  "language": "en",
  "countryCode": "us"
}
```

### Input options

#### Business types

Use buyer-relevant category phrases.

Examples include `restaurants`, `coffee shops`, `beauty salons`, `dentists`, `gyms`, and `hotels`.

#### Locations

Cities are usually the best scanning unit.

You can also try counties, metro areas, states, regions, or countries, but broad locations may produce less complete coverage.

#### Google Maps search URLs

Only public `/maps/search/` URLs are accepted.

Place-detail URLs and unrelated Google URLs fail validation rather than silently changing scope.

#### Maximum opening-soon leads

`maxItems` is a global saved-record limit, not a candidate limit.

Profiles that fail strict opening validation do not count toward it.

#### Maximum days until opening

`openingWindowDays` must be from 1 to 730 days.

Use 90–180 days for near-term sales campaigns and 365 days for broader discovery.

#### Locale

The current date parser is intentionally strict and accepts English opening dates in these forms: `Opens Aug 1`, `Opens Sat Aug 1`, or `Opens Saturday, Aug 1, 2026`. The recognized weekday prefix and explicit year are optional; unrecognized prefixes and non-English date text are ignored.

Use `language: "en"` for reliable extraction.

### Output example

```json
{
  "placeId": "ChIJTevMhhYlTIYRd7g1P6lFzjA",
  "cid": "3516824952235210871",
  "name": "TQM CAFE",
  "categories": ["Coffee shop"],
  "fullAddress": "2851 Plano Pkwy #230, The Colony, TX 75056",
  "city": "The Colony",
  "state": "Texas",
  "postalCode": "75056",
  "countryCode": "US",
  "latitude": 33.0581513,
  "longitude": -96.8645647,
  "phone": "(972) 292-9808",
  "website": "https://tqmcafe.com/",
  "domain": "tqmcafe.com",
  "openingStatus": "OPENING_SOON",
  "openingDateText": "Opens Aug 1",
  "openingDate": "2026-08-01",
  "googleMapsUrl": "https://www.google.com/maps/preview/place/...",
  "query": "coffee shops",
  "geography": "The Colony, Texas",
  "scrapedAt": "2026-07-20T00:00:00.000Z"
}
```

Exact values can change as businesses update their profiles.

### How much does it cost to find opening-soon business leads?

This Actor uses pay-per-event pricing. A run start costs **$0.005**, then only verified dataset records are charged.

| Apify tier | Price per verified lead |
|---|---:|
| Free | $0.00073735 |
| Bronze | $0.00064117 |
| Silver | $0.00050011 |
| Gold | $0.00038470 |
| Platinum | $0.00025647 |
| Diamond | $0.00017953 |

The Apify Console shows the current live price before you start a run.

A small first run is the best way to estimate cost for your territory and categories.

### Coverage and pagination

Google Maps search results are relevance-ranked and can vary by locale, query wording, and time.

For better territory coverage:

- Split large countries into cities or metro areas.
- Use specific business categories.
- Schedule repeated scans.
- Store place IDs in your CRM for historical deduplication.
- Try related category terms rather than one broad phrase.

The Actor deduplicates records inside each run.

Cross-run historical deduplication should be handled in your destination or automation.

### Tips for higher-quality opening-soon leads

- 🎯 Use categories that match your sales offer.
- 🗺️ Prefer city-level searches over country-wide searches.
- 📅 Use a shorter opening window for urgent outreach.
- 🔁 Schedule weekly scans to catch profile changes.
- 🧩 Join by `placeId`, not business name alone.
- 📞 Treat public contact fields as leads to qualify, not guaranteed decision-maker contacts.
- 🛡️ Add an Apify proxy only if direct requests are blocked or you scale search volume.

### Scheduling and monitoring

Apify schedules can run the Actor daily, weekly, or on a custom cron expression.

A practical workflow is:

1. Run every Monday for selected cities.
2. Export place IDs and opening dates.
3. Compare against your CRM.
4. Create opportunities only for unseen place IDs.
5. Recheck dates before time-sensitive outreach.

Use webhooks to notify another system when a run finishes.

### Integrations

#### Google Sheets

Use an Apify integration or Make to append verified leads to a territory sheet.

#### HubSpot or Salesforce

Map `placeId` to an external ID, website domain to company domain, and opening date to a custom field.

#### Make and Zapier

Trigger qualification, enrichment, routing, or notification steps from new dataset records.

#### Slack and email alerts

Send a digest when new opening-soon profiles appear in a priority city.

#### Data warehouses

Load dataset exports into BigQuery, Snowflake, or PostgreSQL for trend and expansion analysis.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/soon-to-open-businesses-leads-scraper').call({
  businessTypes: ['coffee shops'],
  locations: ['Austin, Texas'],
  maxItems: 25,
  openingWindowDays: 180,
  language: 'en',
  countryCode: 'us'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/soon-to-open-businesses-leads-scraper').call(run_input={
    'businessTypes': ['dentists'],
    'locations': ['Phoenix, Arizona'],
    'maxItems': 25,
    'openingWindowDays': 365,
    'language': 'en',
    'countryCode': 'us',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~soon-to-open-businesses-leads-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "businessTypes": ["gyms"],
    "locations": ["Miami, Florida"],
    "maxItems": 25,
    "openingWindowDays": 180,
    "language": "en",
    "countryCode": "us"
  }'
```

Fetch results from the run's `defaultDatasetId` after it succeeds.

### Use with Apify MCP and AI agents

#### Claude Code setup

```bash
claude mcp add --transport http apify 'https://mcp.apify.com?tools=automation-lab/soon-to-open-businesses-leads-scraper'
```

#### Claude Desktop and Cursor setup

Add this server to the Claude Desktop or Cursor `mcpServers` configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/soon-to-open-businesses-leads-scraper"
    }
  }
}
```

#### VS Code setup

Add the same HTTP URL to your VS Code MCP server configuration and label it `apify`.

Example prompts:

- “Find coffee shops opening in Austin during the next 180 days.”
- “Scan Dallas and Fort Worth for opening-soon gyms and return phone, website, and Maps URL.”
- “Create a weekly multi-city restaurant opening lead workflow.”

### Data quality and validation

The Actor deliberately favors precision over recall.

A relevant query match without a structured opening code and a future date is excluded.

An unparseable date is excluded.

A date outside your opening window is excluded.

Duplicates in multiple category or location searches are excluded.

No result can also be a valid outcome when Maps has no explicit future-opening records for the chosen input.

### Limitations

- Google Maps is an undocumented source and can change its internal response layout.
- Search results are ranked, not a guaranteed complete census.
- English date text is currently required.
- Website, phone, and address fields depend on what the profile publishes.
- Email and social-link enrichment are not included in the minimum product.
- One run does not provide historical “first seen” or publication dates.
- Google can throttle requests; optional proxies and narrower query batches can help.

### Responsible use and legality

This Actor extracts publicly displayed business information.

You are responsible for complying with applicable law, Google terms, privacy requirements, and outreach regulations.

Use the data for legitimate business purposes.

Do not send deceptive, discriminatory, or unlawful messages.

Respect opt-outs and suppression lists.

Reverify time-sensitive opening dates before acting on them.

### Troubleshooting

#### Why did my run return zero leads?

The Actor only saves profiles with explicit structured future dates.

Try a larger city, another category, or a wider opening window.

Zero results can be correct for a sparse geography.

#### Why was an ordinary business excluded?

Appearing in an “opening soon” search is not proof of opening status.

The strict filter rejects generic relevance matches.

#### Why did every search fail?

Google may have throttled the connection or changed its response.

Try an Apify proxy, fewer search combinations, or retry later.

#### Why does a direct URL fail validation?

Only Google Maps `/maps/search/` URLs are accepted.

Use a search URL rather than a place-detail or directions URL.

#### Why is the opening date different later?

Business owners can update or postpone profile dates.

Treat every extraction as a timestamped snapshot.

### FAQ

#### Does this scraper find recently opened businesses?

The current contract focuses on explicit future openings.

It does not infer “recently opened” from reviews or vague marketing text.

#### Does it extract email addresses?

No. It returns Maps-native phone and website fields.

You can pass website domains to a separate authorized enrichment workflow.

#### Can I scan several cities at once?

Yes. Add multiple locations and categories; the Actor searches their cross-product.

#### Can I export to Excel?

Yes. Open the dataset and choose Excel, CSV, JSON, XML, or another supported format.

#### Can I run it every week?

Yes. Create an Apify schedule and connect the resulting dataset to your CRM or automation.

#### Are duplicate businesses removed?

Yes, inside a run. Place ID and CID are preferred deduplication keys.

### Related Automation Lab actors

Combine this focused workflow with other public-data tools when your project requires broader coverage:

- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) for general local business discovery.
- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) for broader Maps profile extraction.
- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper) for public review analysis.
- [Google Business Profile Posts Scraper](https://apify.com/automation-lab/google-business-profile-posts-scraper) for profile update monitoring.

Choose this Actor when the decisive requirement is a verified future opening date.

### Start finding future customers

Begin with one category, one city, and 10 records.

Review the output quality, then expand territories and schedule repeat scans.

Opening-soon data is sparse by nature, but each verified record can be a high-value, time-sensitive sales opportunity.

# Actor input Schema

## `businessTypes` (type: `array`):

Categories or business types to search, such as coffee shops, dentists, or gyms.

## `locations` (type: `array`):

Cities, regions, or countries. Every business type is searched in every location.

## `startUrls` (type: `array`):

Optional public Google Maps /maps/search/ URLs. These can be used with or instead of business types and locations.

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

Stop after saving this many strictly verified opening-soon profiles.

## `openingWindowDays` (type: `integer`):

Only retain explicit future dates within this many days.

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

Two-letter language code. English is recommended because opening-date parsing is strict.

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

Two-letter country code used to localize Maps results.

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

Optional Apify Proxy or custom proxies for blocked or high-volume searches.

## Actor input object example

```json
{
  "businessTypes": [
    "TQM Cafe"
  ],
  "locations": [
    "The Colony, Texas"
  ],
  "maxItems": 10,
  "openingWindowDays": 365,
  "language": "en",
  "countryCode": "us"
}
```

# Actor output Schema

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

Verified opening-soon leads with contact, location, date, and source fields.

# 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 = {
    "businessTypes": [
        "TQM Cafe"
    ],
    "locations": [
        "The Colony, Texas"
    ],
    "maxItems": 10,
    "openingWindowDays": 365,
    "language": "en",
    "countryCode": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/soon-to-open-businesses-leads-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 = {
    "businessTypes": ["TQM Cafe"],
    "locations": ["The Colony, Texas"],
    "maxItems": 10,
    "openingWindowDays": 365,
    "language": "en",
    "countryCode": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/soon-to-open-businesses-leads-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 '{
  "businessTypes": [
    "TQM Cafe"
  ],
  "locations": [
    "The Colony, Texas"
  ],
  "maxItems": 10,
  "openingWindowDays": 365,
  "language": "en",
  "countryCode": "us"
}' |
apify call automation-lab/soon-to-open-businesses-leads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/soon-to-open-businesses-leads-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Soon-to-Open Businesses Leads Scraper",
        "description": "🚀 Find local businesses before they open. Scan Google Maps by category and city, verify explicit future opening dates, and export CRM-ready contact and location leads.",
        "version": "0.1",
        "x-build-id": "QLsC1fdJOplT4513r"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~soon-to-open-businesses-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-soon-to-open-businesses-leads-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/automation-lab~soon-to-open-businesses-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-soon-to-open-businesses-leads-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/automation-lab~soon-to-open-businesses-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-soon-to-open-businesses-leads-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",
                "properties": {
                    "businessTypes": {
                        "title": "🔎 Business types",
                        "type": "array",
                        "description": "Categories or business types to search, such as coffee shops, dentists, or gyms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "📍 Locations",
                        "type": "array",
                        "description": "Cities, regions, or countries. Every business type is searched in every location.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Google Maps search URLs",
                        "type": "array",
                        "description": "Optional public Google Maps /maps/search/ URLs. These can be used with or instead of business types and locations.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum opening-soon leads",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after saving this many strictly verified opening-soon profiles.",
                        "default": 50
                    },
                    "openingWindowDays": {
                        "title": "Maximum days until opening",
                        "minimum": 1,
                        "maximum": 730,
                        "type": "integer",
                        "description": "Only retain explicit future dates within this many days.",
                        "default": 365
                    },
                    "language": {
                        "title": "Google language code",
                        "type": "string",
                        "description": "Two-letter language code. English is recommended because opening-date parsing is strict.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Google country code",
                        "type": "string",
                        "description": "Two-letter country code used to localize Maps results.",
                        "default": "us"
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy or custom proxies for blocked or high-volume searches."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```