Coordinately

Geocoding Accuracy Levels

Geocoders return results at tiered accuracy levels: rooftop (~5 m, building footprint known), parcel (~10–20 m, property lot known), street-segment interpolated (~20–50 m, address-range estimate), street-level (~50–100 m, street known), postal-code centroid (~1–5 km), and broader administrative tiers. The article maps the tiers to per-provider taxonomies (Mapbox confidence, Google location_type, HERE matchLevel), explains how to filter and weight by tier, and the data-quality issues that drive tier degradation.

By . Published . Last updated .

A geocoder doesn't just return coordinates; it returns coordinates plus an indication of how those coordinates were computed. The same geocoder, querying the same address database, can produce results at very different accuracy tiers depending on what data is available. This article maps the tiers, the per-provider taxonomies, and the practical filtering rules.

The /learn/what-is-geocoding pillar introduces these tiers; this article goes deeper.

The standard tiers

The accuracy hierarchy used across most providers:

| Tier | Typical accuracy | Source data | | ----------------------------- | ---------------- | ------------------------------------------ | | Rooftop | ~5 m | Building footprint in database | | Parcel | ~10–20 m | Property-lot polygon in database | | Street-segment interpolated | ~20–50 m | Street known + address-range data | | Street-level | ~50–100 m | Street known, no address number | | Block-level | ~100–500 m | Block known (less common tier) | | Postal-code centroid | ~1–5 km | Only postcode known | | City / locality centroid | ~5–50 km | Only city / town known | | Administrative region | Variable | Country, state, or larger region only |

The first three tiers (rooftop, parcel, street-segment) are all “at the address” precision. Below that, the geocoder is returning a centroid as a fallback — useful for some applications, misleading for others.

Rooftop accuracy

Rooftop means the geocoder's database contains the building footprint — the polygon of the actual building. The returned coordinate is typically the building's centroid (or the front-door entrance, depending on the provider).

Sources of rooftop data:

  • Commercial address layers: Mapbox, Google, HERE maintain proprietary rooftop databases for major metros. Coverage varies by region; US, Canada, Western Europe, Australia, and East Asia are well-covered.
  • OpenStreetMap building polygons: in well-mapped cities, OSM has building footprints that geocoders can match against. Coverage varies by community.
  • National mapping agencies: Ordnance Survey (UK), IGN (France), Land Registry data (varies), all contribute rooftop-quality data in their jurisdictions.

Rooftop accuracy is ~5 m — comparable to GPS positioning itself. For delivery, navigation, and emergency dispatch, rooftop is the right tier.

Parcel accuracy

Parcel means the property-lot polygon is in the database, but the specific building location is approximated (often the centroid of the lot). The returned coordinate may be on the lawn, the driveway, or a corner of the lot rather than the building.

Parcel data comes from:

  • County-level cadastral records (US): millions of parcels nationwide, often available freely or via commercial aggregation services.
  • National land-registry systems (UK Ordnance Survey, HMLR; Germany ALKIS).
  • OSM building= tags applied to property polygons.

Parcel accuracy is ~10–20 m. For real-estate listings, property-tax records, and address verification, parcel is typically sufficient. For door-step navigation, rooftop is better.

Street-segment interpolated accuracy

When the geocoder doesn't have rooftop or parcel data, it falls back to street-segment interpolation. The algorithm:

  1. Identify the street segment containing the queried address.
  2. Look up the segment's address range (“Main St: 100–200 even on the north side”).
  3. Interpolate the position by linear proportion: address 150 is at 50 % of the way from one end of the segment to the other.

This is the canonical fallback for TIGER/Line-based US geocoding. Accuracy: ±20–50 m typically, depending on:

  • Block geometry: short urban blocks interpolate better than long rural ones.
  • Address spacing: uniform numbering interpolates better than gappy numbering.
  • Curvature: straight streets interpolate better than curved ones (the algorithm assumes a linear segment).

The geocoder typically flags interpolated results so the calling application can downgrade confidence accordingly.

Postal-code centroid

When no street-level match is found, the geocoder may fall back to the postal-code centroid — the geographic centre of the postcode area. Accuracy: highly variable.

In dense urban areas, a US ZIP code may cover a few square blocks; centroid accuracy ±100 m. In rural areas, a ZIP code may cover hundreds of square kilometres; centroid accuracy ±10 km. The centroid itself may not even be in a populated area.

ZIP-centroid geocoding is useful for marketing aggregation (census-level demographic mapping) and analytical work (broad geographic trends). It's misleading for delivery, dispatch, or any application that needs to know where a specific address actually is.

Per-provider taxonomies

Each major provider has its own accuracy taxonomy:

Mapbox

