DEV Community: orange

Checking If a Business's Google Profile Actually Matches Its Own Website

orange — Sun, 06 Sep 2026 03:50:33 +0000

If you do local SEO work, you've run into this: a client's Google Business Profile says one phone number, their website footer says another, and nobody noticed until a customer called the wrong number. Or the postal code on the GBP listing is a leftover from an old office. This kind of drift is called a NAP (Name, Address, Phone) inconsistency, and it's widely cited as a local search ranking factor. But checking it by hand means opening every listing and every website side by side.

I built Google Maps NAP Consistency Checker, an Apify Actor that takes Google Maps scraper output, fetches each business's own website (lightly: homepage plus one likely subpage), and checks whether the name, postal code, and phone number on the Google Business Profile actually show up on the site.

What it does, and what it doesn't

This Actor checks one thing: does a business's own website agree with its Google Business Profile on name, postal code, and phone number. It does not check third-party directories (Yelp, Facebook, etc.). That's a different problem with a different competitor landscape. It does not crawl an entire website; it fetches at most two pages per business (homepage, plus a subpage if one with a keyword like "contact" or "about" is linked from it). It does not use an LLM. It's regex and string matching against fetched text, which makes it fast, cheap, and predictable. There's no model that can hallucinate a match that isn't there.

Businesses with no independent website (only a social profile, or nothing) are skipped entirely, because there's nothing to fetch and compare against.

How it works

For each place with a real website, the Actor:

Checks robots.txt for that domain before fetching anything, and skips the business if the checker's user agent isn't allowed.
Fetches the homepage HTML (up to 3 MB), strips <script>, <style>, and comments before converting to text, so JavaScript variables and tracking IDs don't get misread as phone numbers.
Looks for an internal link containing a keyword like "contact," "about," "access," or "info" (also handles Japanese equivalents), and fetches that one extra page if found. Mail and tel links and JS pseudo-links are excluded from that search. An early version tried to fetch mailto:info@... as if it were a page URL, which is exactly the kind of bug you only find on real sites.
Pulls out href="tel:..." numbers directly (a strong signal), plus any phone-shaped strings in the visible text, covering Japanese formats (03-6434-9090) and US formats ((512) 828-3835, +1 512-828-3835).
Compares postal code and phone number found on the site against what the Google Business Profile has, using the scraper's own postalCode field when available, with digit-only and hyphenated variants both checked so formatting differences don't cause false mismatches.
Checks whether a meaningful fraction of the business name's word tokens appear anywhere on the page, as a rough "is this even the right site" sanity check.

Every result also gets a changeStatus: run it again later on the same list and matches that were previously flagged as mismatched but are now fine get tagged FIXED. Useful if you're the one who told the client to fix it and want proof it happened.

Usage

Apify Console

Run a Google Maps scraper (e.g. Google Maps Scraper) for the businesses you want to audit.
Open Google Maps NAP Consistency Checker, paste that dataset array into the Google Maps places field.
Click Start. You're billed per business actually checked. Places with no independent website are skipped for free.

Chaining two Actors with apify-client (Python)

from apify_client import ApifyClient

client = ApifyClient(token="YOUR_APIFY_TOKEN")

# 1. Scrape a set of businesses
scrape_run = client.actor("compass/crawler-google-places").call(
    run_input={
        "searchStringsArray": ["plumber in Austin, TX"],
        "maxCrawledPlacesPerSearch": 100,
    }
)
places = list(client.dataset(scrape_run["defaultDatasetId"]).iterate_items())

# 2. Check NAP consistency for each business's own website
nap_run = client.actor("reverenced_garnet/apify-gmaps-nap-checker").call(
    run_input={"places": places}
)
results = list(client.dataset(nap_run["defaultDatasetId"]).iterate_items())

mismatches = [r for r in results if r["reasons"]]
print(f"{len(mismatches)} of {len(results)} checked businesses have a NAP issue")

Input

