# No-Website Business Leads Scraper (Google Maps) (`leafy-dev-jr/no-website-business-leads-scraper-google-maps`) Actor

Find businesses with weak or missing websites on Google Maps — a priority-ranked lead generation list for website developers and designers

- **URL**: https://apify.com/leafy-dev-jr/no-website-business-leads-scraper-google-maps.md
- **Developed by:** [Leafy](https://apify.com/leafy-dev-jr) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 10 total users, 7 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## No-Website Business Leads Scraper (Google Maps)

**Find local businesses with weak or missing websites — and get a ready-to-pitch, priority-ranked outreach list, straight from any Google Maps search.**

Point it at a business type and a city. Walk away with every matching business, each one tagged with how strong (or weak) its web presence is and the exact reason to reach out — so you spend your time pitching, not scrolling Maps and opening 80 tabs to see which sites actually load.

Built for web design agencies, freelance developers, and local SEO consultants.

---

### Why it beats a generic Maps scraper

A normal Google Maps scraper dumps every business and leaves you to figure out who's worth contacting. This one does the qualifying for you:

- ✅ **Filters by web presence, not just contact info** — it actually fetches each website and checks whether it's missing, social-only, a directory link, broken, outdated, or healthy.
- ✅ **Ranks every lead HIGH → MEDIUM → LOW** so you work the hottest prospects first.
- ✅ **Tells you _why_** each business is a lead in plain English — drop it straight into your cold-email merge fields.

---

### What you get

One row per business. Export to CSV / JSON / Excel, or pipe straight into Instantly, Smartlead, Apollo, HubSpot, or Pipedrive.

```json
{
    "businessName": "Bayshore Cuts & Color",
    "address": "123 Bayshore Blvd, Tampa, FL 33606",
    "phone": "(813) 555-0100",
    "googleMapsUrl": "https://www.google.com/maps/place/Bayshore+Cuts+%26+Color/...",
    "websiteUrl": "https://www.facebook.com/bayshorecuts",
    "category": "Hair salon",
    "rating": 4.8,
    "reviewCount": 312,
    "websiteType": "SOCIAL",
    "ssl": null,
    "pageSpeedScore": null,
    "isMobileResponsive": null,
    "siteLoads": null,
    "webPresenceCategory": "SOCIAL_ONLY",
    "outreachPriority": "HIGH",
    "outreachReason": "Website field links to a social profile only (https://www.facebook.com/bayshorecuts)"
}
````

***

### The 6 categories

Every business gets exactly one `webPresenceCategory`, based on **deterministic** signals. Anything we genuinely can't verify defaults to `HEALTHY`, so we never mislabel a real customer's healthy site as a lead.

| Category | What it means | Priority |
|---|---|---|
| `NO_WEBSITE` | No website on the listing, **or** the domain is parked / for sale | HIGH |
| `SOCIAL_ONLY` | "Website" links to Facebook, Instagram, TikTok, LinkedIn, etc. | HIGH |
| `DIRECTORY_ONLY` | "Website" links to Yelp, Yellow Pages, Houzz, BBB, etc. | HIGH |
| `WEBSITE_UNREACHABLE` | A real domain is listed but it didn't load — timed out, refused, or errored | MEDIUM |
| `OUTDATED_WEBSITE` | Real site that loads, but missing **SSL** or **mobile viewport** | MEDIUM |
| `HEALTHY` | Loads with SSL + mobile viewport | LOW |

**Priority at a glance:**

- **HIGH** — no real website to speak of (`NO_WEBSITE`, `SOCIAL_ONLY`, `DIRECTORY_ONLY`). Your strongest pitch.
- **MEDIUM** — a site exists but there's a clear problem to lead with (`WEBSITE_UNREACHABLE`, `OUTDATED_WEBSITE`).
- **LOW** — modern, working site (`HEALTHY`). Probably not your lead — kept in the dataset so you can decide.

The raw `pageSpeedScore` is included for advanced filtering (e.g. "HEALTHY businesses scoring under 60"), but it never drives the category, because Lighthouse scores swing ±5–10 points run-to-run.

***

### How it works

1. Searches Google Maps for `{businessType} in {neighborhood, city, country}`.
2. Harvests every business in the results panel, up to your `maxResults`.
3. Opens each listing and pulls name, address, phone, category, rating, reviews, and the website link.
4. Fetches each website and audits it — reachability, SSL, mobile viewport, and (optionally) PageSpeed.
5. Categorizes, prioritizes, and writes the row to the dataset.

***

### Input

```json
{
    "businessType": "coffee shops",
    "country": "PH",
    "city": "Manila",
    "neighborhood": "Pureza, Santa Mesa",
    "maxResults": 50,
    "onlyNoOrWeakWebsite": false,
    "pageSpeedApiKey": "AIzaSy...",
    "maxConcurrency": 5,
    "mapsConcurrency": 3,
    "useProxy": false
}
```

| Field | Type | Required | Default | What it does |
|---|---|---|---|---|
| `businessType` | string | yes | — | What to search for. Examples: `"coffee shops"`, `"plumbers"`, `"hair salons"` |
| `country` | string | yes | `US` | Pick from the country dropdown. Added to the search query, and used as the proxy country if proxy is on. Choose the **country, not a state** — `US` for Florida, then put `"Tampa FL"` in `city`. |
| `city` | string | yes | — | City or town. Examples: `"Tampa FL"`, `"Manila"`, `"London"` |
| `neighborhood` | string | no | — | Narrow to a district or zip. Useful for big cities where Maps caps at ~120 results per area. |
| `maxResults` | int | no | `50` | 1–200 |
| `onlyNoOrWeakWebsite` | bool | no | `false` | When on, returns only businesses worth pitching — no website, social/directory-only, outdated, or unreachable (HIGH + MEDIUM). Skips healthy sites (LOW). Off returns everything. |
| `pageSpeedApiKey` | string | no | — | Free Google PageSpeed Insights v5 key. Adds `pageSpeedScore` to every record. |
| `maxConcurrency` | int | no | `5` | Parallel website checks (1–20) |
| `mapsConcurrency` | int | no | `3` | Parallel Google Maps detail-page extractions (1–8) |
| `useProxy` | bool | no | `false` | Off uses Apify's IP — fastest, and fine for most searches. Turn on only if you hit blocks/captchas or need strict same-country routing — it's slower. |

***

### Output fields

Every record contains every field below. Nullable fields are `null` when not applicable (e.g. `ssl` is `null` for `NO_WEBSITE` records).

| Field | Type | Description |
|---|---|---|
| `businessName` | string | From the Google Maps listing |
| `address` | string | null | Full street address |
| `phone` | string | null | Phone number as listed |
| `googleMapsUrl` | string | Direct link to the listing |
| `websiteUrl` | string | null | Final URL after following redirects |
| `category` | string | null | Google's category label (e.g. `"Hair salon"`) |
| `rating` | number | null | Star rating |
| `reviewCount` | int | null | Number of reviews |
| `websiteType` | enum | `NONE` | `REAL` | `SOCIAL` | `DIRECTORY` | `DEAD` | `PARKED` |
| `ssl` | bool | null | True if final URL is HTTPS |
| `pageSpeedScore` | int | null | Mobile Lighthouse score 0–100 (only with an API key) |
| `isMobileResponsive` | bool | null | True if the HTML contains a viewport meta tag |
| `siteLoads` | bool | null | True if the URL responded 2xx/3xx within 10s |
| `webPresenceCategory` | enum | One of the 6 categories above |
| `outreachPriority` | enum | `HIGH` | `MEDIUM` | `LOW` |
| `outreachReason` | string | One-line plain-English explanation |

***

### Sample output

Five rows showing each priority band (illustrative data):

```json
[
    {
        "businessName": "Westshore Cuts",
        "address": "456 Kennedy Blvd, Tampa, FL 33609",
        "phone": "(813) 555-0142",
        "googleMapsUrl": "https://www.google.com/maps/place/Westshore+Cuts/...",
        "websiteUrl": null,
        "category": "Hair salon",
        "rating": 4.5,
        "reviewCount": 89,
        "websiteType": "NONE",
        "ssl": null,
        "pageSpeedScore": null,
        "isMobileResponsive": null,
        "siteLoads": null,
        "webPresenceCategory": "NO_WEBSITE",
        "outreachPriority": "HIGH",
        "outreachReason": "No website listed on Google Maps"
    },
    {
        "businessName": "Bayshore Cuts & Color",
        "address": "123 Bayshore Blvd, Tampa, FL 33606",
        "phone": "(813) 555-0100",
        "googleMapsUrl": "https://www.google.com/maps/place/Bayshore+Cuts+%26+Color/...",
        "websiteUrl": "https://www.facebook.com/bayshorecuts",
        "category": "Hair salon",
        "rating": 4.8,
        "reviewCount": 312,
        "websiteType": "SOCIAL",
        "ssl": null,
        "pageSpeedScore": null,
        "isMobileResponsive": null,
        "siteLoads": null,
        "webPresenceCategory": "SOCIAL_ONLY",
        "outreachPriority": "HIGH",
        "outreachReason": "Website field links to a social profile only (https://www.facebook.com/bayshorecuts)"
    },
    {
        "businessName": "Old Town Barber",
        "address": "789 7th Ave, Tampa, FL 33605",
        "phone": "(813) 555-0177",
        "googleMapsUrl": "https://www.google.com/maps/place/Old+Town+Barber/...",
        "websiteUrl": "http://oldtownbarbertampa.com/",
        "category": "Barber shop",
        "rating": 4.6,
        "reviewCount": 64,
        "websiteType": "REAL",
        "ssl": false,
        "pageSpeedScore": 42,
        "isMobileResponsive": false,
        "siteLoads": true,
        "webPresenceCategory": "OUTDATED_WEBSITE",
        "outreachPriority": "MEDIUM",
        "outreachReason": "Website loads but no SSL (still on HTTP) and no mobile viewport meta tag"
    },
    {
        "businessName": "Hair on Howard",
        "address": "321 Howard Ave, Tampa, FL 33606",
        "phone": "(813) 555-0123",
        "googleMapsUrl": "https://www.google.com/maps/place/Hair+on+Howard/...",
        "websiteUrl": "https://haironhoward.com/",
        "category": "Hair salon",
        "rating": 4.7,
        "reviewCount": 215,
        "websiteType": "DEAD",
        "ssl": null,
        "pageSpeedScore": null,
        "isMobileResponsive": null,
        "siteLoads": false,
        "webPresenceCategory": "WEBSITE_UNREACHABLE",
        "outreachPriority": "MEDIUM",
        "outreachReason": "Website is listed but did not load (timed out, refused, or errored) — a strong pitch, but verify by hand: it may just be slow or blocking automated checks"
    },
    {
        "businessName": "SoHo Salon Tampa",
        "address": "654 Howard Ave, Tampa, FL 33606",
        "phone": "(813) 555-0188",
        "googleMapsUrl": "https://www.google.com/maps/place/SoHo+Salon+Tampa/...",
        "websiteUrl": "https://www.sohosalontampa.com/",
        "category": "Beauty salon",
        "rating": 4.9,
        "reviewCount": 1204,
        "websiteType": "REAL",
        "ssl": true,
        "pageSpeedScore": 91,
        "isMobileResponsive": true,
        "siteLoads": true,
        "webPresenceCategory": "HEALTHY",
        "outreachPriority": "LOW",
        "outreachReason": "Website loads with SSL and mobile viewport (PageSpeed mobile score 91/100)"
    }
]
```

***

### How fast and how big

- **Typical run:** ~30–50 qualified leads in a couple of minutes. Results stream in as they're found, so you don't wait for the whole run to see data.
- **Per-search cap:** Google Maps returns ~120 results per search area. For more, run the same query across several `neighborhood` values and merge the datasets.
- **Cost scales with `maxResults`.** Proxy off (the default) is the fastest and lightest option; only turn it on if you actually get blocked.

***

### FAQ

**How many businesses can I get per run?**
Up to `maxResults` (max 200), but Google Maps itself caps a single search area at ~120. Use the `neighborhood` field to cover a big city district-by-district.

**Can I get only the businesses that need a website?**
Yes — turn on `onlyNoOrWeakWebsite`. The output is then limited to HIGH + MEDIUM leads (no site, social/directory-only, outdated, or unreachable) and skips healthy sites. It's off by default so you get the full picture. Every business is still scraped and audited; the toggle only filters what's saved.

**The filter is on and I got 0 results — is it broken?**
No. It means every business found in that search already has a healthy website, so none matched the filter. The run's status message says exactly that. Turn `onlyNoOrWeakWebsite` off to see the full list, or widen the search area.

**Do I need a proxy?**
No — it's off by default and works for most searches, because the location comes from your query text, not your IP. Turn `useProxy` on only if you start seeing blocks/captchas or need strict same-country routing. It's slower.

**Do I need the PageSpeed API key?**
No. Without it you still get every category and priority — you just don't get the numeric `pageSpeedScore`. The key is free (25,000 requests/day); setup is below.

**The results aren't pre-sorted — why?**
Rows are written the instant each business is processed, so you see progress live. Every row carries `outreachPriority`, so sort or filter on that column in your spreadsheet/CRM in one click.

**A business is marked `HEALTHY` but I think its site is bad — why?**
Categories use conservative, deterministic signals (SSL + mobile viewport + reachability). If a site is reachable and technically modern, it's `HEALTHY` even if it's ugly. Use `pageSpeedScore` to find slow-but-healthy sites worth a redesign pitch.

**Is this allowed?**
It collects publicly visible business-listing information. You're responsible for using the data in line with applicable laws and platform terms — including marketing/anti-spam rules (e.g. CAN-SPAM, GDPR) when you run outreach.

***

### Get a free PageSpeed API key (optional, 1 minute)

Adds the raw mobile Lighthouse score to every record — great for fine-grained sorting. Free, 25,000 requests/day.

1. Go to **[console.cloud.google.com](https://console.cloud.google.com)** and create a project.
2. **APIs & Services → Library → "PageSpeed Insights API" → Enable.**
3. **Credentials → Create credentials → API key.** Copy it.
4. Paste it into the `pageSpeedApiKey` input field.

***

### Use cases

- Web design agencies building targeted cold-outreach lists
- Freelance developers who want HIGH-priority leads on tap
- Local SEO consultants filtering by technical signal (`OUTDATED_WEBSITE`, low PageSpeed)
- Cold-email tools — pipe directly into Instantly, Smartlead, or Apollo
- CRM enrichment — augment HubSpot / Pipedrive with a current web-presence signal
- Niche research — find categories where most local businesses are still offline

***

### Limitations

- Google Maps caps results at ~120 per search area. For bigger pulls, split by `neighborhood` and merge.
- Lighthouse scores fluctuate ±5–10 points between runs — that's why they don't drive categorization.
- Selectors can shift when Google A/B tests new layouts. The actor logs a one-time *selector audit* on the first place per run, so you see immediately if any field went null.
- A site that fails to load is labeled `WEBSITE_UNREACHABLE` (MEDIUM), not HIGH — a plain fetch can be fooled by slow servers or bot-blocking, so treat it as "worth a manual look," not a guaranteed dead site. Anything we genuinely can't verify still defaults to `HEALTHY`, so real customers' sites aren't mislabeled.

***

# Actor input Schema

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

What kind of business to search for. Examples: 'coffee shops', 'plumbers', 'hair salons', 'dentists'.

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

Country to search in. Its name is added to the search query, and — if you enable residential proxies below — it selects the proxy country. Pick from the list (start typing to filter). Use the country, not a state: for Florida choose United States, then put 'Tampa FL' in the City field.

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

City or town. Examples: 'Tampa FL', 'Manila', 'London'.

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

Optional — narrow the search to a specific neighborhood, district, or zip code. Examples: 'Lincoln Park', 'Pureza, Santa Mesa', '94110'. Useful for big cities where Maps caps results at ~120 per area.

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

Maximum number of businesses to scrape and process. Google Maps caps results at ~120 per search area.

## `onlyNoOrWeakWebsite` (type: `boolean`):

When on, the output is limited to businesses worth pitching — no website, a social-only or directory-only link, or a site that's outdated or unreachable (HIGH + MEDIUM priority). Businesses with a healthy, modern site (LOW) are skipped. Off by default, so you get every business. Note: every business is still scraped and audited; this only filters what's saved to the dataset.

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

Free Google API key. Get one at console.cloud.google.com → enable PageSpeed Insights API → create API key. Free tier is 25,000 requests/day. If omitted, PageSpeed score is not measured (categorization still works).

## `maxConcurrency` (type: `integer`):

How many business websites to check in parallel. Keep low (3–5) to avoid rate limiting and PageSpeed quota errors.

## `mapsConcurrency` (type: `integer`):

How many Google Maps detail pages to extract in parallel. Higher = faster but more proxy bandwidth and CPU.

## `useProxy` (type: `boolean`):

Off (default): fastest — uses Apify's IP. Fine for most searches, and results stay localized because the location is part of the search query. On: routes Google Maps traffic through residential proxies in the country set above. Enable only if you start hitting blocks/captchas or need strict same-country routing — it is noticeably slower.

## Actor input object example

```json
{
  "businessType": "hair salons",
  "country": "US",
  "city": "Tampa FL",
  "maxResults": 50,
  "onlyNoOrWeakWebsite": false,
  "maxConcurrency": 5,
  "mapsConcurrency": 3,
  "useProxy": false
}
```

# Actor output Schema

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

Every business with its web-presence category, outreach priority, and the reason it's a lead.

# 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 = {
    "businessType": "hair salons",
    "city": "Tampa FL"
};

// Run the Actor and wait for it to finish
const run = await client.actor("leafy-dev-jr/no-website-business-leads-scraper-google-maps").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 = {
    "businessType": "hair salons",
    "city": "Tampa FL",
}

# Run the Actor and wait for it to finish
run = client.actor("leafy-dev-jr/no-website-business-leads-scraper-google-maps").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 '{
  "businessType": "hair salons",
  "city": "Tampa FL"
}' |
apify call leafy-dev-jr/no-website-business-leads-scraper-google-maps --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=leafy-dev-jr/no-website-business-leads-scraper-google-maps",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "No-Website Business Leads Scraper (Google Maps)",
        "description": "Find businesses with weak or missing websites on Google Maps — a priority-ranked lead generation list for website developers and designers",
        "version": "0.2",
        "x-build-id": "UmL7zOp5FFOfrIpec"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/leafy-dev-jr~no-website-business-leads-scraper-google-maps/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-leafy-dev-jr-no-website-business-leads-scraper-google-maps",
                "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/leafy-dev-jr~no-website-business-leads-scraper-google-maps/runs": {
            "post": {
                "operationId": "runs-sync-leafy-dev-jr-no-website-business-leads-scraper-google-maps",
                "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/leafy-dev-jr~no-website-business-leads-scraper-google-maps/run-sync": {
            "post": {
                "operationId": "run-sync-leafy-dev-jr-no-website-business-leads-scraper-google-maps",
                "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": [
                    "businessType",
                    "country",
                    "city"
                ],
                "properties": {
                    "businessType": {
                        "title": "Business type",
                        "type": "string",
                        "description": "What kind of business to search for. Examples: 'coffee shops', 'plumbers', 'hair salons', 'dentists'."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "PH",
                            "IN",
                            "IE",
                            "NZ",
                            "SG",
                            "AE",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "BR",
                            "MX",
                            "JP",
                            "ZA",
                            "AD",
                            "AF",
                            "AG",
                            "AI",
                            "AL",
                            "AM",
                            "AO",
                            "AQ",
                            "AR",
                            "AS",
                            "AT",
                            "AW",
                            "AX",
                            "AZ",
                            "BA",
                            "BB",
                            "BD",
                            "BE",
                            "BF",
                            "BG",
                            "BH",
                            "BI",
                            "BJ",
                            "BL",
                            "BM",
                            "BN",
                            "BO",
                            "BQ",
                            "BS",
                            "BT",
                            "BV",
                            "BW",
                            "BY",
                            "BZ",
                            "CC",
                            "CD",
                            "CF",
                            "CG",
                            "CH",
                            "CI",
                            "CK",
                            "CL",
                            "CM",
                            "CN",
                            "CO",
                            "CR",
                            "CU",
                            "CV",
                            "CW",
                            "CX",
                            "CY",
                            "CZ",
                            "DJ",
                            "DK",
                            "DM",
                            "DO",
                            "DZ",
                            "EC",
                            "EE",
                            "EG",
                            "EH",
                            "ER",
                            "ET",
                            "FI",
                            "FJ",
                            "FK",
                            "FM",
                            "FO",
                            "GA",
                            "GD",
                            "GE",
                            "GF",
                            "GG",
                            "GH",
                            "GI",
                            "GL",
                            "GM",
                            "GN",
                            "GP",
                            "GQ",
                            "GR",
                            "GS",
                            "GT",
                            "GU",
                            "GW",
                            "GY",
                            "HK",
                            "HM",
                            "HN",
                            "HR",
                            "HT",
                            "HU",
                            "ID",
                            "IL",
                            "IM",
                            "IO",
                            "IQ",
                            "IR",
                            "IS",
                            "JE",
                            "JM",
                            "JO",
                            "KE",
                            "KG",
                            "KH",
                            "KI",
                            "KM",
                            "KN",
                            "KP",
                            "KR",
                            "KW",
                            "KY",
                            "KZ",
                            "LA",
                            "LB",
                            "LC",
                            "LI",
                            "LK",
                            "LR",
                            "LS",
                            "LT",
                            "LU",
                            "LV",
                            "LY",
                            "MA",
                            "MC",
                            "MD",
                            "ME",
                            "MF",
                            "MG",
                            "MH",
                            "MK",
                            "ML",
                            "MM",
                            "MN",
                            "MO",
                            "MP",
                            "MQ",
                            "MR",
                            "MS",
                            "MT",
                            "MU",
                            "MV",
                            "MW",
                            "MY",
                            "MZ",
                            "NA",
                            "NC",
                            "NE",
                            "NF",
                            "NG",
                            "NI",
                            "NO",
                            "NP",
                            "NR",
                            "NU",
                            "OM",
                            "PA",
                            "PE",
                            "PF",
                            "PG",
                            "PK",
                            "PL",
                            "PM",
                            "PN",
                            "PR",
                            "PS",
                            "PT",
                            "PW",
                            "PY",
                            "QA",
                            "RE",
                            "RO",
                            "RS",
                            "RU",
                            "RW",
                            "SA",
                            "SB",
                            "SC",
                            "SD",
                            "SE",
                            "SH",
                            "SI",
                            "SJ",
                            "SK",
                            "SL",
                            "SM",
                            "SN",
                            "SO",
                            "SR",
                            "SS",
                            "ST",
                            "SV",
                            "SX",
                            "SY",
                            "SZ",
                            "TC",
                            "TD",
                            "TF",
                            "TG",
                            "TH",
                            "TJ",
                            "TK",
                            "TL",
                            "TM",
                            "TN",
                            "TO",
                            "TR",
                            "TT",
                            "TV",
                            "TW",
                            "TZ",
                            "UA",
                            "UG",
                            "UM",
                            "UY",
                            "UZ",
                            "VA",
                            "VC",
                            "VE",
                            "VG",
                            "VI",
                            "VN",
                            "VU",
                            "WF",
                            "WS",
                            "XK",
                            "YE",
                            "YT",
                            "ZM",
                            "ZW"
                        ],
                        "type": "string",
                        "description": "Country to search in. Its name is added to the search query, and — if you enable residential proxies below — it selects the proxy country. Pick from the list (start typing to filter). Use the country, not a state: for Florida choose United States, then put 'Tampa FL' in the City field.",
                        "default": "US"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City or town. Examples: 'Tampa FL', 'Manila', 'London'."
                    },
                    "neighborhood": {
                        "title": "Neighborhood (optional)",
                        "type": "string",
                        "description": "Optional — narrow the search to a specific neighborhood, district, or zip code. Examples: 'Lincoln Park', 'Pureza, Santa Mesa', '94110'. Useful for big cities where Maps caps results at ~120 per area."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of businesses to scrape and process. Google Maps caps results at ~120 per search area.",
                        "default": 50
                    },
                    "onlyNoOrWeakWebsite": {
                        "title": "Only businesses with no or weak website",
                        "type": "boolean",
                        "description": "When on, the output is limited to businesses worth pitching — no website, a social-only or directory-only link, or a site that's outdated or unreachable (HIGH + MEDIUM priority). Businesses with a healthy, modern site (LOW) are skipped. Off by default, so you get every business. Note: every business is still scraped and audited; this only filters what's saved to the dataset.",
                        "default": false
                    },
                    "pageSpeedApiKey": {
                        "title": "Google PageSpeed Insights API key (optional)",
                        "type": "string",
                        "description": "Free Google API key. Get one at console.cloud.google.com → enable PageSpeed Insights API → create API key. Free tier is 25,000 requests/day. If omitted, PageSpeed score is not measured (categorization still works)."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent website checks",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many business websites to check in parallel. Keep low (3–5) to avoid rate limiting and PageSpeed quota errors.",
                        "default": 5
                    },
                    "mapsConcurrency": {
                        "title": "Max concurrent Google Maps place pages",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many Google Maps detail pages to extract in parallel. Higher = faster but more proxy bandwidth and CPU.",
                        "default": 3
                    },
                    "useProxy": {
                        "title": "Route through residential proxies",
                        "type": "boolean",
                        "description": "Off (default): fastest — uses Apify's IP. Fine for most searches, and results stay localized because the location is part of the search query. On: routes Google Maps traffic through residential proxies in the country set above. Enable only if you start hitting blocks/captchas or need strict same-country routing — it is noticeably slower.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