Mapbox returns a relevance score (0–1) and a categorical accuracy label per result:

  • rooftop — building footprint in database
  • parcel — property lot known
  • point — exact point geocoded
  • interpolated — street-segment interpolation
  • intersection — street intersection
  • street — street known, address not
  • place — city / town centroid
  • region — state / region
  • country — country

The Mapbox confidence bands (high / medium / low) are exposed in the Coordinately tools' result panels.

Google

Google's Geocoding API returns a location_type enum:

  • ROOFTOP — precise to a building
  • RANGE_INTERPOLATED — street-segment interpolation
  • GEOMETRIC_CENTER — centre of a region or polygon (typically when the input was a region rather than an address)
  • APPROXIMATE — approximate location only

Google also returns a partial_match boolean indicating whether the result was a fuzzy match (lower confidence).

HERE

HERE returns a matchLevel:

  • houseNumber
  • street
  • district
  • city
  • county
  • state
  • country

Plus a numerical matchQuality score for each component.

OpenStreetMap Nominatim

Nominatim returns:

  • class and type for the matched entity (e.g., class:place, type:house is a building match).
  • importance (0–1) for ranking.
  • No direct accuracy estimate; applications infer accuracy from the matched-entity type.

Filtering and ranking by tier

Best practice for applications:

Filter by minimum tier. A delivery app might require rooftop or parcel; a navigation app might accept street- segment-interpolated; a marketing app might accept ZIP centroid. Set the minimum tier as an application configuration; reject results below it.

Weight by tier in scoring. When choosing among multiple candidates, weight higher-tier matches more heavily. A rooftop match at low confidence might still be better than a street-segment match at high confidence, depending on the application.

Display the tier to users. The Coordinately tools expose the confidence tier alongside the coordinate, letting users see whether the result is rooftop-precise or postcode-approximate. Applications that hide the tier implicitly claim higher precision than they have.

Track tier degradation over time. As address data ages, rooftop matches may shift to parcel or interpolated (building demolished, new building not yet mapped). Periodic re-geocoding catches the drift.

Why higher accuracy isn't always available

Several reasons a geocoder might return a lower-tier match:

  • New construction: the building exists in reality but isn't in the geocoder's database yet. Commercial geocoders catch up via field surveys; OSM catches up via volunteer contributions.
  • Demolished addresses: the building is in the database but no longer exists. Results may still return rooftop but the precision is meaningless.
  • Informal addresses: rural, favela, or otherwise non-formal addresses don't have rooftop or parcel data. Best the geocoder can do is street-level or centroid.
  • Coverage gaps: some regions have sparse address data. India, sub-Saharan Africa, much of Latin America have significant coverage gaps.
  • Standardization failures: if input standardization fails to match the canonical form, the lookup falls back to broader (and less accurate) matches.

A worked example: same query, different tiers

Suppose three users query the same input at three different moments to three different geocoders:

Query: "123 Main St, Springfield IL 62701"

Geocoder A (premium commercial, top-tier):
  result: 39.7817°N, 89.6501°W
  tier: rooftop
  confidence: 0.95
  source: commercial address + building footprint database

Geocoder B (OpenStreetMap-based, regional coverage):
  result: 39.7820°N, 89.6498°W
  tier: parcel
  confidence: 0.75
  source: OSM addr:* tag on property polygon

Geocoder C (TIGER-only, US-only):
  result: 39.7825°N, 89.6505°W
  tier: street-segment interpolated
  confidence: 0.55
  source: TIGER address range 100–200

The same physical address (123 Main St) produces three different coordinates, all within ~50 m of each other. Application code that picks one without considering the tier silently inherits whichever tier's accuracy. Application code that uses the tier filter (“must be parcel or better”) rejects Geocoder C's result and accepts A or B.

The three coordinates are all “correct” — each is the geocoder's best estimate given its data. The question is whether the precision the application needs matches the precision the tier delivers.

Multi-tier fallback strategies

Some applications use a tiered fallback approach:

  1. Query the geocoder with min_tier=rooftop. If results exist, use them.
  2. If not, retry with min_tier=parcel. Use any result.
  3. If not, retry with min_tier=street-segment-interpolated.
  4. If not, log the address as ungeocodeable; do not substitute a ZIP centroid silently.

This pattern surfaces address-data quality issues to operations teams while still extracting maximum value from the geocoder. Applications that silently fall back to ZIP-centroid for every failure end up with a dataset of inconsistent precision that's hard to clean up later.

Common misconceptions

“A geocoder returns a single coordinate per address.” Returns a coordinate plus a tier. Two results both at “the address” can have very different accuracy — one rooftop, one interpolated, both showing the same coordinate format. The format hides the underlying accuracy difference.

“Confidence scores are comparable across providers.” They're not. Mapbox confidence 1.0 is not the same as Google's ROOFTOP. The taxonomies overlap conceptually but the specific scoring schemes are proprietary. For multi-provider applications, map each provider's tier into a common application taxonomy.

