A local business website might show an address, contact details, service descriptions, and a list of activities.

But how do you know whether the information is complete, consistent, and still useful?

This is an interesting problem for developers working with local business websites.

A small business may appear in online directories, maps, social profiles, and travel listings. Over time, its information can change.

For example, someone researching a dive shop in Lahaina might find the correct business address but an outdated tour schedule.

Both pieces of information appear on the internet. Only one may be suitable for current use.

In this tutorial, we will build a lightweight local business data audit using Python, CSV, and Markdown.

We will use Dive Maui / Hawaiian Rafting Adventures in Lahaina, Hawaii, as a practical example.

No external APIs, databases, or paid tools are required.

1. What Are We Trying to Solve?

Local business information usually includes three important fields:

  • Name
  • Address
  • Phone number

These are often called NAP data.

For local SEO, consistent NAP information helps search engines and customers recognize the same business across different sources.

However, contact information is only part of the picture.

A complete review should also consider:

  • Business website
  • Contact information
  • Service descriptions
  • Current service availability
  • Geographic relevance
  • Source verification status
  • Last review date

The main challenge is separating confirmed information from information that still needs checking.

Our script will help organize that process.

It will not pretend to verify facts automatically.

2. Create a Simple Project Structure

We will start with three files.

local-business-audit/ | |-- business.csv |-- audit.py |-- README.md 

The CSV file stores business information.

The Python script checks the structure and reports missing values.

The Markdown README explains the purpose of the project.

This approach is useful for small datasets and can be expanded later.

3. Store Business Information in CSV

A CSV file is easy to create and can be opened in most spreadsheet applications.

For our example, create a file named business.csv.

business_name,address,city,state,postal_code,phone,service_status Dive Maui / Hawaiian Rafting Adventures,1223 Front St,Lahaina,HI,96761,+18086617333,Needs current verification 

These example contact details are drawn from Dive Maui's published business information.

The service status is deliberately marked as needing verification.

That distinction matters.

Some of Dive Maui's activity pages are marked unavailable following operational challenges connected to the 2023 Lahaina wildfires.

A valid business address does not prove that every service is currently operating.

This is an important principle for any local business dataset.

Do not treat historical service information as a confirmed current offering.

4. Read the CSV File With Python

Python includes a built-in csv module.

That means we can read our business file without installing an additional package.

Create a file called audit.py.

import csv with open( "business.csv", newline="", encoding="utf-8" ) as file: reader = csv.DictReader(file) for business in reader: print("Business:", business["business_name"]) print("City:", business["city"]) print("Phone:", business["phone"]) print("Status:", business["service_status"]) 

This script loads the CSV file and prints selected fields.

It is a simple first step, but it helps demonstrate how structured business information can be processed.

5. Check for Missing Information

A business record may contain empty values.

For example, a contact number could be missing, or a location might be incomplete.

We can add a function to identify those issues.

Replace the script with:

import csv REQUIRED_FIELDS = [ "business_name", "address", "city", "state", "postal_code", "phone" ] def audit_business(business): missing = [] for field in REQUIRED_FIELDS: value = business.get(field, "") if not value or not value.strip(): missing.append(field) return missing with open( "business.csv", newline="", encoding="utf-8" ) as file: reader = csv.DictReader(file) for business in reader: missing = audit_business(business) print(f"Business: {business['business_name']}") if missing: print("Missing fields:", ", ".join(missing)) else: print("Required fields are populated.") 

The script checks whether the required fields contain values.

However, there is an important limitation.

A populated field is not necessarily correct.

For example, a phone number might be present but outdated.

Our script checks completeness, not factual accuracy.

6. Add a Verification Status

A reliable local business audit should record whether information has been checked against an appropriate source.

We can use a separate field for this purpose.

For example:

business_name,nap_verified,services_verified Dive Maui / Hawaiian Rafting Adventures,yes,no 

In this example:

  • nap_verified indicates that the listed contact information has been checked.
  • services_verified indicates whether current service availability has been independently confirmed.

These values should be based on actual verification work.

Do not automatically mark a business as verified just because its fields are filled in.

For a more detailed project, you could add the review date and the name of the person performing the check.

7. Generate a Markdown Audit Report

Now we can turn our checks into a simple report.

