Find Local Businesses Without Websites: Free Lead Gen Goldmine (2026)

Yesterday I ran two API calls against Google Maps: every barber shop in El Paso, Texas, 40 listings total. 21 of them had no website. Established shops, some with over 100 reviews, a listed phone, a steady stream of walk-in customers, and nowhere to send anyone online.

If you build websites for a living, that’s not a statistic. That’s a client list: local businesses without websites are the warmest leads this trade has.

In a live FlyByAPIs test of 252 Google Maps listings across 7 US niches, 95 (38%) had no website. The best-performing niche, barber shops in El Paso, hit 52%. Two API requests surfaced 21 no-website leads from a single search, and the free tier covers 100 requests a month, so a full prospecting run costs $0.

Every guide ranking for this search tells you to click through Maps listings one by one, or to pay for some lead tool with a waitlist. Nobody gives you the actual mechanism.

So this post does: the manual way, a Python script, and a Google Sheets version for people who don’t code. All three tested this week with real numbers, and the full code lives in our blog code repo on GitHub .

We run scraping infrastructure at FlyByAPIs and process millions of Google Maps requests, so the data side of this is our day job. The lead gen side is yours. By the end of this guide you’ll have a sorted CSV or spreadsheet of businesses in your city that need exactly what you sell.

Why a business with no website is your best lead

Think about what a Google Maps listing with 100+ reviews and no website actually tells you. The business is real, and it survived long enough to collect those reviews. Customers already find it, call it, and pay it.

The owner isn’t against being found online. They’re already on Maps. They just never got around to the website part, or got burned by someone who charged $3,000 and delivered nothing.

Compare that to cold-emailing companies from a purchased list. Half the contacts are stale, and the other half already have an agency. In our comparison of B2B data providers , decent lead databases start around $49/month, and none of them can filter by “has no website” at the local level.

Google Maps can, and with a Google Maps local lead API that filter is one line of code.

Sergio’s Barber Shop in El Paso: 125 reviews, 4.7 stars, phone number listed, no site. Same story for Inn The Cutt (109 reviews) and Oscar’s (72). Three warm doors to knock on, from one search.

How to find businesses without websites on Google Maps by hand

The manual method works, and it’s genuinely free. Here’s the whole thing:

For your first 10 leads, honestly, just do this. You’ll learn what the listings look like and which niches in your city are underserved.

Then the math catches up with you. Checking one listing takes 20 to 30 seconds. A city has hundreds of businesses per category, and roughly 6 in 10 of the ones you click will have a website, which means most of those clicks produce nothing.

There’s a second problem nobody mentions: Maps shows you the businesses it ranks highest, and top-ranked listings in big cities almost always have websites. When I pulled the top plumbers in Austin, all 5 had one.

The gold is in positions 20 to 60, exactly the part that’s exhausting to reach by scrolling.

This is the point where you stop clicking and start querying. Both methods below use the FlyByAPIs Google Maps scraper API , which returns every listing as structured JSON, including the one field that matters here: website_url.

The Python method: a sorted lead list in 60 lines

Here’s the mechanism the lead-gen tools charge for. One endpoint, locate_and_search, takes the same query you’d type into Maps and returns up to 200 listings per request as JSON. Each listing includes name, phone, full_address, rating, reviews_count, and website_url.

When a business has no site, website_url is null. That’s the entire filter. The locate_and_search endpoint docs list every field if you want to grab more, like coordinates or opening hours.

The script below pulls 3 pages (60 listings), keeps only the no-site businesses, dedupes them, sorts by review count so the most established leads come first, and writes a clean leads.csv:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

import csv
import os
import time

import requests

API_HOST = "google-maps-extractor2.p.rapidapi.com"
API_KEY = os.environ["RAPIDAPI_KEY"]  # export RAPIDAPI_KEY=... never hardcode it

QUERY = "barber shop in El Paso, TX, USA"  # your niche + city here
PAGES = 3    # 3 pages x 200 results = 600 listings checked
LIMIT = 200  # results per request (endpoint accepts up to 999)


def fetch_page(offset):
    response = requests.get(
        f"https://{API_HOST}/locate_and_search",
        headers={"x-rapidapi-host": API_HOST, "x-rapidapi-key": API_KEY},
        params={
            "query": QUERY,
            "country": "us",
            "language": "en",
            "limit": LIMIT,
            "offset": offset,
        },
        timeout=30,
    )
    response.raise_for_status()
    return response.json().get("data", [])


leads = {}
for page in range(PAGES):
    batch = fetch_page(page * LIMIT)
    if not batch:  # no more results, stop early
        break
    for biz in batch:
        if biz.get("website_url"):  # has a website: not a lead
            continue
        place_id = biz.get("place_id")
        if not place_id or place_id in leads:  # dedupe across pages
            continue
        leads[place_id] = {
            "name": biz.get("name"),
            "phone": biz.get("phone") or biz.get("full_phone") or "",
            "address": biz.get("full_address") or "",
            "category": biz.get("main_category") or "",
            "rating": biz.get("rating") or 0,
            "reviews": biz.get("reviews_count") or 0,
            "maps_link": f"https://www.google.com/maps/place/?q=place_id:{place_id}",
        }
    time.sleep(1)  # be polite between pages

rows = sorted(leads.values(), key=lambda r: r["reviews"], reverse=True)

