Geo-Grid Local Rank Tracking: How It Works & How to Build One (Local Falcon Alternative)

A coffee shop owner once told me her rankings were "fine." She had checked from her phone, sitting at the counter, and she was number one.

Then a customer three blocks away said they could never find her on Google Maps. Both were right. That gap is the whole reason geo-grid rank tracking exists.

Local search is not one ranking. It is hundreds of rankings, one for every point a searcher could be standing. A geo-grid shows you all of them on a single colored map.

This guide explains the concept clearly, then hands you the reusable Python pieces to build it yourself, honestly, including where a cheap API like Serpent fits and where it does not.

What a geo-grid rank tracker actually is

A geo-grid rank tracker checks your local ranking from many spots spread across a map, not from one place. Each spot becomes a data point with its own position number.

Picture a tic-tac-toe board laid over your city. The center is your storefront. Each square is a measurement point, maybe 0.5 miles apart. At every point you ask the same question: "where does my business rank for plumber near me right here?"

The answers get colored in. Green means you are in the top 3. Yellow means positions 4 to 10. Red means you are barely there or gone. The finished picture is a heatmap of your real visibility.

Local Falcon popularized this format back in 2018, and it is now the standard way agencies report local SEO. The insight is simple but powerful: a single rank check hides the truth, while a grid reveals the shape of your visibility.

The grid has two settings that matter: how many points (the grid size, like 5×5 or 13×13) and how far apart they sit (the spacing, like 0.3 or 1 mile). A tight grid over a small radius is great for a dense city block. A wide grid is better for a business that serves a whole metro area, like a roofer or a mobile mechanic.

More points means more detail and, in paid tools, more cost — which is exactly why the pricing model becomes the real decision, and why so many teams end up building their own.

Why one ranking is a lie: proximity

The reason your ranking changes block by block is proximity — how close the searcher is to your business. It is one of Google's three core local ranking signals.

Google has stated plainly that local results are based on relevance, distance and prominence. Relevance is how well you match the search. Prominence is your reviews, links and reputation. Distance is pure geography.

According to Google's own Business Profile guidance, when a searcher does not state a location, Google uses what it knows about where they are. So the same query returns different local packs depending on where the phone is.

This is why a business can rank #1 at its front door and be invisible a few blocks away. A competitor closer to that block simply wins on distance, even with fewer reviews. A single rank number can never show you that — only a grid can.

Share of Local Voice (SoLV), explained

Share of Local Voice (SoLV) is the percentage of grid points where your business appears in Google's local 3-pack. It is the one number that summarizes a whole heatmap.

The math is friendly. Count the points where you rank in the top 3, divide by the total points, multiply by 100.

SoLV beats average rank because it is intuitive for clients and resistant to noise. One point bouncing from 4 to 5 barely moves it, but losing a whole corner of the map shows up immediately. That makes it the right headline metric for a local rank tracking dashboard.

You can also track average position and a "found in top 10" share alongside SoLV. But if you report one number to a local business owner, make it SoLV. It maps directly to "how often do I show up when people nearby search."

One word of caution on the "top 3" threshold. SoLV by convention counts the local 3-pack, because that is what users see without scrolling. If you want a softer view, track a second SoLV at top 5 or top 10 — useful for businesses fighting their way up, where progress happens long before they crack the visible three. The code below lets you change the threshold with a single argument.

Commercial grid tools vs a DIY build

Commercial grid tools are fast to start but charge per map pin, while a DIY build trades setup time for far cheaper, fully owned data. Here is the honest trade-off.

Most grid tools price by the credit, where one credit equals one grid point. A 5×5 scan spends 25 credits; a 13×13 scan spends 169. Pay-as-you-go credits commonly run around $0.05 each, so heavy grids across many keywords add up quickly for an agency.

Be clear-eyed about this. If you need true street-level pins inside one ZIP code, a coordinate-driven tool is doing something a country-level API cannot. If you need to monitor local-pack standings across many cities or many keywords cheaply, a DIY build wins on cost and control. Many agencies run both.

Building the coordinate grid in Python