Field	Type	Description
`places`	array (required)	Place objects from a Google Maps scraper's dataset output. Only places with their own (non-social-media) website are checked. The rest are skipped.

Output

{
  "title": "Ultimate Plumber",
  "placeId": "ChIJv79rmEfzGGARhXlSEd8ceiQ",
  "fetchedOk": true,
  "postalMatch": true,
  "phoneStatus": "match",
  "nameFoundOnSite": true,
  "changeStatus": "FIXED",
  "reasons": []
}

Field	Type	Description
`title`	string	Business name
`placeId`	string	Google Maps place ID
`fetchedOk`	boolean	Whether the website could be fetched at all (`false` means every other field is unknown, not "matching")
`postalMatch`	boolean or null	Whether the GBP postal code appears on the site; `null` if there wasn't enough data on either side to compare
`phoneStatus`	string	`match`, `mismatch`, `gbp_missing_on_site_found`, `site_missing_gbp_has`, `both_missing`, or `unknown`
`nameFoundOnSite`	boolean or null	Whether most of the business name's word tokens appear on the page
`changeStatus`	string	`NEW`, `UPDATED`, `UNCHANGED`, or `FIXED` versus the previous run on this Actor
`reasons`	array	Plain-English list of what didn't match

Note that fetchedOk: false and postalMatch: null are deliberately kept separate from a plain "no mismatch found." If the site couldn't be fetched, or there wasn't a postal code to compare on one side, the Actor says so instead of quietly reporting a false match.

Use case: auditing NAP consistency before a local SEO engagement

A common first step for a local SEO agency taking on a new client, or a freelancer building a pitch:

Scrape the client's own listing (or every location, for a multi-location business) with a Google Maps scraper.
Run it through this Actor to see whether the phone number and address on the GBP listing actually match the website.
Use phoneStatus: gbp_missing_on_site_found as a quick, low-effort recommendation: "your GBP is missing a phone number your own site already lists, this is a five-minute fix."
Schedule it monthly with Apify's Scheduler for an existing client, and use changeStatus: FIXED as evidence the fixes you recommended actually got made.

The same pattern applies to a directory or citation-management tool that wants a quick pre-check on whether a business's own site agrees with itself before flagging bigger discrepancies elsewhere.

A note on scope and responsible use

This Actor fetches at most two pages per business, respects robots.txt for the domain being checked, and identifies itself with its own user agent string. It's not a general-purpose crawler. It only looks at data that's already public on the business's own Google Business Profile and website. It's still worth being explicit that finding a phone number or address on a public page doesn't by itself give you consent to use it for outreach; if you use anything found here for contacting a business, you're responsible for complying with applicable law in your jurisdiction.

Pricing

Pay-per-event: $0.01 when a run starts, plus $0.01 per business actually checked (only businesses that had a website to fetch). Auditing 100 locations costs about $1.01. Places with no independent website are skipped and not charged. Current pricing is always on the Store page.

Try it

The Actor is live on the Apify Store: Google Maps NAP Consistency Checker. I built this as part of a small set of post-processing Actors for Google Maps scraper output. If you're already running a scraper for local SEO or lead work, this is a cheap add-on step to catch a class of client-facing errors that's otherwise easy to miss.

Turning Google Maps Scraper Output into a 0-100 Lead Priority Score (No Scraping, No LLM)

orange — Sat, 05 Sep 2026 23:56:11 +0000

If you've ever built a lead-gen pipeline for a local SEO or web design agency, you know the pattern: scrape a bunch of businesses off Google Maps, then manually eyeball which ones are worth calling. Missing website? Good lead. Unclaimed Google Business Profile? Also good. Both? Great lead. But sorting hundreds or thousands of rows by hand on multiple criteria doesn't scale.

I built Google Maps Lead Priority Scorer, an Apify Actor that takes the JSON output you already have from a Google Maps scraper and turns it into a single sortable priorityScore (0-100) per business, plus a plain-English list of reasons. It does no scraping and makes no LLM or external API calls — it's pure post-processing of data you already paid to collect.

