This tutorial builds a small checker that fetches a hotel's homepage and reports four things:

• whether a known booking engine is embedded or linked
• whether the "Book now" button sends guests to an OTA instead
• whether Google Analytics or Google Tag Manager is installed
• whether a Meta pixel or a Google Ads tag is installed

What you need

• Python 3.9 or newer
• requests and beautifulsoup4 (pip install requests beautifulsoup4)
• A CSV of hotel names and website URLs. Any source works: your own CRM export, a spreadsheet of properties you already know, or a lead list.

Step 1: Signatures to look for

Booking engines leave fingerprints in the HTML: a script, an iframe or a link to the vendor's domain. The list below covers vendors you will meet often on Indian and international hotel sites. It is a starting point, so extend it as you find new ones.

import re

BOOKING_ENGINES = {
    "eZee": ["live.ipms247.com", "ezeeabsolute"],
    "SiteMinder": ["thebookingbutton.com", "direct-book.com", "siteminder.com"],
    "Cloudbeds": ["hotels.cloudbeds.com"],
    "SynXis": ["synxis.com"],
    "STAAH": ["staah.net", "staah.com"],
    "AxisRooms": ["axisrooms.com"],
    "Djubo": ["djubo.com"],
    "Hotelogix": ["hotelogix.com"],
    "Simplotel": ["simplotel.com"],
    "BookingJini": ["bookingjini.com"],
    "ResAvenue": ["resavenue.com"],
}

OTA_DOMAINS = ["booking.com", "makemytrip.com", "goibibo.com", "agoda.com",
               "expedia.", "airbnb.", "tripadvisor.", "oyorooms.com"]

TRACKING = {
    "google_analytics": [r"gtag/js\?id=G-", r"google-analytics\.com/analytics\.js",
                         r"gtag\(\s*['\"]config['\"]\s*,\s*['\"]G-"],
    "google_tag_manager": [r"googletagmanager\.com/gtm\.js", r"GTM-[A-Z0-9]{4,}"],
    "meta_pixel": [r"connect\.facebook\.net/[^\"']+/fbevents\.js", r"fbq\(\s*['\"]init['\"]"],
    "google_ads": [r"gtag\(\s*['\"]config['\"]\s*,\s*['\"]AW-",
                   r"googleadservices\.com/pagead/conversion"],
}

Step 2: Check one website

import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin

HEADERS = {"User-Agent": "Mozilla/5.0 (compatible; site-audit/1.0)"}
BOOK_WORDS = re.compile(r"book\s*now|check\s*availability|reserve", re.I)

def check_site(url: str) -> dict:
    result = {"url": url, "ok": False, "booking_engine": "", "book_button_to_ota": "",
              **{k: False for k in TRACKING}}
    try:
        resp = requests.get(url, headers=HEADERS, timeout=15, allow_redirects=True)
        resp.raise_for_status()
    except requests.RequestException as exc:
        result["error"] = type(exc).__name__
        return result

    html = resp.text
    result["ok"] = True
    lower = html.lower()

    # 1. Booking engine: vendor domain anywhere in the page
    for vendor, needles in BOOKING_ENGINES.items():
        if any(n in lower for n in needles):
            result["booking_engine"] = vendor
            break

    # 2. Where do "Book now" style buttons point?
    soup = BeautifulSoup(html, "html.parser")
    for a in soup.find_all("a", href=True):
        if BOOK_WORDS.search(a.get_text(" ", strip=True)):
            target = urljoin(resp.url, a["href"]).lower()
            ota = next((d for d in OTA_DOMAINS if d in target), "")
            if ota:
                result["book_button_to_ota"] = ota
                break

    # 3. Analytics and ad tags
    for name, patterns in TRACKING.items():
        result[name] = any(re.search(p, html) for p in patterns)

    return result

Run it on one property:

print(check_site("https://example-hotel.in"))
# {'url': 'https://example-hotel.in', 'ok': True, 'booking_engine': '',
#  'book_button_to_ota': 'booking.com', 'google_analytics': True,
#  'google_tag_manager': False, 'meta_pixel': False, 'google_ads': False}

That example output is the profile you are looking for: the site has traffic tracking, but the only way to book is through an OTA, and nothing retargets visitors who leave.

Step 3: Run it over a list

Hotel sites are slow, so use a thread pool. Twenty workers is plenty and stays polite.

import csv
from concurrent.futures import ThreadPoolExecutor