The following script reads business.csv, identifies missing required fields, and creates audit-report.md.

import csv from pathlib import Path REQUIRED_FIELDS = [ "business_name", "address", "city", "state", "postal_code", "phone" ] def find_missing_fields(row): return [ field for field in REQUIRED_FIELDS if not (row.get(field) or "").strip() ] with open( "business.csv", newline="", encoding="utf-8" ) as file: businesses = list(csv.DictReader(file)) lines = [ "# Local Business Data Audit", "", "This report checks data completeness.", "It does not independently verify accuracy.", "" ] for business in businesses: name = business.get("business_name") or "Unnamed Business" missing = find_missing_fields(business) lines.append(f"## {name}") lines.append("") if missing: lines.append( "Missing fields: " + ", ".join(missing) ) else: lines.append("All required fields are populated.") lines.append("") lines.append( "Service status: " + (business.get("service_status") or "Not recorded") ) lines.append("") Path("audit-report.md").write_text( "\n".join(lines), encoding="utf-8" ) print("Audit report created.") 

Run it with:

python audit.py 

The output will be saved as a Markdown file.

This makes it easy to share the report internally, include it in documentation, or maintain it alongside other project files.

8. Think About Geographic Relevance

Local business data should identify the actual business location.

For example, Dive Maui lists its address as:

1223 Front Street, Lahaina, Hawaii 96761.

Nearby areas such as Kaanapali may be relevant to visitors researching local diving options.

However, being near a location does not automatically mean the business offers services throughout that area.

A business audit should distinguish:

Physical location: Where the business lists its address.

Target audience: People who may find the information relevant.

Verified service area: Locations the business actually confirms it serves.

These fields should not be treated as interchangeable.

If a campaign focuses on a seven-mile radius around a physical location, geographic filtering should use verified coordinates and an appropriate distance calculation.

A city name alone is not enough to confirm whether a point lies within that radius.

9. Avoid Turning Old Service Pages Into Current Claims

This is one of the most important lessons in the project.

Imagine that a dive shop website contains a detailed article about a boat diving trip.

The page describes the underwater location, explains the experience, and includes a price.

But a notice on the same page says the trip is currently unavailable.

A simple data scraper might collect the price and trip description while ignoring the notice.

That could produce an inaccurate business listing.

A better data model separates the service description from availability.

For example:

{ "service": "Example guided boat dive", "historically_listed": true, "current_availability": "unverified", "requires_manual_review": true } 

This is an illustrative data structure, not a claim about the current status of a specific trip.

The key idea is simple.

A service can be documented without being available.

Automated systems should preserve that distinction.

10. A Real Local Example: Dive Maui

Dive Maui / Hawaiian Rafting Adventures is a family-run diving business based in Lahaina.

Its published website includes information about scuba activities, training, equipment rentals, and ocean experiences.

The business also explains that some previously offered activities are unavailable due to operational difficulties following the Lahaina wildfires.

This makes it a useful example of why local business data should be reviewed carefully rather than copied automatically.

Developers researching a dive shop in Lahaina can use the official Dive Maui website as a starting point for understanding the business's published information.

Current service availability should still be confirmed directly.

11. Ways to Improve the Audit

Our basic script is intentionally small.

Once the foundation is working, you could expand it with:

  • Phone number normalization
  • Duplicate business detection
  • Coordinate-based radius checks
  • Source URL tracking
  • Verification timestamps
  • Manual review flags
  • Change history between audits
  • Separate status fields for each service

These features would make the tool more useful for larger local business datasets.

However, additional automation should not create false confidence.

A script can identify missing information or inconsistent formats.

It cannot determine whether an unavailable ocean activity has resumed without reliable current evidence.

Final Thoughts

Local business data looks simple at first.

A business name, address, phone number, and website might seem like enough information.

But useful data also needs context.

Is the information current?

Has the source been checked?

Are services actually operating?

Does the stated service area match verified business information?

Python, CSV, and Markdown provide a lightweight way to organize these questions.

The code does not need to be complicated.

The important part is treating uncertainty honestly and keeping historical information separate from confirmed current facts.

That principle applies to dive shops in Lahaina, restaurants, repair businesses, and almost any other local service.

Good local data begins with clear records, careful verification, and fewer assumptions.