The first reusable piece is generating an evenly spaced grid of latitude/longitude points around a center. This logic is valuable no matter which data source you feed it.

The trick is converting a distance in miles into degrees. One degree of latitude is roughly 69 miles (about 111 km) everywhere. One degree of longitude shrinks as you move toward the poles, so you scale it by the cosine of the latitude.

import math

def build_grid(center_lat, center_lng, grid_size=5, spacing_miles=0.5):
    """Return a grid_size x grid_size list of (lat, lng) points
    centered on the business, spaced spacing_miles apart."""
    points = []
    half = grid_size // 2
    # ~69 miles per degree of latitude (constant)
    lat_per_mile = 1 / 69.0
    # longitude degrees shrink toward the poles
    lng_per_mile = 1 / (69.0 * math.cos(math.radians(center_lat)))

    for row in range(-half, half + 1):
        for col in range(-half, half + 1):
            lat = center_lat + (row * spacing_miles * lat_per_mile)
            lng = center_lng + (col * spacing_miles * lng_per_mile)
            points.append({"lat": round(lat, 6),
                           "lng": round(lng, 6),
                           "row": row + half,
                           "col": col + half})
    return points

grid = build_grid(40.7128, -74.0060, grid_size=5, spacing_miles=0.5)
print(f"Generated {len(grid)} measurement points")

That gives you 25 points for a 5×5 grid, each tagged with a row and column so you can place it in the heatmap later. Swap grid_size to 7, 9 or 13 and the spacing to widen or tighten the coverage. This is the same math the commercial tools run internally.

Computing SoLV from local-pack results

The second reusable piece turns a set of local-pack results into a SoLV score. It works on any list of result sets, whether they come from grid points or from many markets.

Each result set is just the local pack for one query: a ranked list of businesses. You scan it for your business name and record the position, then aggregate.

def find_position(local_pack, business_name):
    """Return 1-based position of business_name in a local pack, or None."""
    target = business_name.lower().strip()
    for i, biz in enumerate(local_pack, start=1):
        if target in biz.get("title", "").lower():
            return i
    return None

def compute_solv(result_sets, business_name, top_n=3):
    """result_sets: list of local packs (one per point/market).
    Returns SoLV %, average rank, and the per-point positions."""
    positions = []
    in_top_n = 0
    for pack in result_sets:
        pos = find_position(pack, business_name)
        positions.append(pos)
        if pos is not None and pos <= top_n:
            in_top_n += 1

    total = len(result_sets)
    solv = round(100 * in_top_n / total, 1) if total else 0.0
    found = [p for p in positions if p is not None]
    avg_rank = round(sum(found) / len(found), 2) if found else None
    return {"solv_percent": solv,
            "avg_rank": avg_rank,
            "found_share": round(100 * len(found) / total, 1) if total else 0.0,
            "positions": positions}

Feed this 25 local packs and it returns your SoLV, your average rank where you appear, and the raw positions for the heatmap. The exact same function works whether you tracked one neighborhood or 25 different cities — the logic does not care where the data came from.

Rendering the heatmap

The third piece colors each point and draws the grid, giving you the green-to-red picture clients instantly understand. A tiny matplotlib scatter plot is enough to start.

import matplotlib.pyplot as plt

def color_for(pos):
    if pos is None:      return "#d1d5db"   # not found (grey)
    if pos <= 3:         return "#16a34a"   # top 3 (green)
    if pos <= 10:        return "#eab308"   # 4-10 (yellow)
    return "#dc2626"                        # 11+ (red)

def draw_heatmap(grid, positions, out="solv_heatmap.png"):
    xs = [p["col"] for p in grid]
    ys = [-p["row"] for p in grid]   # flip so row 0 is on top
    colors = [color_for(pos) for pos in positions]
    plt.figure(figsize=(6, 6))
    plt.scatter(xs, ys, c=colors, s=900, edgecolors="white", linewidths=2)
    for p, pos in zip(grid, positions):
        label = str(pos) if pos else "X"
        plt.text(p["col"], -p["row"], label, ha="center", va="center",
                 color="white", fontsize=11, fontweight="bold")
    plt.axis("off")
    plt.title("Share of Local Voice heatmap")
    plt.savefig(out, dpi=130, bbox_inches="tight")
    print(f"Saved {out}")