def audit(in_csv: str, out_csv: str) -> list:
    with open(in_csv, newline="", encoding="utf-8") as f:
        rows = [r for r in csv.DictReader(f) if r.get("website")]

    with ThreadPoolExecutor(max_workers=20) as pool:
        results = list(pool.map(lambda r: {"name": r["name"], **check_site(r["website"])}, rows))

    fields = ["name", "url", "ok", "booking_engine", "book_button_to_ota",
              *TRACKING.keys(), "error"]
    with open(out_csv, "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=fields, extrasaction="ignore")
        w.writeheader()
        w.writerows(results)
    return results

results = audit("hotels.csv", "hotels_audit.csv")

Step 4: Turn the audit into a call list

Sort by the gap you sell. For a booking-engine or hotel-website pitch, this order works:

def priority(r: dict) -> int:
    if not r["ok"]:
        return 0                      # site down: a different pitch
    score = 0
    if not r["booking_engine"]:
        score += 3                    # no direct booking at all
    if r["book_button_to_ota"]:
        score += 2                    # actively sending guests to an OTA
    if not (r["meta_pixel"] or r["google_ads"]):
        score += 1                    # no retargeting
    return score

results.sort(key=priority, reverse=True)

Three gotchas

• Tags loaded through Google Tag Manager. A Meta pixel added inside a GTM container does not appear in the raw HTML. If google_tag_manager is true and meta_pixel is false, record the pixel as "unknown", not "missing".
• Chain hotels. Many chain properties book through the group website, so a property page without an engine is not always a gap. Focus on independents and small groups.
• Booking on a subpage. Some sites only load the engine on a /rooms or /book page. If the homepage shows nothing, follow the first "Book now" link that stays on the same domain and check that page too.

What the output looks like at scale

I work on Mantis, which runs this kind of check on every website it finds on Google Maps and shows the result as flags such as "No online booking", "No analytics" or "No ad pixel". You can see the result on a public page like the list of hotels in Bangalore: 97 properties, 74 with a website, and per-property flags. If you are turning an audit like this into a sales pitch, this guide on selling websites to guest houses covers the conversation.

The script above is enough to run the same audit yourself on any list of hotel URLs. If you extend the vendor list, I would like to hear which engines you find most often in your city.

Disclosure: I work on Mantis.

No external services are needed. Everything below runs on the standard library plus csv.

The input

Assume a CSV with one row per business:

name,category,city,reviews,rating,website
Amit's Gym,gym,Kolkata,847,4.7,
SAS FITNESS,gym,Kolkata,1403,4.6,
Kross9 Gym Kasba,gym,Kolkata,551,4.8,
Big Chain Fitness,gym,Kolkata,2300,4.2,https://example.com
Corner Studio,gym,Kolkata,12,5.0,

website is empty when the listing has no site. Ratings near 5.0 with very few reviews are common and not very informative, so we want the score to trust review volume more than the raw rating.

Step 1: a demand score that does not over-reward huge numbers

Review counts are heavily skewed. A business with 1,400 reviews is not 100 times more interesting than one with 14. A log scale keeps big numbers from dominating:

import math

def demand_score(reviews: int, rating: float) -> float:
    """0-100. Log-scaled review volume, lightly adjusted by rating."""
    volume = min(math.log10(reviews + 1) / 3.0, 1.0)   # 1,000 reviews ~ 1.0
    quality = max(min((rating - 3.5) / 1.5, 1.0), 0.0)  # 3.5 -> 0, 5.0 -> 1
    return round(100 * (0.8 * volume + 0.2 * quality), 1)

Volume carries 80% of the weight because it reflects real footfall. Rating only nudges the result.

Step 2: flag the gap

For anyone selling websites or digital services, a business with strong demand and no website is the best lead. Add a gap flag and a combined priority:

def priority(row: dict) -> float:
    score = demand_score(int(row["reviews"]), float(row["rating"] or 0))
    has_site = bool(row["website"].strip())
    return score if not has_site else score * 0.3

Businesses that already have a site drop to the bottom instead of disappearing. They can still be leads for redesigns.

Step 3: rank and export

import csv

def rank(path_in: str, path_out: str, top: int = 20) -> None:
    with open(path_in, newline="", encoding="utf-8") as f:
        rows = list(csv.DictReader(f))
    for r in rows:
        r["priority"] = priority(r)
        r["gap"] = "no website" if not r["website"].strip() else ""
    rows.sort(key=lambda r: r["priority"], reverse=True)
    with open(path_out, "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
        w.writeheader()
        w.writerows(rows[:top])

rank("listings.csv", "ranked.csv")

With the sample input, the order comes out as SAS FITNESS, Amit's Gym, Kross9 Gym Kasba, then Corner Studio (few reviews), with Big Chain Fitness last because it already has a website.

Step 4: sanity-check the weights

Before trusting any score, eyeball the extremes:

• Does a 5.0 rating with 3 reviews outrank a 4.5 with 600? It should not.
• Does every row in the top 10 have a reason you could say out loud to the owner?
• Does the score change sensibly if you double one business's reviews?

If any answer is "no", adjust the 0.8 / 0.2 split or the log divisor. Keep the formula simple enough to explain; that is the point.

What the output looks like in practice

The same idea, applied to live listings, produces lists like this one of gyms with no website in Kolkata, where review counts range from about 370 to 1,400 per gym. For turning a ranked list into conversations, this guide on selling websites to gyms covers the pitch.

Wrap-up

• Log-scale review counts so large businesses do not drown everything else.
• Treat rating as a light adjustment, not the main signal.
• Down-weight, rather than delete, businesses that already have a website.
• Keep the formula explainable.

Disclosure: I work on Mantis, which builds lead lists like the one above.

You can find these businesses yourself with the official Google Places API. This post walks through a small Python script that searches a category in a city, keeps only places with no website, scores them, and writes a CSV you can work through.

What we're building

• Input: a text query like dance academy in Pune
• Output: leads.csv with name, address, rating, review count, phone and a 0–100 score
• Only places where the API returns no websiteUri

Prerequisites

• A Google Cloud project with Places API (New) enabled and an API key
• Python 3.9+ and requests (pip install requests)
• Read the Places API policies first. You may store place IDs indefinitely, but most other Places content has caching limits, so treat the CSV as a short-lived working list, not a database.

Step 1: Text Search with a field mask

Places API (New) requires a field mask. You're billed by the fields you request, so ask only for what you need. Fields like websiteUri and rating can move a request into a higher pricing tier, so check the pricing page before running large jobs.

import csv, os, time, requests

API_KEY = os.environ["PLACES_API_KEY"]
URL = "https://places.googleapis.com/v1/places:searchText"
FIELDS = ",".join([
    "places.id", "places.displayName", "places.formattedAddress",
    "places.rating", "places.userRatingCount", "places.websiteUri",
    "places.nationalPhoneNumber", "places.businessStatus", "nextPageToken",
])

def search(query: str, max_pages: int = 3):
    body, page = {"textQuery": query, "pageSize": 20}, 0
    while page < max_pages:
        r = requests.post(URL, json=body, headers={
            "X-Goog-Api-Key": API_KEY, "X-Goog-FieldMask": FIELDS}, timeout=30)
        r.raise_for_status()
        data = r.json()
        yield from data.get("places", [])
        token = data.get("nextPageToken")
        if not token:
            break
        body["pageToken"] = token   # keep every other parameter identical
        page += 1
        time.sleep(1)

Text Search returns at most 20 results per page and, per Google's docs, a maximum of 60 across pages. For a whole city, run several narrower queries (by locality) instead of one broad one.

Step 2: Keep only "no website" places and score them

There's no official "lead score", so here is a deliberately simple heuristic you can tune. Reviews show real demand, rating shows reputation, and a closed business scores zero.

import math

def score(p: dict) -> int:
    if p.get("businessStatus") != "OPERATIONAL":
        return 0
    reviews = p.get("userRatingCount", 0)
    rating = p.get("rating", 0.0)
    demand = min(math.log10(reviews + 1) / 3, 1.0)      # ~1000 reviews -> 1.0
    quality = max(rating - 3.5, 0) / 1.5                # 3.5 -> 0, 5.0 -> 1.0
    return round(100 * (0.6 * demand + 0.4 * quality))

def leads(query: str):
    seen = set()
    for p in search(query):
        if p["id"] in seen or p.get("websiteUri"):
            continue
        seen.add(p["id"])
        yield {
            "name": p["displayName"]["text"],
            "address": p.get("formattedAddress", ""),
            "rating": p.get("rating", ""),
            "reviews": p.get("userRatingCount", 0),
            "phone": p.get("nationalPhoneNumber", ""),
            "score": score(p),
            "place_id": p["id"],
        }

Dedupe on the place ID, never the name. Chains share names and one shop can be spelled four ways.

Step 3: Write the CSV, best leads first

if __name__ == "__main__":
    rows = sorted(leads("dance academy in Pune"), key=lambda r: r["score"], reverse=True)
    with open("leads.csv", "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
        w.writeheader(); w.writerows(rows)
    print(f"{len(rows)} places without a website")

Run it with PLACES_API_KEY=... python find_leads.py.

Gotchas worth knowing

• "No websiteUri" isn't the same as "no website". Some owners have a site and never added it to their listing. Spot-check before you pitch, and phrase it as "your Google listing doesn't link to a website".
• Facebook or Instagram as the website. Some listings put a social profile in websiteUri. Decide whether to count those as "no real website" by checking the host.
• Data goes stale. Listings close and owners add sites. Re-run the search rather than trusting an old export.
• Stay inside the terms. Use the official API. Scraping the consumer Maps UI breaks Google's terms.

What this looks like at scale

Running this per locality and category across many cities, then refreshing it, becomes a data pipeline of its own. For a sense of what the finished output looks like, here's a live list of Pune dance and self-defence academies with no website on Mantis. Once you have the list, the hard part is the first conversation; this guide to Google Maps prospecting for web designers covers that side.

I work on Mantis, a live map search for businesses without websites.