fields = ["name", "phone", "address", "category", "rating", "reviews", "maps_link"]
with open("leads.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=fields)
    writer.writeheader()
    writer.writerows(rows)

print(f"{len(rows)} no-website leads saved to leads.csv")

Set your key as an environment variable (export RAPIDAPI_KEY=your_key), swap in your own niche and city, and run it. When I ran this exact script against the El Paso barber query it finished in about 8 seconds and printed 34 no-website leads saved to leads.csv.

Why 34 when the intro said 21? The intro test stopped at 2 pages. The third page, positions 41 to 60, added 13 more leads, which tells you where the no-website listings pile up.

The 260-listing manual grind from earlier, the one that costs 2 hours by hand, is 13 requests for this script. And the free tier of the FlyByAPIs Google Maps lead generation API gives you 100 requests a month, so a full month of prospecting costs nothing.

The Google Sheets method (no code skills needed)

Not a developer? You don’t need to be. Google Sheets can call the same Google Maps data extraction API through a built-in feature called Apps Script , and I’ll walk you through every click.

First, get your free API key: sign up on the RapidAPI page linked above, and you’ll find your key under “Header Parameters” as x-rapidapi-key. Copy it somewhere safe and treat it like a password.

Then:

Here’s the script:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

const RAPIDAPI_KEY = "YOUR_RAPIDAPI_KEY"; // paste your key between the quotes
const QUERY = "barber shop in El Paso, TX, USA"; // your niche + city
const PAGES = 3; // each page checks up to 200 businesses

function findLeads() {
  const sheet = SpreadsheetApp.getActiveSheet();

  const seen = {};
  const rows = [];

  for (let page = 0; page < PAGES; page++) {
    const url = "https://google-maps-extractor2.p.rapidapi.com/locate_and_search" +
      "?query=" + encodeURIComponent(QUERY) +
      "&country=us&language=en&limit=20&offset=" + (page * 20);

    const response = UrlFetchApp.fetch(url, {
      headers: {
        "x-rapidapi-host": "google-maps-extractor2.p.rapidapi.com",
        "x-rapidapi-key": RAPIDAPI_KEY,
      },
      muteHttpExceptions: true,
    });

    if (response.getResponseCode() !== 200) {
      throw new Error("API error: " + response.getContentText());
    }

    const businesses = JSON.parse(response.getContentText()).data || [];
    businesses.forEach(function (biz) {
      if (biz.website_url) return; // has a website: skip it
      if (!biz.place_id || seen[biz.place_id]) return; // dedupe
      seen[biz.place_id] = true;
      rows.push([
        biz.name || "",
        biz.phone || biz.full_phone || "",
        biz.full_address || "",
        biz.main_category || "",
        biz.rating || "",
        biz.reviews_count || 0,
        "https://www.google.com/maps/place/?q=place_id:" + biz.place_id,
      ]);
    });
  }

  rows.sort(function (a, b) { return b[5] - a[5]; }); // most reviews first

  sheet.clearContents(); // only clear once all pages fetched fine
  sheet.appendRow(["Name", "Phone", "Address", "Category", "Rating", "Reviews", "Maps link"]);
  rows.forEach(function (row) { sheet.appendRow(row); });
}

To prospect a different niche or city, change the QUERY line and click Run again. The sheet clears and refills. That’s the whole workflow, and it’s the same trick we covered for spreadsheet users in scraping website data straight to Excel .

Which industries have the most local businesses without websites

I didn’t want to hand you a generic “target home services!” list, so I tested it with the Google Maps business search API . Seven niches, seven mid-sized US cities, 40 listings each (except where Maps returned fewer). Live data from this week:

The pattern: the more personal and appointment-driven the service, the fewer websites. Barbers, cleaners, and mechanics run on repeat customers and phone calls. Landscapers and tattoo artists surprised me by being better covered. For tattoo shops, Instagram already does the marketing job.

Two practical rules fall out of the data:

Every query costs 1 request and checks up to 200 businesses, so mapping your entire region across 10 niches is maybe 50 requests. The no-website business finder pattern with the Google Maps API is honestly one of the highest-ROI uses of the free tier we’ve seen.

Turning the list into clients

A lead list is worth nothing in a drawer. A few things that separate the freelancers who close from the ones who spam:

Sort by reviews, call the top. A business with 100+ reviews and no site has money and momentum. That’s why both scripts sort by reviews_count descending: your call list is literally ordered by lead quality.

Reference something real. Open with their numbers instead of your portfolio:

You can even run their name through our Google Search API and open with “you don’t show up anywhere on Google outside of Maps”, which is usually true and usually alarming.

Once the pipeline grows, a few enrichment ideas from the rest of our stack:

One request, though: don’t blast these lists. 20 researched calls beat 500 spam emails, and local business owners talk to each other.

Run your first query today

The manual method costs time, the scripts cost nothing, and the leads are sitting there right now. Pick the niche with the worst website coverage in your city, run 3 requests, and you’ll have a phone list before your coffee gets cold.

Grab the full code for both versions on GitHub , and if you want to go deeper on the data side, our Python Google Maps scraping tutorial covers reviews, details, and everything else the Google Maps business data API returns.

P.S. If you close a client from a list you built with this guide, tell me. Those emails are the best part of running this thing.

Oriol.