# Google Maps Business Without Websites Leads Scraper (`lurkapi/google-maps-business-without-websites-leads-scraper`) Actor

Find local businesses on Google Maps without a website. Every row includes phone + address + optional social profiles (Facebook, Instagram, LinkedIn, Yelp, and 5 more). Ready-to-pitch leads for web agencies, SEO consultants, and cold outreach.

- **URL**: https://apify.com/lurkapi/google-maps-business-without-websites-leads-scraper.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Agents, Automation, Lead generation
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.69 / 1,000 place scrapeds

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 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/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

## Google Maps Business Without Websites Leads Scraper

Find local businesses on Google Maps that do not have a website. Every row is a phone number, an address, and optionally Facebook, Instagram, LinkedIn, Yelp, and six more social profiles. Ready-to-pitch lead lists for web design agencies, SEO consultants, marketing agencies, and cold outreach teams. Any keyword, any city, worldwide.

### 🎯 What it does

Give it a search keyword and a location, and it will:

1. **Search Google Maps** for matching businesses (barber shops, plumbers, restaurants, anything you can search for).
2. **Keep only listings without a website** on their Google Maps profile. Businesses that already have a site are dropped automatically, so every row is a real prospect.
3. **Pull the public details** Google shows: business name, phone, address, category, rating, review count, opening hours, coordinates, price range, photos, and more.
4. **(Recommended add-on)** Find Facebook, Instagram, LinkedIn, Yelp, TikTok, YouTube, and 3 more social profiles per business. Turns a phone-only lead into a multi-channel outreach target.
5. **Return everything** as a clean dataset you can export to CSV, Excel, JSON, or push straight into your CRM.

### 📋 How to use it

#### Step 1: Configure input

- **Search terms**: One keyword per line. Example: `barber shop`, `plumber`, `food truck`.
- **Location**: City, region, or country. Example: `Austin, TX`, `London, UK`, `France`. Broad regions like a whole state or country are supported.
- **Max places per search term**: Cap how many no-website places to keep per keyword. Google itself caps results per single query at about 120, but broad regions can go far above that.

Optional:

- **Google Maps URLs**: Paste search or place URLs directly instead of using the keyword field. Any listing that turns out to have a website is dropped with a clear status message.
- **Place IDs to skip**: Paste IDs you already collected on previous runs. Skipped without charge, so you never pay for the same lead twice.
- **Geo filters**: Restrict to a circle around a coordinate (`{lat, lng, radiusMiles}`) or a custom polygon.
- **Quality filters**: Minimum rating, minimum review count, only currently-open businesses. Filtered places are not charged.
- **Add-ons**: Social profiles & Yelp discovery (recommended), company registry enrichment, legal-entity resolution, and free lead scoring (details below).
- **Output fields**: Toggle each field on or off to shrink row size for large exports.

#### Step 2: Run it

Click **Start** and wait. Results stream into the Output tab as each search term finishes, so you can start using the data before the whole run is done.

#### Step 3: Get your results

Open the **Output** tab. Each row is one no-website business.

Key fields:

| Field | What it is |
|---|---|
| `status` | Always present. `Success` on a clean row, or a human-readable message explaining why a listing was skipped (for example, it turned out to have a website). |
| `placeId` | Google's permanent identifier for the business. Use this to dedupe across runs. |
| `title`, `category`, `categories` | Business name and Google category. |
| `address`, `city`, `state`, `country`, `postalCode` | Full address broken out by component. |
| `latitude`, `longitude` | Coordinates in decimal degrees. |
| `phone` | Phone number listed on the Google Maps profile, in clean E.164 format. |
| `rating`, `reviewCount`, `priceRange` | Quality and pricing signals. |
| `openingHours`, `popularTimes`, `currentStatus`, `permanentlyClosed` | When the business is open and how busy it typically gets. |
| `description`, `mainImage`, `images` | Editorial description and photos. |
| `serviceOptions`, `additionalInfo`, `menu`, `reservations`, `orderOnline` | Service and booking details when the business publishes them. |
| `googleMapsUrl` | Direct link to the listing on Google Maps. |
| `facebook`, `instagram`, `linkedin`, `twitter`, `tiktok`, `youtube`, `pinterest`, `discord`, `yelp` | Social profile and Yelp URLs when the Social Profiles add-on is enabled. |
| `leadScore` | 0 to 100 score for each lead when the Lead Scoring add-on is enabled. |
| Registry fields | Registration number, legal status, incorporation date, registered address, and IDs like EIN or SIREN when the Registry add-on is enabled. |
| `legalEntity` | The legal company behind the trade name when the Legal Entity add-on is enabled. |