The problem with single-signal lead lists

Most "find leads with no website" tools give you exactly one signal. But a business that has no website and an unclaimed GBP listing and fewer reviews than its neighbors is a categorically hotter lead than one that's just missing a website. If you're running four separate scrapers/filters and merging spreadsheets by hand, you're doing manual work a scoring function should do for you.

This Actor combines four signals into one number:

Signal	Max points
No independent website (a bare social-media link doesn't count)	35
Unclaimed Google Business Profile	25
Other missing profile fields (phone, description, hours, photos, categories)	25
Review count below the median for similar nearby businesses	15

Scores map to tiers: Hot (≥70), Warm (40-69), Cold (<40). Businesses marked permanently closed on Google Maps are dropped automatically before scoring, so you never waste an outreach call on a place that no longer exists.

How it works: no scraping, no LLM

This is the detail that matters most for a technical audience: this Actor is not a Maps scraper. It expects you to already have place objects (from something like Google Maps Scraper) and does pure computation on top of them — string checks for real vs. social-media-only URLs, null checks across profile fields, and a percentile calculation against other places in the same input batch. No headless browser, no OpenAI call, nothing that can time out or hallucinate. That's also why it's cheap: pay-per-event pricing is $0.005 per run start plus $0.0015 per scored lead returned. Scoring 1,000 already-scraped places costs about $1.51 on top of whatever the scraper itself charged.

Usage: Apify Console or the API

Option 1 — Apify Console

Run a Google Maps scraper for your target city/category and grab its dataset output (as JSON).
Open Google Maps Lead Priority Scorer in Apify Console, paste that array into the Google Maps places input field.
Optionally set Minimum priority tier to Warm or Hot so you're only ever billed for the leads worth calling.
Click Start. Results come back sorted highest-priority first, downloadable as JSON/CSV/Excel.

Option 2 — `apify call` from the CLI

apify call reverenced_garnet/apify-gmaps-lead-priority \
  --input '{
    "places": [
      { "title": "Lemari Coffee", "placeId": "ChIJv79rmEfzGGARhXlSEd8ceiQ" }
    ],
    "minTier": "Warm"
  }'

Option 3 — Apify API / SDK (chaining two Actors)

The realistic production setup is: scrape → score → dataset, all in one script. Here's a minimal Node example using the Apify client that chains a Maps scraper run into this Actor:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

// 1. Run a Google Maps scraper for a city/category
const scrapeRun = await client.actor('compass/crawler-google-places').call({
    searchStringsArray: ['coffee shop in Austin, TX'],
    maxCrawledPlacesPerSearch: 200,
});
const { items: places } = await client
    .dataset(scrapeRun.defaultDatasetId)
    .listItems();

// 2. Score those places for lead priority
const scoreRun = await client.actor('reverenced_garnet/apify-gmaps-lead-priority').call({
    places,
    minTier: 'Warm',
    webhookUrl: 'https://your-n8n-instance.example.com/webhook/new-leads',
});

const { items: leads } = await client
    .dataset(scoreRun.defaultDatasetId)
    .listItems();

console.log(`Got ${leads.length} Warm+ leads, top one:`, leads[0]);

The same works in Python with the apify-client package (ApifyClient(token=...), .actor(...).call(run_input=...), .dataset(...).list_items()).

Input schema

Field	Type	Description
`places`	array	Place objects from a Google Maps scraper's dataset output
`minTier`	string	`Hot`, `Warm`, or `Cold` (default) — minimum tier to include in the output
`slackWebhookUrl`	string (optional)	Slack Incoming Webhook URL — posts a run summary
`discordWebhookUrl`	string (optional)	Discord Channel Webhook URL — posts a run summary
`webhookUrl`	string (optional)	Any URL — receives a structured JSON summary (e.g. for n8n/Make)
`notifyOnlyNewOrUpdated`	boolean	Default `true` — only include `NEW`/`UPDATED` leads in notifications

