# Businesses Without Website from Google Maps | $3/1K Leads (`berkaydev/google-maps-businesses-without-website`) Actor

Businesses without website from Google Maps, by business type and city: local leads for web design agencies with phone, address, rating and a lead score that explains every point. Social-only and booking-only businesses flagged, unlinked sites ruled out. $3 per 1,000 leads.

- **URL**: https://apify.com/berkaydev/google-maps-businesses-without-website.md
- **Developed by:** [Gezgin Data](https://apify.com/berkaydev) (community)
- **Categories:** Lead generation, Automation, Agents
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 lead (business without website)s

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Businesses without website from Google Maps** — search any business type in any city and get
only the ones whose Google listing leads to no website of their own. Every lead comes with its
phone, address, rating and a **lead score that explains every point**, so a web design agency knows
who to call first and what to say.

Call it from code or an AI agent with plain inputs:

```json
{"searchTerms": ["hair salon", "barber"], "location": "Austin, TX", "maxResults": 50}
```

### What you get that other no-website scrapers don't

**A live search by city, not a stale database.** You name the business type and the town, the Actor
searches Google Maps right now. New businesses show up the day they get a listing.

**It tells you what the business uses instead of a website.** Some have nothing at all. Many link a
Facebook or Instagram page, a Treatwell or Doctolib booking profile, or a Linktree. Those are often
the best leads of all — they clearly want to be found online and have no site of their own — so each
row says which kind it is (`website_status`), and you can switch the social-only or booking-only
ones off.

**Businesses with an unlinked website are ruled out.** Google Maps only knows the website the owner
entered. Before a business is delivered, the Actor tries the obvious domains for its name — a salon
called "Haarwerk Müller" in Germany gets haarwerk-mueller.de and haarwerkmueller.de checked. A domain
only counts as theirs when the page carries the business's phone number or its street, so a parked
"for sale" domain never knocks a real lead out. Businesses that do have a site are listed in
`SITES_FOUND_BY_DOMAIN_CHECK` instead, and you are not charged for them.

**A score you can read.** `score_breakdown` lists every point with its reason, for example:

```json
[
  {"points": 30, "reason": "219 Google reviews: an established business with steady customers"},
  {"points": 20, "reason": "No website at all on its Google listing"},
  {"points": 15, "reason": "Rated 4.9: customers like it, a website would show that off"},
  {"points": 12, "reason": "Phone number on the listing"},
  {"points": 5,  "reason": "Opening hours maintained: the owner keeps the listing up to date"}
]
```

An established business with many good reviews and no website has customers, a budget and
something to lose online — that is a hot lead. A business with two reviews may have just opened.
`lead_priority` sums it up as hot, warm or cold, and `lead_reason` gives the two biggest reasons.

**An opening line, in English or German.** `outreach_hook` states one checked fact about the listing,
e.g. "Your Google Maps listing points at a social media profile rather than a website of your own.
With 67 reviews at 4.8 stars, many customers look you up online." No sales talk, nothing invented.

**Only new businesses, on a schedule.** Turn on `onlyNew` and run it weekly: you get only businesses
you have not received before, so newly opened places without a website reach you first. If you only
care about businesses that open from today on, start with one run with `baselineOnly` switched on:
it remembers everything Google lists for the search today, delivers nothing and charges nothing.
Every scheduled `onlyNew` run after that brings only what appeared since. Keep the search to one
trade in one town or district, because Google returns at most about 190 businesses per search.

**Privacy built in.** Sole traders often list a private mobile number. Every phone is tagged
`mobile`, `landline` or `unknown` (detected for Germany, Austria, Switzerland, the UK, the
Netherlands, France, Belgium, Spain and Italy), and `hideMobileNumbers` blanks mobile numbers so you
keep only business landlines.

### Input

| Field | What it does |
|---|---|
| `searchTerms` | Business types, as you would type them into Google Maps |
| `location` | City or area, e.g. `Austin, TX`, `Köln`, `Manchester, UK` |
| `maxResults` | How many leads to deliver (default 50) |
| `includeSocialOnly` | Include businesses with only a social media page (default on) |
| `includePlatformOnly` | Include businesses with only a booking/directory profile or link page (default on) |
| `checkDomains` | Rule out businesses with an unlinked website (default on) |
| `minReviews`, `minRating` | Only established or well-rated businesses |
| `hideMobileNumbers` | Blank mobile numbers, keep landlines |
| `onlyNew` | Return only businesses not delivered by earlier runs of the same search |
| `baselineOnly` | Remember everything the search finds today, deliver and charge nothing; later `onlyNew` runs return only businesses that appear afterwards |
| `language` | `en` or `de` for Maps results and the opening line |
| `compact` | Short rows for AI and LLM use |

The Actor also understands `queries`, `keywords`, `city` and `limit`, so an agent guessing field names
still gets a result.

### Output

One row per business without a website. Download it as JSON, CSV or Excel, or pull it through the
API. Main fields: `name`, `category`, `address`, `city`, `country`, `phone`, `phone_type`,
`website_status`, `listed_link` (the social or booking page, if any), `rating`, `review_count`,
`opening_hours`, `lead_score`, `lead_priority`, `lead_reason`, `score_breakdown`, `outreach_hook`,
`place_id` and `maps_url`.

`RUN_STATUS` in the key-value store says how many businesses were checked, how many had a website,
how many were ruled out by the domain check, and why a run came back empty.

### FAQ

#### What does the Businesses Without Website Actor return?

The Businesses Without Website Actor returns local businesses from Google Maps that have no website of their own, with phone, address, rating, review count, a 0–100 lead score and the reason behind the score.

#### How does the Businesses Without Website Actor know a business has no website?

The Businesses Without Website Actor checks the Google Maps listing and then tests likely domains built from the business name. Businesses found to have a site are left out and not charged.

#### What input does the Businesses Without Website Actor need?

The Businesses Without Website Actor needs search terms and a location, for example {"searchTerms": \["hair salon"], "location": "Austin, TX", "maxResults": 50}.

#### What does the Businesses Without Website Actor cost?

The Businesses Without Website Actor costs $3 per 1,000 leads delivered, less on paid Apify plans. Businesses that have a website or are filtered out cost nothing.

#### Does the Businesses Without Website Actor include businesses with only a Facebook page?

Yes, by default the Businesses Without Website Actor includes businesses whose only web presence is a social profile or a booking platform, marked in website_type. Turn this off with includeSocialOnly or includePlatformOnly.

### Use it from an AI agent (MCP)

Connect this Actor to Claude, ChatGPT, Cursor or any other MCP client with one URL:

```
https://mcp.apify.com/?tools=berkaydev/google-maps-businesses-without-website
```

Then ask in plain words, for example: *"Find hair salons in Austin, Texas that have no website."* The agent fills in the input, runs the Actor and reads the results. You pay the same as for a normal run.

### How much does it cost?

**$3 per 1,000 leads** — $0.003 for each business delivered, less on paid Apify plans ($2.10 per
1,000 on Gold). Businesses that have a website, are ruled out by the domain check or filtered by
your settings cost nothing. 50 leads cost at most $0.15.

### Good to know

A single Google Maps search returns up to roughly 120 businesses. For a large city, list several
related business types (hair salon, barber, beauty salon) to reach more of them. How many businesses
lack a website depends heavily on the trade: in a test in November 2026, 1 in 10 hair salons in
Austin and 1 in 5 in Cologne had none.

The data comes from public Google Maps listings. Business names, addresses and phone numbers can
still be personal data for sole traders — use them in line with the GDPR and the rules for cold
outreach where your customers are (in Germany, for example, cold e-mails need prior consent).

# Actor input Schema

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

What kind of businesses to look for, as you would type it into Google Maps. Several types widen the search, e.g. hair salon, barber, nail salon.

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

Where to search, e.g. Austin, TX or Köln or Manchester, UK.

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

How many businesses without a website to return. You pay only for delivered leads ($0.003 each, less on paid plans), so 50 leads cost at most $0.15.

## `includeSocialOnly` (type: `boolean`):

A Facebook or Instagram page instead of a website. Often the best leads: they want to be found online but have no site of their own.

## `includePlatformOnly` (type: `boolean`):

Treatwell, Doctolib, Lieferando, a Linktree and similar instead of a website.

## `checkDomains` (type: `boolean`):

Before a business is delivered, the obvious domains for its name are tried (e.g. salon-mueller.de). If one belongs to the business — the page names its phone, street or name and town — it is left out and listed in SITES_FOUND_BY_DOMAIN_CHECK instead. Recommended.

## `minReviews` (type: `integer`):

Only established businesses. 0 = all.

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

Only businesses rated at least this (1–5). 0 = all.

## `hideMobileNumbers` (type: `boolean`):

Sole traders often list a private mobile number. Turn this on to deliver only business landlines (detected for DE, AT, CH, UK, NL, FR, BE, ES, IT). The row stays, the number is blanked.

## `onlyNew` (type: `boolean`):

Remember what this search already delivered and return only businesses you have not seen. Run it weekly on a schedule to get newly opened businesses without a website first.

## `baselineOnly` (type: `boolean`):

For tracking newly opened businesses: this run remembers every business the search finds today and delivers nothing, so nothing is charged. Afterwards, run the same search with 'Only new businesses' on a weekly schedule and you get only businesses without a website that appeared after today.

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

Where already-delivered businesses are remembered. Letters, digits and hyphens.

## `maxPlacesToScan` (type: `integer`):

How many Google Maps results to look through per business type. Google Maps returns roughly up to 120 per search.

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

Language of Google Maps results and of the outreach sentence (en or de).

## `compact` (type: `boolean`):

Only name, category, city, phone, website status, score, priority, reason and Maps link.

## Actor input object example

```json
{
  "searchTerms": [
    "hair salon"
  ],
  "location": "Austin, TX",
  "maxResults": 50,
  "includeSocialOnly": true,
  "includePlatformOnly": true,
  "checkDomains": true,
  "minReviews": 0,
  "minRating": 0,
  "hideMobileNumbers": false,
  "onlyNew": false,
  "baselineOnly": false,
  "seenStoreName": "no-website-leads-seen",
  "maxPlacesToScan": 300,
  "language": "en",
  "compact": false
}
```

# Actor output Schema

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

No description

## `runStatus` (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": [
        "hair salon"
    ],
    "location": "Austin, TX"
};

// Run the Actor and wait for it to finish
const run = await client.actor("berkaydev/google-maps-businesses-without-website").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": ["hair salon"],
    "location": "Austin, TX",
}

# Run the Actor and wait for it to finish
run = client.actor("berkaydev/google-maps-businesses-without-website").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "hair salon"
  ],
  "location": "Austin, TX"
}' |
apify call berkaydev/google-maps-businesses-without-website --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,berkaydev/google-maps-businesses-without-website"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/1mjxNqWX3P4RGgkQA/builds/xhhQ5f8fr0Igu8V6s/openapi.json