### 🤖 Use it from AI clients (MCP)

Call this tool from Claude Code, Claude Desktop, Codex, Cursor, and any other client that speaks the Model Context Protocol. Once configured, prompt in plain English, for example *"Find 50 barber shops in Austin without a website"*, and your assistant runs the scraper and returns the results.

Every example below needs an `APIFY_TOKEN`. Grab one from [console.apify.com/settings/integrations](https://console.apify.com/settings/integrations).

**Claude Code**

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server \
  --actors lurkapi/google-maps-business-without-websites-leads-scraper
````

Then export the token in the same shell: `export APIFY_TOKEN=your-token`.

**Claude Desktop**

Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server",
               "--actors", "lurkapi/google-maps-business-without-websites-leads-scraper"],
      "env": { "APIFY_TOKEN": "your-token" }
    }
  }
}
```

**Codex CLI**

Edit `~/.codex/config.toml`:

```toml
[mcp_servers.apify]
command = "npx"
args = ["-y", "@apify/actors-mcp-server",
        "--actors", "lurkapi/google-maps-business-without-websites-leads-scraper"]
env = { APIFY_TOKEN = "your-token" }
```

**Cursor**

Edit `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server",
               "--actors", "lurkapi/google-maps-business-without-websites-leads-scraper"],
      "env": { "APIFY_TOKEN": "your-token" }
    }
  }
}
```

**Anything else that speaks MCP**: same `npx @apify/actors-mcp-server --actors lurkapi/google-maps-business-without-websites-leads-scraper` command, wrapped in whatever config shape your client expects.

### 💰 Pricing

Pay-per-result. You only pay for what you get. Failed lookups and filtered listings cost nothing.

**Base**

| Item | Price |
|---|---|
| No-website place shipped | **$1.99 / 1,000** |

Volume discounts apply automatically at higher Apify plan tiers.

**Add-ons** (pay only when the add-on returns a decisive positive result)

| Add-on | Charges when | Price |
|---|---|---|
| **Social profiles & Yelp (recommended)** | At least one social profile URL is discovered (Facebook, Instagram, LinkedIn, Twitter / X, TikTok, YouTube, Pinterest, Discord, or Yelp) | **$3.00 / 1,000** |
| Company registry enrichment | The business is matched to an official registry record | **$2.00 / 1,000** |
| Legal-entity resolution | The legal company behind the listing is resolved | **$2.00 / 1,000** |
| Lead scoring (0 to 100) | Free. No extra fetches, no extra charges. | **Free** |

### 💡 Good to know

- Coverage depends on what Google Maps publishes. Some businesses have a website that is not linked on Google Maps; those may show up as "no-website" leads even though a domain exists elsewhere on the internet.
- Phone numbers from Google Maps come in clean E.164 format (`+15128030078`), ready to dial or import into any CRM.
- Broad regions (states, whole countries) return more results than a single city, but take longer to run. Start with a city or two before scaling up.
- The Registry and Legal Entity add-ons work best in the US, UK, Australia, France, and New Zealand. Coverage in other countries is limited to the worldwide LEI.
- The Social Profiles add-on hits roughly 50-70% of local businesses. Yelp coverage is strongest in the US; Facebook and Instagram are strong worldwide. A business with a big local presence usually returns 3-5 platforms.
- Results are stored in your Apify storage. How long they are kept depends on your Apify plan.

### ❓ FAQ

**How is this different from other Google Maps scrapers?**

Most Google Maps scrapers return every business, including ones that already have a website. You then have to filter the CSV manually. This tool ships only the businesses that do not have a website on their Google Maps profile, so every row is already a qualified prospect for a web design or SEO pitch.

**How many leads can I pull in one run?**

Google Maps caps a single keyword-plus-city query at about 120 places. For more, run multiple keywords (`barber shop`, `hair salon`, `beauty salon`) or use broader locations. The Max places per search term input goes up to 10,000 per keyword.

**Why does a listing sometimes have a website in real life?**

The tool follows what Google Maps itself publishes. If a business has a website but has not linked it on their Google Maps profile, that listing still counts as "no website" for the purposes of this scrape. Many agencies treat this as a positive signal: the owner has not fully set up their online presence.

**How long are the results stored?**

They are stored in your Apify storage. Retention depends on your Apify plan.

### 🔗 Other tools you might like

- [Google Maps Business Leads Scraper (Email, Phone...)](https://apify.com/lurkapi/google-maps-business-leads-scraper): the companion tool that keeps businesses WITH websites and crawls each site for emails, phones, and social profiles.
- [Google Maps Reviews Scraper](https://apify.com/lurkapi/google-maps-reviews-scraper): pull the full review stream from any place. Text, rating, date, author, photos.
- [Google Maps Photos & Videos Scraper](https://apify.com/lurkapi/google-maps-photos-and-videos-scraper): every photo and video for a place, categorized as Menu, Food & drink, Vibe, By owner, Latest, Videos, and Street View.

### ⚖️ Disclaimer

This tool is intended for personal, research, and educational use. You are responsible for complying with Google's Terms of Service and applicable laws in your jurisdiction. The developer is not liable for misuse. Data availability depends on Google Maps at run time.

**Keywords:** google maps scraper, no website leads, web agency prospecting, local business lead generation, cold outreach list, seo leads, social profile finder, facebook instagram linkedin yelp lookup

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search on Google Maps. One per line. Each is paired with the Location field below. Businesses WITH a website are filtered out automatically (this is the whole point).

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

City, region, or country to search in. A city name alone works (e.g. 'Austin'); add state or country for precision (e.g. 'Austin, TX' or 'Paris, France'). Broad regions (state or country) work too.

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

Google Maps language. Default 'en'.

## `maxPlacesPerSearch` (type: `integer`):

Cap how many no-website places are kept per keyword. Google Maps returns up to ~120 places per single query; broad regions can push far above that.

## `googleMapsUrls` (type: `array`):

Paste Google Maps search URLs or place URLs. When non-empty, the search terms / location pair is ignored. Place URLs are still filtered by the 'no website' rule. A listing with a website gets dropped with a status row explaining why.

## `placeIdsToSkip` (type: `array`):

Place IDs you already collected. Skipped without charge. Bulk-paste many at once: one per line, or comma-separated.

## `searchCircle` (type: `object`):

Limit search to a circular area. Provide { "lat": <number>, "lng": <number>, "radiusMiles": <number> }. Centers the Maps viewport here and drops places outside the radius.

## `searchPolygon` (type: `array`):

Limit search to an arbitrary polygon. Provide an array of \[lng, lat] pairs (GeoJSON convention; first and last point can match). Takes precedence over Search circle when both are set.

## `minRating` (type: `number`):

Skip places below this average rating. Accepts decimals (e.g. 4.5). Filtered places are not charged.

## `minReviewCount` (type: `integer`):

Skip places with fewer than this many reviews. Filtered places are not charged.

## `onlyCurrentlyOpen` (type: `boolean`):

Drop places marked permanently or temporarily closed. Filtered places are not charged.

## `enrichRegistry` (type: `boolean`):

Look up the business in official government registries: registration number, legal status, incorporation date, registered address, and IDs like EIN / SIREN / NZBN. Covers the US, UK, Australia, France, and New Zealand.

## `enrichLegalEntity` (type: `boolean`):

Find the legal company behind the trade name. Many businesses operate under a brand that differs from the entity that owns it (a 'Subway' franchise may legally belong to 'Doctor's Associates LLC').

## `enrichSocialProfiles` (type: `boolean`):

Turns phone-only rows into multi-channel outreach targets. Discovers Facebook, Instagram, LinkedIn, TikTok, YouTube, Yelp, and 3 more per business. Hits around 50-70% of local businesses. Charges only when at least one profile is found, so misses cost nothing.

## `enableLeadScoring` (type: `boolean`):

Compute a 0 to 100 lead score per place from signals already in the row (phone, rating, review count, category, closure status, etc.). Free, no extra fetches. Tune via Lead score weights below.

## `leadScoreWeights` (type: `object`):

Override the default scoring weights. Provide any subset of: phonePresent (default 20), ratingAtLeast4 (15), reviewCountAtLeast10 (15), reviewCountAtLeast50 (10), descriptionPresent (5), mainImagePresent (5), additionalInfoPopulated (5), categoryPresent (5), notPermanentlyClosed (20). Keys you don't specify keep their defaults. Permanently-closed places always score 0.

## `outputPlaceId` (type: `boolean`):

Google's permanent identifier for the business.

## `outputCid` (type: `boolean`):

Google's hex CID identifier for the business.

## `outputTitle` (type: `boolean`):

Display name shown on Google Maps.

## `outputPhone` (type: `boolean`):

Phone number listed on the Google Maps profile.

## `outputGoogleMapsUrl` (type: `boolean`):

Direct link to the listing on Google Maps.

## `outputSearchKeyword` (type: `boolean`):

Keyword that produced this row.

## `outputError` (type: `boolean`):

Technical error string when a lookup fails.

## `outputCategory` (type: `boolean`):

First category Google assigns to the business.

## `outputCategories` (type: `boolean`):

All categories Google assigns to the business.

## `outputAddress` (type: `boolean`):

Complete street address.

## `outputCity` (type: `boolean`):

City component of the address.

## `outputState` (type: `boolean`):

State or region component of the address.

## `outputCountry` (type: `boolean`):

Country component of the address.

## `outputPostalCode` (type: `boolean`):

Postal code component of the address.

## `outputLatitude` (type: `boolean`):

Latitude in decimal degrees.

## `outputLongitude` (type: `boolean`):

Longitude in decimal degrees.

## `outputRating` (type: `boolean`):

Average review rating (1 to 5).

## `outputReviewCount` (type: `boolean`):

Total number of reviews.

## `outputPriceRange` (type: `boolean`):

Price range string (such as $$ or US$10-20).

## `outputDescription` (type: `boolean`):

Editorial description shown on the listing.

## `outputOpeningHours` (type: `boolean`):

Opening hours per day of the week.

## `outputPopularTimes` (type: `boolean`):

Hourly busyness percentages from Google.

## `outputCurrentStatus` (type: `boolean`):

Current status string (Open, Closed, Permanently closed).

## `outputTimezone` (type: `boolean`):

IANA timezone string for the location.

## `outputPlusCode` (type: `boolean`):

Google plus code for the location.

## `outputMainImage` (type: `boolean`):

Primary photo of the business.

## `outputImages` (type: `boolean`):

List of additional photo URLs.

## `outputServiceOptions` (type: `boolean`):

Service options listed on the business profile.

## `outputAdditionalInfo` (type: `boolean`):

Additional attributes Google publishes for the business.

## `outputMenu` (type: `boolean`):

Menu link if the business publishes one.

## `outputReservations` (type: `boolean`):

Reservation links if the business publishes any.

## `outputOrderOnline` (type: `boolean`):

Order-online links if the business publishes any.

## `outputOwner` (type: `boolean`):

Listing owner or top contributor info if available.

## `outputHotel` (type: `boolean`):

For lodging categories (hotel, motel, hostel, inn, resort, extended-stay): star rating, display nightly price, check-in / check-out dates. Null on every non-lodging row.

## Actor input object example

```json
{
  "searchTerms": [
    "barber shop"
  ],
  "location": "Austin, TX",
  "language": "en",
  "maxPlacesPerSearch": 10,
  "onlyCurrentlyOpen": false,
  "enrichRegistry": false,
  "enrichLegalEntity": false,
  "enrichSocialProfiles": false,
  "enableLeadScoring": false,
  "outputPlaceId": true,
  "outputCid": true,
  "outputTitle": true,
  "outputPhone": true,
  "outputGoogleMapsUrl": true,
  "outputSearchKeyword": true,
  "outputError": true,
  "outputCategory": true,
  "outputCategories": true,
  "outputAddress": true,
  "outputCity": true,
  "outputState": true,
  "outputCountry": true,
  "outputPostalCode": true,
  "outputLatitude": true,
  "outputLongitude": true,
  "outputRating": true,
  "outputReviewCount": true,
  "outputPriceRange": true,
  "outputDescription": true,
  "outputOpeningHours": true,
  "outputPopularTimes": true,
  "outputCurrentStatus": true,
  "outputTimezone": true,
  "outputPlusCode": true,
  "outputMainImage": true,
  "outputImages": true,
  "outputServiceOptions": true,
  "outputAdditionalInfo": true,
  "outputMenu": true,
  "outputReservations": true,
  "outputOrderOnline": true,
  "outputOwner": true,
  "outputHotel": true
}
```

# Actor output Schema

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

No description

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

No description

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

No description

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

No description

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

No description

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

No description

# 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 = {
    "searchTerms": [
        "barber shop"
    ],
    "location": "Austin, TX",
    "maxPlacesPerSearch": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/google-maps-business-without-websites-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 = {
    "searchTerms": ["barber shop"],
    "location": "Austin, TX",
    "maxPlacesPerSearch": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/google-maps-business-without-websites-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 '{
  "searchTerms": [
    "barber shop"
  ],
  "location": "Austin, TX",
  "maxPlacesPerSearch": 10
}' |
apify call lurkapi/google-maps-business-without-websites-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Business Without Websites Leads Scraper",
        "description": "Find local businesses on Google Maps without a website. Every row includes phone + address + optional social profiles (Facebook, Instagram, LinkedIn, Yelp, and 5 more). Ready-to-pitch leads for web agencies, SEO consultants, and cold outreach.",
        "version": "0.0",
        "x-build-id": "pXXxef6658uYUbVDj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~google-maps-business-without-websites-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-google-maps-business-without-websites-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/lurkapi~google-maps-business-without-websites-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-google-maps-business-without-websites-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/lurkapi~google-maps-business-without-websites-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-google-maps-business-without-websites-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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search on Google Maps. One per line. Each is paired with the Location field below. Businesses WITH a website are filtered out automatically (this is the whole point).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, or country to search in. A city name alone works (e.g. 'Austin'); add state or country for precision (e.g. 'Austin, TX' or 'Paris, France'). Broad regions (state or country) work too."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Google Maps language. Default 'en'.",
                        "default": "en"
                    },
                    "maxPlacesPerSearch": {
                        "title": "Max places per search term",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Cap how many no-website places are kept per keyword. Google Maps returns up to ~120 places per single query; broad regions can push far above that.",
                        "default": 10
                    },
                    "googleMapsUrls": {
                        "title": "Google Maps URLs (replaces keyword search if set)",
                        "type": "array",
                        "description": "Paste Google Maps search URLs or place URLs. When non-empty, the search terms / location pair is ignored. Place URLs are still filtered by the 'no website' rule. A listing with a website gets dropped with a status row explaining why.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeIdsToSkip": {
                        "title": "Place IDs to skip",
                        "type": "array",
                        "description": "Place IDs you already collected. Skipped without charge. Bulk-paste many at once: one per line, or comma-separated.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchCircle": {
                        "title": "Search circle (lat / lng / radius miles)",
                        "type": "object",
                        "description": "Limit search to a circular area. Provide { \"lat\": <number>, \"lng\": <number>, \"radiusMiles\": <number> }. Centers the Maps viewport here and drops places outside the radius."
                    },
                    "searchPolygon": {
                        "title": "Search polygon (GeoJSON ring)",
                        "type": "array",
                        "description": "Limit search to an arbitrary polygon. Provide an array of [lng, lat] pairs (GeoJSON convention; first and last point can match). Takes precedence over Search circle when both are set."
                    },
                    "minRating": {
                        "title": "Minimum rating (1–5)",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "number",
                        "description": "Skip places below this average rating. Accepts decimals (e.g. 4.5). Filtered places are not charged."
                    },
                    "minReviewCount": {
                        "title": "Minimum review count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip places with fewer than this many reviews. Filtered places are not charged."
                    },
                    "onlyCurrentlyOpen": {
                        "title": "Only currently-open businesses",
                        "type": "boolean",
                        "description": "Drop places marked permanently or temporarily closed. Filtered places are not charged.",
                        "default": false
                    },
                    "enrichRegistry": {
                        "title": "Company registry enrichment ($)",
                        "type": "boolean",
                        "description": "Look up the business in official government registries: registration number, legal status, incorporation date, registered address, and IDs like EIN / SIREN / NZBN. Covers the US, UK, Australia, France, and New Zealand.",
                        "default": false
                    },
                    "enrichLegalEntity": {
                        "title": "Find the legal entity behind the listing ($)",
                        "type": "boolean",
                        "description": "Find the legal company behind the trade name. Many businesses operate under a brand that differs from the entity that owns it (a 'Subway' franchise may legally belong to 'Doctor's Associates LLC').",
                        "default": false
                    },
                    "enrichSocialProfiles": {
                        "title": "Recommended: Find social profiles & Yelp ($)",
                        "type": "boolean",
                        "description": "Turns phone-only rows into multi-channel outreach targets. Discovers Facebook, Instagram, LinkedIn, TikTok, YouTube, Yelp, and 3 more per business. Hits around 50-70% of local businesses. Charges only when at least one profile is found, so misses cost nothing.",
                        "default": false
                    },
                    "enableLeadScoring": {
                        "title": "Score each lead (0 to 100)",
                        "type": "boolean",
                        "description": "Compute a 0 to 100 lead score per place from signals already in the row (phone, rating, review count, category, closure status, etc.). Free, no extra fetches. Tune via Lead score weights below.",
                        "default": false
                    },
                    "leadScoreWeights": {
                        "title": "Lead score weights (override defaults)",
                        "type": "object",
                        "description": "Override the default scoring weights. Provide any subset of: phonePresent (default 20), ratingAtLeast4 (15), reviewCountAtLeast10 (15), reviewCountAtLeast50 (10), descriptionPresent (5), mainImagePresent (5), additionalInfoPopulated (5), categoryPresent (5), notPermanentlyClosed (20). Keys you don't specify keep their defaults. Permanently-closed places always score 0."
                    },
                    "outputPlaceId": {
                        "title": "Place ID",
                        "type": "boolean",
                        "description": "Google's permanent identifier for the business.",
                        "default": true
                    },
                    "outputCid": {
                        "title": "CID (long-form ID)",
                        "type": "boolean",
                        "description": "Google's hex CID identifier for the business.",
                        "default": true
                    },
                    "outputTitle": {
                        "title": "Business name",
                        "type": "boolean",
                        "description": "Display name shown on Google Maps.",
                        "default": true
                    },
                    "outputPhone": {
                        "title": "Phone (from Google Maps)",
                        "type": "boolean",
                        "description": "Phone number listed on the Google Maps profile.",
                        "default": true
                    },
                    "outputGoogleMapsUrl": {
                        "title": "Google Maps URL",
                        "type": "boolean",
                        "description": "Direct link to the listing on Google Maps.",
                        "default": true
                    },
                    "outputSearchKeyword": {
                        "title": "Source search keyword",
                        "type": "boolean",
                        "description": "Keyword that produced this row.",
                        "default": true
                    },
                    "outputError": {
                        "title": "Error details (when status is not Success)",
                        "type": "boolean",
                        "description": "Technical error string when a lookup fails.",
                        "default": true
                    },
                    "outputCategory": {
                        "title": "Primary category",
                        "type": "boolean",
                        "description": "First category Google assigns to the business.",
                        "default": true
                    },
                    "outputCategories": {
                        "title": "All categories",
                        "type": "boolean",
                        "description": "All categories Google assigns to the business.",
                        "default": true
                    },
                    "outputAddress": {
                        "title": "Full address",
                        "type": "boolean",
                        "description": "Complete street address.",
                        "default": true
                    },
                    "outputCity": {
                        "title": "City",
                        "type": "boolean",
                        "description": "City component of the address.",
                        "default": true
                    },
                    "outputState": {
                        "title": "State / region",
                        "type": "boolean",
                        "description": "State or region component of the address.",
                        "default": true
                    },
                    "outputCountry": {
                        "title": "Country",
                        "type": "boolean",
                        "description": "Country component of the address.",
                        "default": true
                    },
                    "outputPostalCode": {
                        "title": "Postal / zip code",
                        "type": "boolean",
                        "description": "Postal code component of the address.",
                        "default": true
                    },
                    "outputLatitude": {
                        "title": "Latitude",
                        "type": "boolean",
                        "description": "Latitude in decimal degrees.",
                        "default": true
                    },
                    "outputLongitude": {
                        "title": "Longitude",
                        "type": "boolean",
                        "description": "Longitude in decimal degrees.",
                        "default": true
                    },
                    "outputRating": {
                        "title": "Average rating",
                        "type": "boolean",
                        "description": "Average review rating (1 to 5).",
                        "default": true
                    },
                    "outputReviewCount": {
                        "title": "Review count",
                        "type": "boolean",
                        "description": "Total number of reviews.",
                        "default": true
                    },
                    "outputPriceRange": {
                        "title": "Price range",
                        "type": "boolean",
                        "description": "Price range string (such as $$ or US$10-20).",
                        "default": true
                    },
                    "outputDescription": {
                        "title": "Editorial description",
                        "type": "boolean",
                        "description": "Editorial description shown on the listing.",
                        "default": true
                    },
                    "outputOpeningHours": {
                        "title": "Opening hours (per day)",
                        "type": "boolean",
                        "description": "Opening hours per day of the week.",
                        "default": true
                    },
                    "outputPopularTimes": {
                        "title": "Popular times (busyness % per hour)",
                        "type": "boolean",
                        "description": "Hourly busyness percentages from Google.",
                        "default": true
                    },
                    "outputCurrentStatus": {
                        "title": "Current open / closed status",
                        "type": "boolean",
                        "description": "Current status string (Open, Closed, Permanently closed).",
                        "default": true
                    },
                    "outputTimezone": {
                        "title": "Timezone (IANA)",
                        "type": "boolean",
                        "description": "IANA timezone string for the location.",
                        "default": true
                    },
                    "outputPlusCode": {
                        "title": "Plus code",
                        "type": "boolean",
                        "description": "Google plus code for the location.",
                        "default": true
                    },
                    "outputMainImage": {
                        "title": "Main image URL",
                        "type": "boolean",
                        "description": "Primary photo of the business.",
                        "default": true
                    },
                    "outputImages": {
                        "title": "Image gallery URLs",
                        "type": "boolean",
                        "description": "List of additional photo URLs.",
                        "default": true
                    },
                    "outputServiceOptions": {
                        "title": "Service options (Delivery / Takeout / Dine-in)",
                        "type": "boolean",
                        "description": "Service options listed on the business profile.",
                        "default": true
                    },
                    "outputAdditionalInfo": {
                        "title": "Additional info (LGBTQ+ friendly, accessibility, etc.)",
                        "type": "boolean",
                        "description": "Additional attributes Google publishes for the business.",
                        "default": true
                    },
                    "outputMenu": {
                        "title": "Menu link",
                        "type": "boolean",
                        "description": "Menu link if the business publishes one.",
                        "default": true
                    },
                    "outputReservations": {
                        "title": "Reservation links",
                        "type": "boolean",
                        "description": "Reservation links if the business publishes any.",
                        "default": true
                    },
                    "outputOrderOnline": {
                        "title": "Order-online links",
                        "type": "boolean",
                        "description": "Order-online links if the business publishes any.",
                        "default": true
                    },
                    "outputOwner": {
                        "title": "Owner / contributor info",
                        "type": "boolean",
                        "description": "Listing owner or top contributor info if available.",
                        "default": true
                    },
                    "outputHotel": {
                        "title": "Lodging-specific fields (stars, nightly price, dates)",
                        "type": "boolean",
                        "description": "For lodging categories (hotel, motel, hostel, inn, resort, extended-stay): star rating, display nightly price, check-in / check-out dates. Null on every non-lodging row.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