“ZIP-centroid geocoding is acceptable for addresses.” Acceptable for analysis at the ZIP-code level (demographics, market analysis). Not acceptable for delivery, dispatch, or any application requiring the actual address location. ZIP centroids can be 5–10 km from the target address in rural areas.

“Interpolation errors are random and cancel out.” Interpolation errors are systematic — they depend on the geometry of the block and the spacing of addresses. They don't cancel out when integrated over many addresses; the bias persists.

“Higher coordinate precision means higher accuracy.” Coordinate precision (decimal places of lat/lon) is a function of the geocoder's internal computation, not the source data accuracy. A street-segment- interpolated result at 7 decimal places is no more precise than at 4 decimal places — both are accurate to ±30 m of the true address, the trailing decimals are arithmetic artefacts. See /learn/precision-vs-accuracy-in-coordinates for the broader concept.

“The same input always returns the same tier.” Generally true but not always: providers update their data continuously. An address at parcel tier today might be promoted to rooftop next month as the geocoder ingests new building-footprint data.

Frequently asked questions

What are the standard geocoding accuracy levels?

From most to least accurate: rooftop (~5 m, the building footprint is in the database), parcel (~10–20 m, the property lot is mapped but the building approximated), street-segment interpolated (~20–50 m, the address number is interpolated along a street segment's address range), street-level (~50–100 m, the street is known but the specific number isn't), postal-code centroid (~1–5 km, only the postcode is known), city / locality (~5–50 km, only the city is known), and country / region (very broad fallback). Each provider has its own naming but the tiers map roughly across.

How do I get the highest-accuracy results?

Three factors. (1) Use a high-quality geocoder with proprietary address data — Google, Mapbox, HERE — over open-source-only solutions in markets where data quality matters. (2) Standardize the input first to maximise match quality. (3) Filter or rank by accuracy tier in your application: reject anything below street-segment-interpolated for navigation use cases; accept ZIP-centroid only for marketing or analytical work. The accuracy you can achieve is bounded by the database quality and the input completeness; standardization and filtering are the application-side levers.

Why does street-segment interpolation have ±20–50 m error?

Because the geocoder assumes addresses are evenly distributed along the street segment. In reality, building lot sizes vary; address numbering isn't always sequential (some blocks have only odd numbers, some have gaps); cul-de-sacs and irregularly shaped blocks deviate from the linear-interpolation assumption. The ±20–50 m bound is typical; in some areas it's better (10 m for short densely-numbered blocks), in others worse (100+ m for very long sparse blocks or rural roads). TIGER/Line is the canonical source for US street-segment data.

What is rooftop vs parcel accuracy?

Rooftop means the building footprint (the polygon outline of the building) is in the geocoder's database; the returned coordinate is at the building's centroid (often near the front door). Parcel means the property lot polygon is in the database; the returned coordinate is at the lot centroid, which may be on the lawn rather than the building. Rooftop is typically ±5 m of the door; parcel is typically ±10–20 m of the building. Both are 'precise' for most applications; the distinction matters for delivery (rooftop is the door), real-estate listings (parcel might still be the right answer), and emergency dispatch.

How do I interpret confidence scores?

Each provider has its own scoring scheme — they're not directly comparable. Mapbox returns a 0–1 confidence score with categorical bands (high, medium, low). Google returns location_type (ROOFTOP, RANGE_INTERPOLATED, GEOMETRIC_CENTER, APPROXIMATE) tied to specific accuracy levels. HERE returns matchLevel (houseNumber, street, postalCode, etc.). Within a single provider, the scores are useful for ranking and filtering; across providers, you have to map between taxonomies manually. The Coordinately tools surface confidence bands explicitly to expose this directly.

Sources

  1. US CensusTIGER/Line — accuracy documentation · https://www.census.gov/programs-surveys/geography/technical-documentation.html · Accessed .
  2. MapboxMapbox Geocoding API — confidence and accuracy · https://docs.mapbox.com/api/search/geocoding/ · Accessed .
  3. GoogleGoogle Maps Platform — Geocoding API location_type · https://developers.google.com/maps/documentation/geocoding/requests-geocoding · Accessed .
  4. HEREHERE Geocoding & Search — match level documentation · https://developer.here.com/documentation/geocoding-search-api/ · Accessed .

Cite this article

APA format:

Steve K. (2026). Geocoding Accuracy Levels. Coordinately. https://coordinately.org/learn/geocoding-accuracy-levels

BibTeX:

@misc{coordinately_geocodingaccuracylevels_2026,
  author = {K., Steve},
  title  = {Geocoding Accuracy Levels},
  year   = {2026},
  publisher = {Coordinately},
  url    = {https://coordinately.org/learn/geocoding-accuracy-levels},
  note   = {Accessed: 2026-06-05}
}