Output fields

{
  "title": "Lemari Coffee",
  "placeId": "ChIJv79rmEfzGGARhXlSEd8ceiQ",
  "priorityScore": 60,
  "tier": "Warm",
  "changeStatus": "NEW",
  "reasons": [
    "No independent website (social-media link or none at all)",
    "No business description"
  ],
  "hasRealWebsite": false,
  "isUnclaimed": false,
  "completenessScore": 70,
  "reviewPercentileInGroup": 25.0
}

Field	Type	Description
`title`	string	Business name
`placeId`	string	Google Maps place ID
`priorityScore`	number	0-100 combined lead-priority score
`tier`	string	`Hot`, `Warm`, or `Cold`
`changeStatus`	string	`NEW`, `UPDATED`, or `UNCHANGED` vs. the previous run on this Actor
`reasons`	array	Plain-English reasons contributing to the score
`hasRealWebsite`	boolean	False if no site, or only a social-media link
`isUnclaimed`	boolean	True if the Google Business Profile is unclaimed
`completenessScore`	number	0-100 GBP profile completeness
`reviewPercentileInGroup`	number	Review-count percentile vs. same city+category peers

One useful, unusual feature for anyone running this on a schedule: changeStatus. Run the Actor again later on the same area and every lead gets tagged NEW, UPDATED, or UNCHANGED compared to the previous run, so your sales team only re-reviews what actually moved instead of re-triaging the whole list every week.

Use case: building an outbound list for a local SEO agency

A typical workflow for an agency doing outbound prospecting for, say, dentists in a metro area:

Run Google Maps Scraper for "dentist in Denver, CO", get back a few hundred place objects.
Feed that array into this Actor with minTier: "Hot" — you now only pay for and receive the businesses with the strongest combination of no website, unclaimed profile, and thin review count.
Set slackWebhookUrl so the agency's sales channel gets pinged with a summary whenever a run finds new or updated leads.
Schedule the whole pipeline (scraper → scorer) weekly with Apify's built-in Scheduler. Because of changeStatus, week-over-week runs only surface leads that changed, so the team isn't re-triaging the same 300 businesses every Monday.
Export the dataset as CSV and import into whatever CRM or cold-email tool the agency uses.

The same pattern works for directory sites deciding which unclaimed listings to email about claiming their profile, or freelancers building a target list for a single vertical + city combo before a cold-call sprint.

A word on scope and legality

This Actor deliberately does one thing: turn place data you already have into a priority score. It doesn't scrape anything, doesn't call any external API, and doesn't infer anything with an LLM — which is also why it's fast and cheap. It's also worth being explicit that the presence of a phone number or address on a public Google Business Profile doesn't by itself mean you have consent to cold-call or cold-email that business. If you're using this for outreach, you're responsible for complying with applicable law (GDPR, CAN-SPAM, TCPA, etc. depending on where your leads are).

Try it

The Actor is live on the Apify Store: Google Maps Lead Priority Scorer. If you're already running a Google Maps scraper as part of a lead-gen pipeline, this is a five-minute addition that replaces a manual sorting/filtering step with a single number your sales team can trust.

DEV Community: orange

Checking If a Business's Google Profile Actually Matches Its Own Website

What it does, and what it doesn't

How it works

Usage

Apify Console

Chaining two Actors with apify-client (Python)

Input

Output

Use case: auditing NAP consistency before a local SEO engagement

A note on scope and responsible use

Pricing

Try it

Turning Google Maps Scraper Output into a 0-100 Lead Priority Score (No Scraping, No LLM)

The problem with single-signal lead lists

How it works: no scraping, no LLM

Usage: Apify Console or the API

Option 1 — Apify Console

Option 2 — apify call from the CLI

Option 3 — Apify API / SDK (chaining two Actors)

Input schema

Output fields

Use case: building an outbound list for a local SEO agency

A word on scope and legality

Try it

Option 2 — `apify call` from the CLI