Pass it the same grid and the positions list from compute_solv and you get a labeled green-yellow-red grid saved as a PNG. From here it is a short hop to an interactive map with Folium or a client dashboard. If you want a fuller starting point, our build a rank tracker in 100 lines of Python guide shares the storage and scheduling scaffolding.

Where Serpent API fits (and where it does not)

Serpent API is the affordable SERP and data layer for the parts of this that do not need street-level coordinates: country and market-level Google local-pack tracking. It is honest about its boundary, and that boundary matters.

Here is the straight version. Serpent localizes by country (a two-letter code) and language. It does not accept latitude/longitude, a uule, or a street-level location parameter. So it will not run a different query per grid coordinate.

What it does brilliantly is return the Google local pack for a query in a given market — business name, rating, review count and position — at a flat per-call price where depth never multiplies the cost. That is exactly what you need to monitor local-pack standings across many cities, many keywords, or many client locations cheaply.

Here is a working call that pulls the localPack and computes SoLV across several markets:

import requests

API_KEY = "sk_live_your_key"
BASE = "https://api.apiserpent.com/api/search"
HEADERS = {"X-API-Key": API_KEY}

def get_local_pack(query, country="us", language="en"):
    params = {"q": query, "engine": "google",
              "country": country, "language": language}
    r = requests.get(BASE, headers=HEADERS, params=params, timeout=60)
    r.raise_for_status()
    data = r.json()
    return data.get("results", {}).get("localPack", [])

# Track one keyword across several US markets
markets = ["us"]   # add more country codes for international coverage
packs = [get_local_pack("best coffee shop", country=m) for m in markets]

result = compute_solv(packs, business_name="Blue Bottle", top_n=3)
print(result)   # {'solv_percent': ..., 'avg_rank': ..., ...}

For coverage across borders, pair this with our international rank tracking across 40 countries approach — loop the same keyword over many country codes. For the broader setup, the local SEO rank tracking API tutorial and our local SEO rank tracking guide walk through storage and alerting. And if you also pull business listings, see scraping Google Maps data with Python and how teams turn that into SERP-powered lead generation.

So position it correctly: use a coordinate-aware tool when you truly need street-level pins inside one city, and use Serpent's Google SERP API as the cheap engine for multi-market local-pack monitoring plus all the tracking, alerting and visualization you build on top. No proxy pool or headless browser to manage — the API handles access for you.

FAQ

What is a geo-grid rank tracker?

A geo-grid rank tracker checks a business's local ranking from many points spread across a map, not just one spot. Each point gets a position, the points are colored green to red, and together they show exactly where you are visible and where you vanish.

What is Share of Local Voice (SoLV)?

Share of Local Voice is the percentage of grid points where your business appears in Google's local 3-pack. If you show in the top 3 at 18 of 25 points, your SoLV is 72%. It is the single clearest number for local visibility across an area.

Is there a free or cheaper Local Falcon alternative?

Yes. You can build your own tracker on top of a SERP API. Serpent returns Google local-pack data at flat per-call pricing with 10 free searches, so you pay for data, not per map pin, and depth never multiplies the cost.

Can Serpent API track street-level grid points by coordinates?

No. Serpent localizes by country and language, not by latitude/longitude or a street address. It is built for country and market-level Google local-pack monitoring. For true per-coordinate grid precision you need a data source that accepts coordinates.

How does Google decide local pack rankings?

Google uses three main signals: relevance (how well you match the search), distance (how close you are to the searcher), and prominence (reviews, links and reputation). Distance is why a business can rank first at its door yet disappear a few blocks away.

How much does it cost to run geo-grid tracking yourself?

On Serpent, Google searches start at $0.60 per 10,000 pay-as-you-go and drop to $0.03 per 10,000 at scale, with no subscription. You query the local pack, store the data, and run the grid, SoLV and heatmap logic locally for free.