Coordable (Posts by François Andrieux)

String Distance Metrics for Address Comparison: Levenshtein, Damerau, Jaro, and Jaro-Winkler

François Andrieux — Wed, 01 Apr 2026 10:00:00 GMT

Comparing addresses is not a simple equality check

When you compare two address strings to decide if they refer to the same location, an exact match is rarely enough. Real-world addresses come with typos, abbreviations, inconsistent casing, and missing components. "15 Baker St" and "15 Baker Street" are the same address, but "15 Baker St" == "15 Baker Street" evaluates to False.

String distance metrics can be used to solve this problem. They assign a number to two strings that quantifies how different (or similar) they are. This number lets you set a threshold: "if the distance is less than 2, or the similarity is above 0.9, treat them as the same address."

In this guide, we cover the four most widely used metrics for address comparison:

Levenshtein distance - the classic edit distance
Damerau-Levenshtein distance - edit distance with transpositions
Jaro similarity - character matching with position awareness
Jaro-Winkler similarity - Jaro with a bonus for matching prefixes

For each one, we explain how it works, walk through a concrete address example, and discuss when it is (and is not) a good fit. At the end, a summary table and practical recommendations.

Table of contents:

A quick note before diving in

There are two flavors of metric:

Distance metrics (Levenshtein, Damerau-Levenshtein): return 0 for identical strings, and a higher integer for more different strings. Think of them as counting "how many operations to fix this?"
Similarity metrics (Jaro, Jaro-Winkler): return 1.0 for identical strings, and a lower value (down to 0.0) for more different strings. Think of them as "what fraction of characters match?"

Neither type is universally better. Which one to use depends on your data and your use case.

1. Levenshtein distance

How it works

The Levenshtein distance between two strings is the minimum number of single-character edits needed to transform one into the other. The allowed operations are:

Insertion: add a character (e.g., "Streeet" - one character - to "Street")
Deletion: remove a character (e.g., "Streeet" + one deletion - to "Street")
Substitution: replace one character with another (e.g., "Straat" - replace 'a' with 'e' - to "Street")

A distance of 0 means the strings are identical. A distance of 1 means a single operation is enough.

Address example

Compare "15 baker srteet" (a common keyboard transposition typo) to "15 baker street":

15 baker srteet
15 baker street

To fix "srteet" into "street", Levenshtein needs 2 substitutions: replace 'r' with 't' at position 9, and 't' with 'r' at position 10.

Distance = 2.

This is technically correct, but it feels like a lot for what is clearly a single typing mistake. We will fix this in the next section.

In Python

import jellyfish

jellyfish.levenshtein_distance("15 baker srteet", "15 baker street")
# → 2

Install with pip install jellyfish.

Pros and cons

Pros	Cons
Simple and well understood	Counts a transposition (swap of two adjacent chars) as 2 operations instead of 1
Handles insertions and deletions well (great for abbreviations like "St" vs "Street")	Raw distance is hard to compare across string pairs of different lengths
Available in virtually every language and library	Does not give extra weight to matching prefixes
Fast on short strings

When to use it for addresses

Levenshtein is a solid default, especially when the main source of variation is abbreviations or missing characters. Set a relative threshold to make comparisons fair across different string lengths:

def normalized_levenshtein(a, b):
    dist = jellyfish.levenshtein_distance(a, b)
    return dist / max(len(a), len(b))

# Treat as same address if < 15% different
normalized_levenshtein("15 baker street", "15 baker st") # → 0.267
normalized_levenshtein("15 baker street", "15 baker sreet") # → 0.067

2. Damerau-Levenshtein distance

How it works

Damerau-Levenshtein extends Levenshtein by adding one more operation:

Transposition: swap two adjacent characters (e.g., "srteet" to "street" - swap 'r' and 't')

This single addition makes a big practical difference. Studies of typing errors show that transpositions (adjacent character swaps) are one of the most frequent mistakes people make when typing by hand. Recognizing them as a single error rather than two substitutions gives a much more realistic picture of "how many mistakes did the user make?"

Address example

Same pair as before: "15 baker srteet" vs "15 baker street".

15 baker srteet
15 baker street
         ^^     ← 'rt' transposed to 'tr'

Damerau-Levenshtein distance = 1 (one transposition).

Compare this to the Levenshtein distance of 2 for the same pair. One error, one operation - much more intuitive.

Another example: "rue de al paix" vs "rue de la paix" (the words "al" and "la" are swapped - a common cut-and-paste error):

rue de al paix
rue de la paix
       ^^       ← 'a' and 'l' transposed

Levenshtein = 2, Damerau-Levenshtein = 1.

In Python

import jellyfish

jellyfish.damerau_levenshtein_distance("15 baker srteet", "15 baker street")
# → 1

jellyfish.damerau_levenshtein_distance("rue de al paix", "rue de la paix")
# → 1

Pros and cons

Pros	Cons
More realistic for human typing errors	Slightly more complex to implement from scratch
Transpositions (very frequent mistakes) cost 1, not 2	Same issue with raw distance across different string lengths
Strict superset of Levenshtein - always <= Levenshtein distance

When to use it for addresses

Prefer Damerau-Levenshtein over plain Levenshtein whenever your input comes from users typing addresses manually (web forms, search boxes, mobile apps). It gives a better answer to the question "how careless was this input?" and lets you set tighter thresholds while still tolerating common slip-of-the-finger errors.

3. Jaro similarity

How it works

Jaro takes a completely different approach. Instead of counting edit operations, it measures the proportion of characters that match between two strings, with a penalty for characters that are far apart or out of order.

Two characters are considered matching if: 1. They are the same character, and 2. Their positions are not too far apart. The maximum allowed distance between two matching characters is: floor(max(len(s1), len(s2)) / 2) - 1

Once you count the matching characters m and the number of matching characters that are out of order t (transpositions), the Jaro similarity is:

Jaro(s1, s2) = (1/3) * (m / |s1| + m / |s2| + (m - t) / m)

The result is between 0.0 (nothing matches) and 1.0 (identical).

Address example

Compare "church rd" (abbreviated) to "church road" (full form):

s1 = "church rd" (9 characters), s2 = "church road" (11 characters)
Matching window = floor(11 / 2) - 1 = 4

Every character in "church rd" can be matched to a character in "church road" within the window: c, h, u, r, c, h, (space), r, d all appear in the same relative order. So m = 9, t = 0.

Jaro = (1/3) * (9/9 + 9/11 + 9/9)
     = (1/3) * (1.000 + 0.818 + 1.000)
     ≈ 0.939

A similarity of 0.939 for what is clearly the same street, just abbreviated. That is the right answer.

In Python

import jellyfish

jellyfish.jaro_similarity("church rd", "church road")
# → ~0.939

jellyfish.jaro_similarity("main street", "mane street")  # typo: i→e
# → ~0.970

Pros and cons

Pros	Cons
Normalized score between 0 and 1 - easy to threshold	Formula is less intuitive than edit distance
Handles abbreviations and length differences naturally	Can give surprisingly high scores to long strings with many common characters
Well suited for comparing individual address components	Does not give extra weight to matching prefixes - we fix this with Jaro-Winkler

When to use it for addresses

Jaro is a good fit for comparing individual address fields (just the street name, just the city) rather than full concatenated address strings. It is also useful for detecting near-duplicate records in a database.

4. Jaro-Winkler similarity

How it works

Jaro-Winkler builds on Jaro by adding a prefix bonus: if two strings share the same first characters, their similarity is boosted. The motivation is that strings that start the same way are more likely to refer to the same thing than strings that diverge immediately.

The formula is:

JaroWinkler(s1, s2) = Jaro(s1, s2) + l * p * (1 - Jaro(s1, s2))

Where: - l = length of the common prefix, up to a maximum of 4 characters - p = scaling factor, conventionally 0.1

The effect is a modest upward adjustment when the prefix matches. With p = 0.1 and l = 4, the maximum bonus is +4 * 0.1 * (1 - Jaro), which boosts a Jaro of 0.90 by at most 0.04. Small but meaningful for ranking candidates.

Address example

Take "church rd" vs "church road" again (Jaro = 0.939, common prefix "chur", l = 4):

JaroWinkler = 0.939 + 4 * 0.1 * (1 - 0.939)
            = 0.939 + 0.4 * 0.061
            ≈ 0.963

Now consider two streets that differ at the very beginning:

"avenue du general leclerc" vs "boulevard du general leclerc"

These share no prefix at all (l = 0), so Jaro-Winkler equals Jaro exactly. No bonus is applied, and the score is lower than it would be for two strings with the same beginning. This is exactly the intended behavior: a difference at the start is a stronger signal of a mismatch than a difference in the middle.

Now consider a house number mismatch:

"12 rue de la paix" vs "21 rue de la paix": the prefix is "1" vs "2", so l = 0. The score penalizes the mismatch at the start, which is what we want - these are two completely different addresses.

In Python

import jellyfish

jellyfish.jaro_winkler_similarity("church rd", "church road")
# → ~0.963

jellyfish.jaro_winkler_similarity("12 rue de la paix", "21 rue de la paix")
# → ~0.980  (lower score due to no prefix match)

jellyfish.jaro_winkler_similarity("12 rue de la paix", "12 rue de la pai")
# → ~0.988  (strong prefix, only one char missing at end)

Pros and cons

Pros	Cons
Prefix bonus aligns with how we read addresses (number first, then street name)	Prefix bonus requires consistent formatting - mixed case will kill the bonus
Often more accurate than plain Jaro for addresses and proper names	`p = 0.1` is conventional; tuning it for your data takes experimentation
Normalized 0-1 score, easy to threshold	Like Jaro, harder to explain to non-technical stakeholders than edit distance

When to use it for addresses

Jaro-Winkler is the best general-purpose choice for full address comparison when strings are properly normalized (lowercase, consistent formatting). The prefix bonus is particularly useful when the house number is at the start of the string - it correctly penalizes address strings that start with different numbers, since those represent different physical locations regardless of the rest.

Summary table

Metric	Type	Score range	Transpositions	Prefix bonus	Best for
Levenshtein	Distance	0 to +inf	Costs 2	No	Abbreviations, insertions, deletions
Damerau-Levenshtein	Distance	0 to +inf	Costs 1	No	User-typed input, keyboard typos
Jaro	Similarity	0 to 1	Handled	No	Individual address fields
Jaro-Winkler	Similarity	0 to 1	Handled	Yes (up to 4 chars)	Full normalized address strings

Quick decision guide:

User types addresses into a form - use Damerau-Levenshtein. Transpositions are very common in manual input.
You are deduplicating a database of street names - use Jaro or Jaro-Winkler on the street name component alone.
You want a single score for a full address string - use Jaro-Winkler on normalized strings.
Your main problem is abbreviations ("Blvd" vs "Boulevard") - normalize abbreviations first (see below), then any metric will do.

Normalization: the step that matters more than metric choice

No string metric can compensate for what normalization ignores. Before comparing two addresses, apply at least these basics:

Lowercase everything: "Baker Street" and "baker street" should score 1.0, not 0.9.
Expand abbreviations consistently: "St" -> "street", "Blvd" -> "boulevard", "Ave" -> "avenue", "Rd" -> "road". Or shorten everything to a consistent short form.
Remove punctuation: "St. James's" and "St Jamess" will score very differently if you keep periods and apostrophes.
Normalize whitespace: collapse multiple spaces, strip leading/trailing whitespace.

With these steps, "15 Baker St." and "15 Baker Street" become "15 baker street" and "15 baker street" - identical strings that score perfectly on any metric.

import re

def normalize_address(addr):
    addr = addr.lower()
    addr = re.sub(r"[.,'\-]", "", addr)
    addr = re.sub(r"\bst\b", "street", addr)
    addr = re.sub(r"\bblvd\b", "boulevard", addr)
    addr = re.sub(r"\bave\b", "avenue", addr)
    addr = re.sub(r"\brd\b", "road", addr)
    addr = re.sub(r"\s+", " ", addr).strip()
    return addr

normalize_address("15 Baker St.")   # "15 baker street"
normalize_address("15 Baker Street")  # "15 baker street"

After normalization, both strings are identical and any metric returns a perfect score.

Putting it all together: a complete address comparison

Here is a short example that combines normalization with all four metrics:

import jellyfish
import re

def normalize_address(addr):
    addr = addr.lower()
    addr = re.sub(r"[.,'\-]", "", addr)
    addr = re.sub(r"\bst\b", "street", addr)
    addr = re.sub(r"\bblvd\b", "boulevard", addr)
    addr = re.sub(r"\bave\b", "avenue", addr)
    addr = re.sub(r"\brd\b", "road", addr)
    addr = re.sub(r"\s+", " ", addr).strip()
    return addr

pairs = [
    ("15 Baker St.", "15 Baker Street"),
    ("15 Baker Srteet", "15 Baker Street"),
    ("12 Rue de la Paix", "21 Rue de la Paix"),
    ("Church Rd", "Church Road"),
]

for a, b in pairs:
    na, nb = normalize_address(a), normalize_address(b)
    lev = jellyfish.levenshtein_distance(na, nb)
    dlev = jellyfish.damerau_levenshtein_distance(na, nb)
    jaro = jellyfish.jaro_similarity(na, nb)
    jw = jellyfish.jaro_winkler_similarity(na, nb)
    print(f"{a!r} vs {b!r}")
    print(f"  Levenshtein: {lev}, Damerau-Levenshtein: {dlev}")
    print(f"  Jaro: {jaro:.3f}, Jaro-Winkler: {jw:.3f}")

Expected output:

'15 Baker St.' vs '15 Baker Street'
* Levenshtein: 0, Damerau-Levenshtein: 0  # normalization made them identical
* Jaro: 1.000, Jaro-Winkler: 1.000

'15 Baker Srteet' vs '15 Baker Street'
* Levenshtein: 2, Damerau-Levenshtein: 1  # one transposition, not two substitutions
* Jaro: 0.978, Jaro-Winkler: 0.987

'12 Rue de la Paix' vs '21 Rue de la Paix'
* Levenshtein: 2, Damerau-Levenshtein: 1  # different house number
* Jaro: 0.980, Jaro-Winkler: 0.980        # no prefix bonus (1 != 2)

'Church Rd' vs 'Church Road'
* Levenshtein: 0, Damerau-Levenshtein: 0  # normalization expanded Rd -> Road
* Jaro: 1.000, Jaro-Winkler: 1.000

Note how the normalization step handles "St" vs "Street" and "Rd" vs "Road" completely, leaving the metrics to handle what normalization cannot catch (typos, transpositions, genuine differences).

Where to go from here

String similarity metrics are one tool in the address quality toolbox. In geocoding workflows, they are commonly used to:

Verify that a geocoded result actually matches the input address (compare the returned address label to the input).
Deduplicate address lists before batching geocoding requests.
Build fuzzy search over a local address database before calling a paid API.

If you are working on address data quality as part of a geocoding pipeline, these resources may also be useful:

Learn how to geocode large batches cost-effectively: How to reduce geocoding costs by 67%
See what geocoding providers are available and how their prices compare: Geocoding prices in 2026
Find the best geocoding provider for your country: Best geocoding providers for France, UK, Germany

Try address geocoding with Coordable

US Census + Google Maps: How to cut geocoding costs by 90% for US addresses

François Andrieux — Sat, 21 Mar 2026 10:00:00 GMT

The setup

We wanted to test the effectiveness of a cascading geocoding strategy for US addresses. We took 1,000 real US addresses (a mix of residential and business addresses, of variable quality but overall correct) and ran three geocoding tests.

Here is the summary of the results:

Test	Provider(s)	Addresses resolved	Cost per 1,000
1	US Census only	91.9%	$0.00
2	Google Maps only	92.6%	$5.00
3	US Census → Google Maps (cascade)	97.3%	$0.41

The cascade delivers 97.3% addresses found at $0.41, compared to $5.00 for Google Maps alone. That is a 90% cost reduction with a +5.4 percentage point improvement in addresses resolved. Amazing right?

Read on to see how each test was run and what the results look like.

Table of contents:

Test 1: US Census Geocoder

What is the US Census Geocoder?

The US Census Geocoder is a public and free API provided by the US federal government. It is not open source (the underlying software and data are maintained by the Census Bureau), but it is freely accessible, requires no API key, and has no published usage limits or cost.

It is built on TIGER/Line data, the official US address dataset. Results are interpolated on the street rather than placed at the exact building location (no rooftop precision). For most use cases (delivery routing, territory analysis, customer mapping), street-level interpolation is entirely sufficient.

The output data is in the public domain, with no licensing restrictions on how you store or use the coordinates.

Important limitation: US Census only understands structured street addresses. It cannot geocode points of interest, business names, or company names. If your dataset contains entries like "Starbucks, Chicago" or "Boeing headquarters", US Census will return nothing for those rows. In that case, the 90% cost reduction figure will not hold: a commercial provider will need to handle a much larger share of your requests. This strategy works best for datasets of clean street addresses ; see below for a solution.

Results

Accuracy: 91.9% (919 out of 1,000 addresses resolved)
Cost: $0.00

Test 1, US Census only: 919/1,000 addresses resolved, at no cost.

91.9% is a strong result for a free API. The 8.1% of unresolved addresses are typically due to non-standard formatting, missing components, or addresses that simply do not appear in the TIGER/Line dataset.

Test 2: Google Maps Geocoding API

What is Google Maps Geocoding?

Google Maps is one of the most widely used geocoding providers. At $5.00 per 1,000 addresses (after the free quota), it is also one of the most expensive.

It returns different precision levels: ROOFTOP for exact building locations, and RANGE_INTERPOLATED for street-level interpolation. For a fair comparison with US Census, which only returns street-level results, we accept both ROOFTOP and RANGE_INTERPOLATED in this test.

Licensing note: Google Maps results come with significant restrictions beyond the price. Google's Terms of Service do not allow you to store geocoded coordinates long-term or use them outside of a Google Maps display context. If you need to build a database of geocoded addresses, use the results in a non-Google mapping tool, or export coordinates for analysis, you may be violating Google's terms. This is an important constraint to factor in before committing to Google as your primary geocoding provider.

Note: Google free quota is excluded from these cost figures, as its effective value depends on overall usage across all Google Maps products. The $5.00 figure reflects the standard pay-as-you-go rate.

Results

Accuracy: 92.6% (926 out of 1,000 addresses resolved)
Cost: $5.00

Test 2, Google Maps only: 926/1,000 addresses resolved at ROOFTOP or RANGE_INTERPOLATED level, at $5.00 per 1,000.

Google Maps edges out US Census by 0.7 percentage points (92.6% vs 91.9%), but at a cost of $5.00 per 1,000 addresses vs $0. For this dataset, paying for Google Maps buys very little extra accuracy on its own.

Test 3: US Census + Google Maps (cascade)

How the cascade works

The cascading strategy is straightforward:

Send every address to US Census first. If US Census returns a valid result, use it. Cost: $0.
For addresses that US Census could not resolve, send them to Google Maps. Cost: $5.00 per 1,000 for this subset only.

In our test, approximately 90% of addresses were resolved by US Census (free), and only ~8% required Google Maps, at a total cost of $0.41. The remaining ~2.7% were not resolved by either provider.

This is why the cost drops so dramatically: instead of paying $5.00 for every address, you only pay Google's rate for the small fraction that US Census could not handle.

The two-provider cascade configured in Coordable: US Census first, then Google Maps for unresolved addresses, accepting both ROOFTOP and RANGE_INTERPOLATED results.

Results

Accuracy: 97.3% (973 out of 1,000 addresses resolved)
Cost: $0.41
Provider split: ~90% resolved by US Census · ~8% resolved by Google Maps · ~2.7% unresolved

Test 3, US Census → Google Maps cascade: 973/1,000 addresses resolved, at $0.41 per 1,000.

The cascade delivers a +5.4 percentage point improvement over either provider alone, at 8% of the cost of Google Maps. The key insight is that US Census and Google Maps fail on different addresses. Addresses that US Census cannot parse or match are often resolved by Google's more robust parsing engine, and vice versa.

Set up cascading geocoding with Coordable

Going further: adding a third provider

This two-provider cascade already delivers strong results, but you can push accuracy even higher by adding a third provider.

For example, adding HERE as a second fallback (after Google Maps) would catch some of the 2.7% of addresses that neither US Census nor Google resolved. HERE has strong US address coverage and is significantly cheaper than Google Maps at $0.83 per 1,000 addresses. A three-provider cascade (US Census → Google Maps → HERE) would likely push accuracy above 97.3% while keeping the overall cost low, since HERE would only handle the tiny fraction of addresses that both previous providers missed.

We ran a similar experiment with French addresses using the BAN API (the French government geocoder), Google Maps, and HERE, and achieved 97.7% accuracy at $1.62 per 1,000, a 67% cost reduction compared to Google alone. The principle is identical: route easy addresses through the cheapest provider, and reserve expensive providers for the hard cases. See How to reduce geocoding costs by 67% for the full breakdown.

Conclusion

For US address geocoding, the US Census Geocoder is a powerful and underused tool. It is free, requires no API key, and handles the vast majority of clean street addresses correctly. Pairing it with Google Maps as a fallback gives you the best of both worlds: near-complete coverage at a fraction of the cost.

Test	Provider(s)	Found	Cost per 1,000
1	US Census only	91.9%	$0.00
2	Google Maps only	92.6%	$5.00
3	US Census → Google Maps (cascade)	97.3%	$0.41

The key caveat: this strategy works for street address datasets. If your data contains business names, POIs, or unstructured inputs, US Census will not help and you will need a commercial provider for a larger share of requests.

However, it would have been possible to plug a low-cost provider to handle the remaining addresses as well : HERE, Nominatim (OSM), OpenCage, etc.

If you want to implement this cascade without writing custom code, Coordable lets you configure multi-provider workflows with quality rules at each step, so only good results pass through.

Try cascading geocoding with Coordable

Where to go from here

See how the same cascading approach cuts costs by 67% for French addresses: How to reduce geocoding costs by 67%
Compare geocoding prices across all major providers: Geocoding prices in 2026
Learn more about Google Maps Geocoding: Google Maps Geocoding API

How to reduce geocoding costs by 67%

François Andrieux — Sun, 08 Mar 2026 10:00:00 GMT

The use case: a logistics company paying way too much for geocoding

If you work in logistics, insurance, or routing software, you know the drill: geocoding volumes are massive, and the bills that come with them are too.

In this article, we show how Coordable helped a logistics company cut geocoding costs by 67% while also increasing its share of valid geocoding results from 94% to 97.7%. Total savings: $20,280 per year. 🤩

Let's dive in.

Table of contents:

The problem: choosing between cost and quality

You have probably faced this tradeoff: premium providers like Google Maps deliver excellent results, but they come at a price. Cheaper alternatives may leave some addresses unresolved.

Most of the time, though, you do not actually need the premium option; addresses are clean and unambiguous, so any decent geocoder will do the job. The real challenge appears when your address data is messy: in those cases, you are forced to choose between paying for Google Maps to guarantee correct results, or accepting that a cheaper provider will miss some.

The solution: cascading providers

Good news: there is a strategy that gives you the best of both worlds, cascading geocoders. The principle is straightforward:

Use an open-source or low-cost provider for ~90% of geocoding requests (the clean, unambiguous addresses).
Use a premium geocoder (or several) to resolve the remaining ~10%.

This approach raises geocoding success rates while keeping costs down. In our case, it reduced costs by 67% and increased the share of successfully geocoded addresses by +3.7%. Here is how we did it.

The workflow: 3 providers

Our logistics client needed to geocode mostly residential addresses in France. France has an excellent government API for this purpose, the Base Adresse Nationale (BAN), which covers French residential addresses very well, though it does not handle points of interest or addresses outside France. Many commercial providers actually use BAN data to improve their own results.

The downside of BAN's API is that it is less robust at parsing and matching poorly formatted input. So we still needed to pair it with at least one commercial provider to ensure no addresses slip through. For that, we chose Google Maps. Finally, we added HERE as a second fallback because HERE also leverages BAN data, making it a strong option for the French addresses that Google could not resolve to rooftop level.

Here is our strategy:

French BAN: confidence score > 0.75 required.
Google Maps API: ROOFTOP location type required (if not resolved in step 1).
HERE: confidence score > 0.75 required (if not resolved in step 2).

The three-provider cascade configured in Coordable: BAN → Google Maps → HERE, each step gated by a quality rule.

We apply quality rules at each step to discard results that are not good enough. For French BAN and HERE, the confidence score reflects how closely the geocoder matched the input string. Although computed slightly differently across providers, both scores are a reliable way to filter out poor results. Setting the threshold at 0.75 is fairly strict, but the cascade makes this safe; any address rejected at one step simply moves to the next provider.

Google Maps does not provide a confidence score, so instead we filter on the location type returned (ROOFTOP, APPROXIMATE, GEOMETRIC_CENTER). For residential addresses, we require ROOFTOP only, to ensure the coordinates are placed in front of the building rather than somewhere in the middle of the street.

The results

To measure the impact, we ran two geocoding sessions on the same dataset and compared them:

Google Maps only: the client's initial setup.
Cascading strategy: BAN → Google Maps → HERE.

The test dataset contains 1,000 residential addresses, mostly clean and well-formed. That is large enough to get a reliable picture of how this strategy performs at scale.

In practice, the client geocodes about 500,000 addresses per month.

Session 1: Google Maps only

Session 1, Google Maps only: 940/1,000 addresses resolved at ROOFTOP level, at $5 per 1,000.

Results:

94% valid geocoding results (addresses resolved to ROOFTOP).
Estimated cost: $5.00 per 1,000 addresses.

Note: these costs ignore the Google free quota, which is shared across all Google Maps products. Its effective value depends on each client's overall usage, so we exclude it for a fair comparison.

Session 2: BAN + Google Maps + HERE (cascading)

Session 2, Cascading strategy: 977/1,000 addresses resolved, at $1.62 per 1,000.

Results:

97.7% valid geocoding results, a +3.7% improvement.
Estimated cost: $1.62 per 1,000 addresses.

Provider breakdown: BAN 64.5% · Google Maps 31.7% · HERE 3.8%

Using BAN means that 64.5% of addresses cost nothing to geocode. Our strict rules then sent 31.7% of addresses to Google Maps, and HERE handled the remaining 3.8%.

Total cost reduction: 67%, while improving geocoding quality.

Yearly cost savings

At 500,000 addresses per month, the client was spending about $2,500/month on Google Maps alone. With the cascading strategy, that bill drops to $810/month, without any loss of quality; on the contrary.

	Monthly cost	Annual cost
Google Maps only	$2,500	$30,000
Cascading (BAN + Google + HERE)	$810	$9,720
Savings	$1,690	$20,280

That is $20,280 saved per year, while resolving +3.7% more addresses correctly.

Conclusion

If you are paying Google Maps rates for every address, you are likely overpaying. This real-world example shows how large the gap can be: by routing the bulk of clean French addresses through the free BAN API, reserving Google Maps for harder cases, and using HERE as a final safety net, the client went from 94% to 97.7% geocoding success while paying 67% less.

The key is combining the right providers in the right order, and enforcing quality rules at each step so only genuinely good results pass through. The result is a system that is both cheaper and more reliable than relying on a single provider.

Set up cascading geocoding with Coordable

Where to go from here

Learn more about the providers used in this workflow: Google Maps Geocoding API, HERE Geocoding API.
See how providers compare in France: Best geocoding providers for France.
Compare Google and HERE head-to-head: Google vs HERE for geocoding.
See current geocoding prices at a glance: Geocoding prices in 2026.

HERE price increase by 6% in 2026

François Andrieux — Fri, 06 Mar 2026 12:00:00 GMT

HERE Technologies is updating its pricing from April 2026. This post summarizes what matters for geocoding users: effective date, what changes, and who is affected.

Table of contents:

What HERE announced

From April 1, 2026, the price of the HERE Base Plan will increase by 6% for new contracts, renewals, and extensions. Existing contracts remain unchanged until renewal or extension.

HERE Technologies communicated the following:

The prices of all 35 HERE Location Services and Data IO using the pay-per-transaction model will increase by 6%.
This price increase applies to all new subscriptions and (auto-)renewals from April 1, 2026 onwards.
The price of the Developer technical support plan remains unchanged.
These pricing updates will be reflected in all future contracts and invoices from April 1, 2026 onwards.

What this means for you

If you sign a new contract or renew on or after April 1, 2026, you will see the new 6% pricing. For coverage, rate limits, licensing, and current pricing details, see our HERE Geocoding API guide.

Where to go from here

HERE Geocoding API — coverage, rate limits, and licensing.
Geocoding prices in 2026 — compare HERE with other providers.
Google vs HERE for geocoding — head-to-head comparison.

Geocoding prices in 2026

François Andrieux — Fri, 06 Mar 2026 10:00:00 GMT

Here’s a clear overview of what the main geocoding services cost in 2026, and whether anything changed recently. Use the table and the interactive chart below to compare prices at a glance and to simulate your costs. 🙂

Table of contents:

Pricing overview

Roughly what you pay after the free tier (per 1,000 requests, in USD). Free tiers and volume discounts vary; check each provider for exact terms.

Provider	Free tier	Price per 1,000 (after free)	Note
Google Maps	10,000/month	$5.00	Volume discounts; see March 2025 changes below.
HERE	30,000/month	$0.83	Volume discounts; 6% increase from April 2026 for new contracts and renewals.
TomTom	2,500/day (~75k/month)	$0.75	Volume discounts.
Mapbox (Temporary)	100,000/month	$0.75	Temporary results only; no long-term storage.
Mapbox (Permanent)	—	$5.00	Allows indefinite storage of results.
OpenCage	2,500/day (~75k/month)	from ~$0.15–0.17	Subscription-based; volume discounts. Permissive storage.
Nominatim (OSM)	Public API rate-limited	Free	Self-hosting has infra costs.

Many countries also have free or low-cost official APIs (e.g. France's BAN, Spain's CartoCiudad, UK's OS Places under certain schemes). For local addresses, check our country-specific comparisons linked at the end.

Compare costs at your volume

The difficulty is that most providers have different pricing tiers and different free tiers. So you need to know exactly how many addresses you need to geocode to know which provider is the cheapest. Also, prices typically decrease as volume increases, so your per-request cost depends heavily on your total usage.

You can simulate your costs with the interactive chart below. Just select the number of addresses you need to geocode and the chart will show you the cost per provider!

Did prices change?

Google (March 2025): Google replaced the previous $200/month credit with per-SKU free usage (e.g. around 10,000 free billable events per month for the Geocoding API). Volume discount tiers were expanded for high usage. So the effective free tier for geocoding is lower than before, but heavy users can see lower marginal costs at scale. Details: Google Maps Geocoding API guide and Google Maps Platform March 2025 changes.

HERE (April 2026): From April 1, 2026, the HERE Base Plan and all pay-per-transaction Location Services and Data IO increase by 6% for new contracts, renewals, and extensions. Existing contracts are unchanged until renewal. See HERE price increase by 6% in 2026 for details.

Other major providers: TomTom, Mapbox, and OpenCage have kept their published pricing stable into 2026. Our source dates in the repo are October 2025 / January 2026; always confirm current prices on each provider’s site before committing.

How to reduce geocoding cost

Relying on a single premium provider (e.g. Google at $5 per 1,000 requests) can become very expensive at scale. A proven way to cut costs without sacrificing quality is cascading geocoders: use several providers in a defined order, and only fall back to the next when the current one fails or does not meet your criteria.

What is cascading? You define an ordered list of providers (e.g. OpenStreetMap or OpenCage → HERE → Google). For each address, you try the first provider; if that fails or the result does not pass validation, you automatically try the next one, and so on. Cheaper or free providers handle the bulk of easy addresses; premium providers are used only for the harder cases. The result: higher success rates (often 98–99% instead of ~90% with one provider) and lower total cost, because most requests are served by the least expensive option.

Reduce your costs with Coordable cascading geocoding

The diagram below illustrates the idea: send 100% of requests to a free or low-cost provider first (e.g. OSM); only the unresolved share (e.g. 10%) goes to a mid-tier provider (e.g. HERE); and only the remainder (e.g. 4%) hits the premium provider (e.g. Google). You still reach a very high overall geocoding rate (e.g. 99.9%) while paying the premium rate for a small fraction of traffic.

Cascading geocoders: prioritize cheap or free providers, fall back to premium only when needed. Quality and cost scale with each step.

You can implement cascading in your own code (call provider A, then B on failure, etc.) or do it easily with Coordable: choose your providers, define the cascade order and fallback rules, and optionally validate results so only good coordinates reach your database. Either way, the principle is the same: prioritize cheaper solutions and only fall back to premium when it is truly necessary.

Try Coordable to easily implement cascading geocoding for your business.

Price is not everything

Pricing does not always reflect quality. The cheapest option is not necessarily the worst, and some geocoders can match or beat large commercial providers depending on region and data type (addresses vs POIs, local vs global). To see how providers actually perform where you operate, check the best geocoding provider for your country. We have in-depth comparisons for:

Where to go from here

For more detail on a single provider (coverage, rate limits, licensing), see our guides: Google Maps Geocoding API, HERE Geocoding API, Mapbox Geocoding API. For a head-to-head in 2026, see Google vs HERE for geocoding.

UK Address and Postal Data FAQ: AddressBase, UPRN, PAF, and PSGA Explained

François Andrieux — Sun, 02 Nov 2025 10:00:00 GMT

If you work with UK addresses, you've probably encountered terms like AddressBase, UPRN, PAF, and PSGA. These are fundamental components of the UK's address infrastructure, but they can be confusing.

This FAQ answers the most common questions about UK address and postal data systems. I hope it will help you as it helped me! 🙂

Looking for practical geocoding solutions? See our comparison of UK geocoding providers to find the best API for your needs.

Table of contents:

What is a UPRN?

UPRN stands for Unique Property Reference Number. It's a unique 12-digit identifier assigned to every addressable location in Great Britain (England, Scotland, and Wales).

Each property has one UPRN that never changes, even if the address changes. These are simple 12-digit numbers (e.g., 100023336956) that cover residential homes, commercial buildings, sheds, garages, and even mailboxes. The system is managed by GeoPlace, a partnership between the Local Government Association and Ordnance Survey.

Example: the 10 Downing Street UPRN is 10008517798 (source)

For example, 100023336956 is the UPRN for 10 Downing Street, London SW1A 2AA (the Prime Minister's residence). Even if the building's use or occupant changes, this 12-digit identifier remains constant, ensuring consistent identification across all government systems and databases.

This UPRN is associated to the 8400071 USRN (Unique Street Reference Number) for the street "Downing Street".

What is a USRN?

USRN stands for Unique Street Reference Number. It's a unique identifier assigned to every street in Great Britain, that can go up to 10 digits long.

Each street has one USRN that never changes, even if the street name changes. For example, 8400071 is the USRN for the street "Downing Street".

Why do UPRNs exist?

Using addresses as identifiers is problematic because:

Addresses change: Streets get renamed, building numbers change
Typos and variations: "High St", "High Street", "HIGH STREET" are all the same place
Inconsistent formatting: Different systems store addresses differently

UPRNs solve this by providing a stable, unique identifier that connects all systems and databases.

For example, if 123 High Street, London is renamed to 123 King Avenue, London, the UPRN remains the same (e.g., 100023336956). This allows:

Government records to stay linked
Utility companies to maintain service history
Emergency services to find the correct location
Council tax records to remain accurate

How to check for a UPRN?

You can use the website uprn.uk to check for a UPRN.

Example lookup for the UPRN 100023336956 (source)

What is AddressBase?

AddressBase is the most comprehensive and authoritative address database for Great Britain, maintained by Ordnance Survey.

AddressBase combines UPRNs, addresses, coordinates, and property metadata into a comprehensive database.

It contains all UPRNs (every property's unique identifier), full addresses (building number/name, street, locality, town, postcode), geographic coordinates (latitude and longitude in British National Grid and WGS84), property classification (residential, commercial, etc.), local authority information (which council area the property belongs to), and multiple address formats (official address, alternative names, historical addresses).

What are the different AddressBase products?

Ordnance Survey offers three AddressBase products with varying levels of detail:

AddressBase Core provides basic address information with UPRNs and coordinates, suitable for simple address lookup and validation.

AddressBase Plus is an enhanced dataset with additional address details, multiple address formats (e.g., Welsh language variants), and property status information.

AddressBase Premium is the most comprehensive dataset, including full address history, alternative addresses (e.g., previous names), detailed metadata and relationships. It's best for complex applications requiring complete address intelligence.

Can you give an example of AddressBase data?

Here's a sample record from AddressBase Plus showing an address in Exeter, United Kingdom:

uprn: 10094201708
udprn: ""
parent_uprn: 55508903
sub_building: "FLAT 404"
building_name: "CLIFFORD HOUSE"
building_number: ""
dependent_thoroughfare: ""
thoroughfare: "STADIUM WAY"
double_dependent_locality: ""
dependent_locality: ""
post_town: "EXETER"
postcode: "EX4 6AX"
rpc: "S"
coordinates:
  x: 292839.08
  y: 093519.86
  latitude: 50.7313689
  longitude: -3.5197896
classification: 2
status: "E"
state: "I"
dates:
  start_date: 2018-07-03
  last_update: 2019-11-20
  entry_date: 2020-06-13
record_type: "R"

This record represents Flat 404, Clifford House, Stadium Way, Exeter EX4 6AX, with coordinates and metadata showing when the address was created and last updated.

What is Royal Mail PAF?

PAF stands for Postcode Address File. It's Royal Mail's database of all "delivery points" (addresses that receive mail) in the UK.

Managed by Royal Mail (the UK's postal service), PAF is delivery-focused and contains only addresses where mail is delivered. It's updated regularly to reflect new builds and address changes, covers all UK countries (England, Scotland, Wales, and Northern Ireland), and every address is linked to its postcode.

Each PAF record contains: building name/number, street name, locality, town, county, postcode, and a delivery point suffix (DPS) — a unique identifier within a postcode.

PAF vs AddressBase: What's the difference?

Let's take an example:

Feature	Royal Mail PAF	AddressBase
Coverage	UK (including Northern Ireland)	Great Britain only (England, Scotland, Wales)
Focus	Mail delivery points	All addressable locations
Identifier	Postcode + DPS	UPRN
Includes	Only addresses receiving mail	All properties (including non-postal)
Managed by	Royal Mail	Ordnance Survey / GeoPlace
Coordinates	Not included (usually)	Included

To illustrate: a property might be in PAF if it receives mail (e.g., 123 High Street, London SW1A 1AA), but in AddressBase whether or not it receives mail (e.g., a shed, garage, or temporary structure). Some properties (like construction sites or private roads) may have a UPRN but no PAF entry because Royal Mail doesn't deliver there.

Is AddressBase free and open data?

Short answer: Partially open — it depends on who you are and how you'll use it.

✅ Free access:

For UK public sector organizations, AddressBase is available through the Public Sector Geospatial Agreement (PSGA) (see below about this). This includes AddressBase Core and Plus, free to use for public sector purposes.

For others, some local authorities publish UPRN data as open data (not universal), and Ordnance Survey's OpenData products exist, but AddressBase is NOT included.

💰 Paid licenses required:

For commercial use, businesses need a paid license. Various developer license tiers are available based on usage volume. AddressBase Premium requires a paid license even for many public sector uses beyond basic PSGA coverage.

Important note: While UPRN itself is just a number, accessing the full database requires licensing. Using UPRNs in your application may require a license even if you obtain them elsewhere. Always check current terms on the Ordnance Survey website.

Is Royal Mail PAF free and open data?

No, PAF is not free or open data. Royal Mail licenses PAF commercially (see Royal Mail PAF pricing).

You can access PAF in three ways: directly from Royal Mail (various commercial licenses available, with pricing based on usage and application type, offering the full dataset or subsets for specific regions), through licensed resellers (many address validation and geocoding providers like Loqate, Postcode Anywhere, and Ideal Postcodes license PAF, allowing you to access it indirectly through their APIs), or for public sector (some limited access via PSGA, often supplemented with AddressBase).

Check out our comparison of UK geocoding providers to find the best API for your needs.

Royal Mail is a commercial company, and PAF is valuable intellectual property. Maintaining and updating the database requires significant resources, funded through licensing fees.

What is the Public Sector Geospatial Agreement (PSGA)?

The PSGA is a UK government initiative that provides free access to Ordnance Survey data for public sector organizations.

Who qualifies? UK public sector organizations, including central government departments, local councils and authorities, NHS organizations, police and fire services, educational institutions (schools, universities), and other public bodies.

What data is included? The PSGA provides access to AddressBase Core (free), AddressBase Plus (free), AddressBase Premium (limited access, may require additional licenses), OS MasterMap and other Ordnance Survey datasets, plus API access for online services.

What are the terms? The data is free to use for public sector business but cannot be shared with commercial third parties, cannot be resold or used for purely commercial purposes, and must be used for public sector functions.

How to access PSGA data: Check if your organization qualifies, register on the Ordnance Survey website, download data or access APIs, and use in compliance with PSGA terms.

What are the alternatives to AddressBase and PAF?

If you need free or open UK address data, consider these alternatives:

OpenAddresses UK is a crowdsourced, open-source address database with good coverage in many areas (though not complete), available under open data (public domain) license at openaddresses.io.

OpenStreetMap (OSM) offers community-maintained map data with UK addresses. Coverage varies by area (excellent in cities, patchy in rural areas), licensed under ODbL (Open Database License), accessible at openstreetmap.org.

ONS Postcode Directory (ONSPD) from the Office for National Statistics provides all UK postcodes with geographic info under the Open Government License at ONS Geoportal. Note: it contains postcodes and coordinates, not full addresses.

Local Authority open data: Some councils publish their address data (coverage varies widely by council), usually under the Open Government License. Check individual council open data portals.

Good to know: AddressBase and PAF are more complete and accurate, commercial data is updated more frequently, licensed data comes with support while open data is "as-is", and commercial licenses are clear while open data usage can be complex.

How do UPRN, AddressBase, and PAF work together?

In short, they complement each other in the UK address ecosystem.

Here's an example workflow: imagine a utility company needs to manage customer accounts. A customer signs up with address "10 Downing Street, London SW1A 2AA". The system looks up the address in AddressBase, gets UPRN 10008517798 and coordinates 51.5034, -0.1276, validates the postcode using PAF to confirm it's a mail delivery point, stores the UPRN as the primary identifier, and links all services to this UPRN (billing, service calls, maintenance history).

The UK address ecosystem: UPRNs identify properties, AddressBase provides comprehensive data, and PAF focuses on mail delivery.

The benefits are clear: if the address changes, the UPRN stays the same; coordinates enable field service routing; the postcode confirms mail delivery is possible; and there are no duplicate customer records.

Which should I use: AddressBase or PAF?

It depends on your use case:

Use PAF if you need postcode validation, mail delivery confirmation, address formatting for postal services, Northern Ireland addresses, or simple address lookup by postcode.

Use AddressBase if you need UPRNs for data linking, geographic coordinates, all addressable locations (not just postal), property classification, local authority boundaries, or historical address data.

Use both if you need complete address intelligence, geocoding with postal validation, maximum coverage and accuracy, or integration with multiple systems.

Many organizations use both: AddressBase for the authoritative address register and UPRNs, and PAF for postal validation and formatting.

Can I geocode UK addresses without AddressBase or PAF?

Yes! You have several options:

Global geocoding providers include Google Maps Geocoding API (excellent for UK addresses), HERE Geocoding (good UK coverage), Mapbox Geocoding (uses OpenStreetMap + proprietary data), and TomTom Geocoding (commercial-grade accuracy). These services have their own address databases, often incorporating multiple sources.

UK-specific geocoding services include Ideal Postcodes (uses OS data, licensed), Loqate (uses PAF and other data), and Postcode Anywhere (UK-focused address validation).

Open-source geocoding options include Nominatim (OpenStreetMap geocoder, free and open-source) and Pelias (open-source geocoder that can use OpenAddresses).

Learn more in our comparison of UK geocoding providers: Best Geocoding Providers for the United Kingdom.

Where can I learn more?

Official sources:

Ordnance Survey: ordnancesurvey.co.uk
GeoPlace (UPRN): geoplace.co.uk
Royal Mail PAF: royalmail.com/business/services/marketing/data-optimisation/paf
PSGA Information: ordnancesurvey.co.uk/psga

Related articles:

How geocoding works: A simple guide
UK Country Analysis — Geocoding performance in the UK

Need help with UK addresses? Coordable can help you geocode, validate, and manage UK addresses with high accuracy, supporting multiple providers and data sources.

How geocoding works ? A simple guide

François Andrieux — Wed, 22 Oct 2025 10:00:00 GMT

What is geocoding and why it matters?

Every day, we interact with addresses and places; whether we're searching for a nearby coffee shop on our phone, or entering our delivery address at checkout. But here's the thing: computers don't naturally understand "123 Main Street" or "Central Park." They work with numbers and more specifically, with latitude and longitude coordinates.

That's where geocoding comes in: Geocoding is the process of translating human-readable addresses into geographic coordinates that computers can use to pinpoint locations on a map. It's the invisible bridge between how we describe places and how machines navigate, analyze, and visualize them.

A simple geocoding example.

This guide will walk you through what geocoding is, how it works behind the scenes, what can go wrong, and how to get the best results. Let's dive in! 🙂

Note: You don't need to be technical to use geocoding well. Understanding a few key concepts will help you troubleshoot issues and make better decisions.

Table of contents:

The two ways of geocoding

Geocoding actually works in two directions, and each serves a different purpose.

Forward geocoding: turning addresses into coordinates

Forward geocoding takes a text address (like 57 Rue de Varenne, Paris, France) or place name (like Tour Eiffel) and returns a pair of coordinates (latitude and longitude).

This is the exact process that happens when you search for a location in Google Maps or Apple Maps on your phone:

In Google Maps, typing "57 Rue de Varenne, Paris, France" and getting the coordinates is a forward geocoding process.

Forward geocoding is an essential tool for a wide variety of operations. I don't want to sound too boring already by listing all the examples, but here are just a few.

For consumers:

Finding places: Forward geocoding lets you search for locations in navigation apps, just type a name or address to find a coffee shop, pharmacy, or tourist site.
Getting directions: All navigations apps use geocoding to get the coordinates of the destination and display it on the map. Then, the best route is computed by the navigation engine.
Package delivery: Addresses are sent to the delivery driver to help them find your address and drop off your package.

For businesses:

Address validation: Online stores and delivery services geocode addresses to check and standardize them at checkout.
Route optimization: Companies geocode address lists to plan deliveries efficiently and save resources.
Customer analytics: Businesses geocode customer addresses to spot trends and improve marketing or logistics.
Store locators: Retailers use geocoding so customers can easily find the nearest shop from their address.

And this list is not exhaustive. Yes, geocoding is everywhere! 😀

Reverse geocoding: turning coordinates into addresses

Reverse geocoding does the opposite: you start with a GPS point (latitude and longitude) and get back the nearest address or place name.

That's what happens when you pin a place on the map in Google Maps or Apple Maps:

In Google Maps, pinpointing a location and getting a suggestion for the address is a reverse geocoding process.

Again, here are some real world examples:

When you drop a pin on a map to show a friend where you are, the app reverse geocodes that point to display 57 Rue de Varenne, Paris, France instead of 48.8589, 2.3514.
Photos taken with your smartphone often store GPS coordinates in their metadata. Apps reverse geocode those coordinates to label your photos with Central Park, New York or Eiffel Tower, Paris.
A delivery driver scans a package at your door. The handheld device logs the GPS coordinates at that moment, and the system reverse geocodes it to confirm delivery at the correct address.

Good to know: In most cases, when people mention "geocoding", they’re talking about forward geocoding. If reverse geocoding is meant, it’s usually specified directly.

How geocoding works (simplified version)

Now let's walk through what happens when you provide an address to a geocoding system. Understanding these steps will help you recognize why some addresses work perfectly and others struggle.

Basically, geocoding involves matching an input address to the most similar entry in a large address database. In other words, it's a process of looking up an address in a database:

Address lookup: the geocoding system checks your input against a massive database of known addresses and places to find the best match.

When I type 57 ru de varenne Paris in Google Maps (yes, with the typo), the system will compare this input with Google's database of addresses and POIs (Points of Interest) and will return the closest match.

This simple address lookup is made of 4 steps:

Address normalization
Parsing
Database lookup
Scoring and ranking

Let's go through each step in detail.

Step 1: Address normalization

Addresses can be entered in many different ways: with typos, all uppercase, extra or missing information (like country or postal code), or with unnecessary details.

The normalization process aims to standardize addresses so they can be easily compared to those in the database. Here are some typical normalization steps:

Standardization: Convert to lowercase, remove extra spaces and symbols, etc. Example: 57 , AV des Champs-élysées (paris) becomes 57 avenue des champs elysees Paris.
Expanding abbreviations: 57 R de Varenne may be expanded to 57 Rue de Varenne.
Correcting small typos: Obvious small errors can be fixed, e.g., 57 Reu de Varenne becomes 57 Rue de Varenne.
Removing filler words: We can remove words like "de", "la" (in french) or "of", "the", "in", e.g. 57 Rue de la Varenne in Paris could become 57 Rue Varenne Paris.

Note: The amount and type of normalization and cleaning depends on the geocoding provider. Google Maps will have different rules than HERE, and Mapbox, and so on. This is part of each provider's "secret sauce", and that's why a provider can fail where another succeeds.

Step 2: Parsing components

Once the address is normalized, we can try to parse it, i.e., split it into recognized component parts: house number, street name, unit/apartment number, city, postal code, region/state, and country.

Address parsing: the geocoding system splits the address into recognizable components.

This is needed in order to specify the search. When I type 57 rue de Varenne paris, should I check all addresses in the World? Probably not!

Because Paris strongly suggests that we are in France (or at least, it's highly probable... we could, for example, also be in Paris, Texas, United States 😅).

Parsing works by identifying patterns. For example:

Countries are usually placed at the end of the address (like in 57 Rue de Varenne, Paris, France)
Postal codes are usually codes between 3 to 10 digits (or characters), depending on the country
Housenumbers are usually the first numbers encountered

But all these rules can be unreliable, and the geocoding system must deal with a lot of inconsistencies.

Missing components: Sometimes components are missing (I didn't type the country and the postal code for my search)
Abbreviations: People write St (street? saint?), Av (avenue? aviation?), Dr (drive? doctor?). The system must use context to decide.
Different country formats: In the U.S., postal codes come at the end. In the UK, they're often in the middle. In Japan, the structure is completely different (country, postal code, prefecture, city, district, block, building).
Multiple languages: Rue (French), Calle (Spanish), Rua (Portuguese), Ulica (Polish) — they all mean "street," and the system needs to recognize them.

As an example, Google Maps still works well if I type 75015 Paris - Rue de Varenne 57 even if it does not respect the usual format.

Why parsing is powerful: Once the address is parsed, the geocoding engine can use the country or state or city to filter out billions of irrelevant addresses. A postal code narrows it even further often to just a few hundred possibilities. This is how geocoding systems stay fast and accurate even when dealing with enormous datasets.

Step 3: Database lookup - finding the match

Now that we have clean, parsed components, it's time to look them up in a reference database. This is an example of process:

Take only addresses within the same country or state or city (if available, let's say France for our example)
Find addresses that match the most of our components: house number, street name, city, postal code.

Illustration of the address lookup by components.

In this above example, we find 4 possible matches (that have at least one component in common with our input):

57 Rue de Varenne, Riom, France
57 Rue de Varenne, Paris, France
58 Rue de Varenne, Paris, France
57 Av. des Champs-Elysées, Paris, France

For the sake of simplicity, we used a strict matching, i.e. we only match if the input is exactly the same as the database. However, in reality, geocoding systems often use distance functions, like the Levenshtein distance, which helps match addresses even when they contain typos or abbreviations (e.g. 57 Rue de Varene with a missing letter n).

Tokenization: Some geocoding systems use a process called tokenization, which means splitting an address into smaller pieces (tokens), usually words. Instead of trying to match the entire street name as one string, the system can match individual tokens. For example, champs elysées might be split into tokens like champs, elysées, champs elysées, and champs-elysées. This approach increases the chances of finding a match even if the address format varies or contains minor errors. Geocoding engines use different strategies to generate and compare tokens: some rely on phonetic similarity, others use techniques like stemming (reducing words to their base form) or lemmatization. The exact methods may vary between systems.

You also now understand that the goal is to have the most complete list of addresses possible but also to include street names, administrative boundaries, cities, neighborhoods, POIs, and more. This is also why some providers can give much different results than others. Commercial providers like Google or Apple have their own private data, whereas some well-known open source initiatives like OpenStreetMap and OpenAddresses.io can give you good coverage of the world.

Google Maps, for instance, excels with commercial data like restaurant names or shop names. The US Census geocoder will never be able to match a restaurant name with a location; it's simply not in their database.

Step 4: Scoring and ranking - choosing the best match

As we saw, the database lookup often returns multiple candidates. Maybe there are two 57 Rue de Varenne addresses in neighboring towns. Or the postal code matches perfectly, but the street name is slightly off. How does the system decide which one to return?

If you look at the example above, it's clear that not all matches are equal. Some are more likely to be the correct one than others. If our input is 57 Rue de Varenne, Paris, France, we have:

57 Rue de Varenne, Riom, France: same housenumber & street name but different city
57 Rue de Varenne, Paris, France: same housenumber & street name & city
58 Rue de Varenne, Paris, France: same street name & city
57 Av. des Champs-Elysées, Paris, France: same housenumber & city

It becomes obvious that some components are more important than others, i.e. matching the right city is probably more important than matching the right housenumber. For our example, let's attribute a score with ponderationnal weighting:

1 point for the housenumber
2 points for the street name
3 points for the city

The result would be:

57 Rue de Varenne, Riom, France: 1 + 2 = 3 points
57 Rue de Varenne, Paris, France: 1 + 2 + 3 = 6 points 🏆
58 Rue de Varenne, Paris, France: 2 + 3 = 5 points
57 Av. des Champs-Elysées, Paris, France: 1 + 3 = 4 points

The database lookup with 57 Rue de Varenne, Paris, France has 6 points, being the highest score, so that's the one that will be returned ! 🎉

Good to know: It's a way for geocoding providers to score their results and return confidence scores. Some may use different weighting, some may use different distance functions, etc. But you get the idea. Again, it's a way for some geocoding providers to achieve better performance than others.

Coming up with a good scoring system isn't easy, and there's no single right answer. Is the city name always worth 3 points, or should that change if the name's a bit ambiguous? What about situations where parts of the address are missing or not very reliable? Tweaking the weights for each component can have a big effect on your results, and it often depends on where your data is from and the types of addresses you get.

In practice, building these ranking rules usually involves a lot of testing, tweaking, and sometimes even a dash of machine learning to get the best possible matches.

What could go wrong? Understanding geocoding failures

Now that you understand how geocoding works, let's talk about what could go wrong. You will be surprised to see how often geocoding fails, and how often it's not obviously stated by the geocoding provider 😅.

Problem #1: Database issues (missing, incorrect, ...)

Geocoding systems are only as good as the data they use. If the underlying database has missing information or is out of date, even perfect input won't produce accurate results.

Missing data:

Rural areas: A farmhouse on a county road might not have a specific street address in the database. The geocoder might place it at the road centerline or at the entrance to the property close, but not exact.
New construction: A brand-new apartment building might not yet appear in the address database. It could take weeks or months for mapping providers to update their data after construction is complete.
Private roads and gated communities: These are often excluded from public datasets. If you're trying to geocode an address inside a private community, the system might only get you to the main entrance.

Ambiguous data:

Street renaming: A city renames Washington Avenue to Martin Luther King Jr. Boulevard. For months, the old name still appears in the database, and geocoding requests using the new name fail or return low-confidence results.
Multiple languages: Some addresses must exist in multiple languages, e.g. 9 Rue des pensées, 1030 Schaerbeek should as well exist as Penseestraat 9, 1030 Schaarbeek (street name and even city name are different). They both represent the exact same address, but with different languages (French and Dutch).

How to deal with this issue? You must not just trust the geocoding provider's result. You must always check the result and if it's not correct, you must try to correct it manually. Coordable automatically detects these issues for you.

Example 1: Google Maps

At the time of writing (2025, October), Google Maps does not have the address 12 rue sur le rang, Bourogne in France. Instead, it would insist in returning the address 12 Rue Vivaldi, 90140 Bourogne, France.

Google Maps wrong example: the address 12 rue sur le rang, Bourogne is not located correctly.
Mapbox is correct because it probably uses the open source French database for this example.

This example is not that bad in the sense that the result is pretty close to the correct location. However, that's still a false positive: a result that is returned and is confident about it, but it's not the correct one.

Example 2: HERE wrong example

To be fair, all geocoding providers have their flaws. Here is another example with HERE, where Google actually works better.

In this example, we geocode the address 38 b faubourg de montbéliard, Delle. It's still unsure if there are two addresses with the same housenumber there (38 and 38B), but HERE returns something completely wrong with a high score (1.0).

HERE wrong example: the address 38 b faubourg de montbéliard, Delle is not located correctly.
Google Maps is correct in this case.

The problem here seems a lack of update in the open source French database. As HERE uses it, it also inherits its errors.

Problem #2: Parsing failures when the system can't make sense of the input

Most of the time, addresses are messy. They contain extra noise, typos, mixed languages, and other formatting issues.

But sometimes, the parser can't understand the input at all:

CALL JOHN AT 555-239-4829 120 MAIN STREET APT 5B, BROOKLYN, NY, USA: too many noise, phone number, instructions, etc.
1234ElmStreetLosAngelesCA90001: no spaces or wrong order, no city or postal code.
ru Saint cathrine West, Montreal QC H3B 1B5 Canda: typo, mixed languages, etc.
RUE DES F?TES, 75019 PARIS: encoding issue, special character (should be Rue des Fêtes)

Try these examples with your favorite maps application. You would be surprised to see how often they fail.

Parsing errors are a real problem: businesses processing thousands of global addresses using poorly designed parsers often see failed deliveries or mismatched addresses, all due to small parsing errors that could have been avoided with better cleaning and normalization.

How to deal with this issue? Cleaning the input is a good way to improve the results. E.g. if you know that your addresses have encoding issues, fix it before sending it to the geocoding provider. Coordable has automated AI cleaning that deals with all the above issues and more.

Example 1: basic encoding issue

In this example, the address RUE DES F?TES, 75019 PARIS cannot be geocoded correctly in both Mapbox and Nominatim (the OpenStreetMap geocoder).

Illustration of an encoding issue: the address RUE DES F?TES, 75019 PARIS is not properly geocoded.

In both cases, they will return the correct location if f?tes is replaced by fêtes.

Example 2: noise issue

In this example, we consecutively try CALL JOHN AT 555-239-4829 120 MAIN STREET APT 5B, BROOKLYN, NY, USA and MAIN STREET APT 5B, BROOKLYN, NY, USA in Google Maps.

Example of noise: extra phone numbers and instructions prevent the geocoder from finding the correct address.

The result is that noise is not being filtered by Google Maps (which has, to be honest, one of the best parsers out there). Is it Google Maps fault? No, probably not. At this point, we should have cleaned the input ourselves.

You may think it's a silly example, but it's not 🫠. It happens a lot to see mixed fields because of human errors.

Example 3: typos

In this example, we try to geocode the address ru Saint cathrine West, Montreal QC H3B 1B5 Canda in HERE and Mapbox. It's a mix of French and English with many typos. A correct address could be Rue Sainte-Catherine Ouest, Montreal QC H3B 1B5 Canada or St-Catherine West, Montreal QC H3B 1B5 Canada.

Example of typos and mixed languages that can cause geocoding failures.

HERE returns the correct address, but Mapbox can't find it and returns Montreal, QC, Canada. It's interesting to play around with the suggestions in the HERE dropdown. It shows that both English and French versions are available, and it's not affected by the typo ru instead of Rue.

Best practices: how to get reliable geocoding results

Now that you understand how geocoding works and what can go wrong, let's talk about how to improve your results 😎. Whether you're a consumer troubleshooting a single address or a business processing thousands, these practices will help.

1. Pick the right geocoding provider

You can get better results by picking the right geocoding provider.

Why: All providers rely on different data, different parsing rules, different scoring systems, etc. This makes many ways to differentiate them.

How: You should try different geocoding providers and see which one works best for you. You can also try to use the geocoding provider's API to get the best results.

Good to know: on Coordable, you can select the geocoding provider from a dropdown in the address input field.

2. Always add context (country, region, postal code)

Geocoding accuracy improves dramatically when you provide strong context: country, state/region, and especially postal code.

Why: Cities, streets, and even building names can be duplicated across the world (or even within a single country). "Paris" could mean Paris, France or Paris, Texas. "There are thousands of streets named Main Street in the United States alone."

How: At least, always concatenate the country to the address. It's a quick win. And if possible, a postal code is a strong hint of the correct location.

3. Clean your addresses before you geocode

Messy, incomplete, or inconsistent addresses are the #1 cause of poor geocoding results. Cleaning (a.k.a. "address normalization") means fixing typos, filling in missing parts, converting to a canonical format, and removing extraneous noise.

Why: Geocoding engines often struggle with extra info ("Attn: John", "call before delivery", phone numbers), bad capitalization, spelling/formatting variations, or misplaced address parts. Clean inputs = far fewer errors.

How: You can implement some of the rules we presented earlier in this article: normalization, replacement of abbreviations, encoding issues, etc.

Tools: Basic cleaning can be handled with spreadsheet formulas, or specialized software/APIs like Coordable, libpostal, or your geocoding provider's normalization endpoint.

4. Help the parser if possible

If possible, provide the information of your address components to the geocoding provider. This can help the parser to understand the address better.

Why: Parsing is one of the most important steps in geocoding. If it's failing, you will get poor results.

How: Some geocoding providers can accept a structured address input like a JSON object with the address components: {house_number: "57", street: "Rue de Varenne", city: "Paris", state: "Île-de-France", country: "France", postal_code: "75015"}.

5. Understand what you are geocoding

Are you sending residential addresses or POIs? Do you have mostly street names alone or do you have house numbers?

Why: Understanding what you are sending can help you to understand the quality of your results. It's obvious, but if only 50% of your addresses are residential addresses, you should expect less than 50% of results with housenumbers.

How: You can implement your own rules to classify addresses. For instance, you could write a regex rule to parse postal codes and housenumbers.

Good to know: when uploading a dataset or starting a geocoding job on Coordable, we automatically classify the addresses for you.

6. Don't trust results blindly

Geocoding systems return results even when they're not confident. If you blindly accept the first result, you might get the wrong location. Even the confidence score is not a guarantee of the correctness of the result.

Why: The confidence score is not a guarantee of the correctness of the result. It's a score given by the geocoding provider to indicate the confidence in the result. It's not a guarantee of the correctness of the result.

How to avoid it: Implement your own rules to measure accuracy and correctness of the result, based on the information the provider gives you, as well as your own manual verification.

Good to know: the Coordable platform embeds a powerful verification engine that can help you quickly identify false positives and incorrect results.

Conclusion

I hope you enjoyed this guide. I tried to explain how geocoding works in a simple way, with examples and practical tips to improve your results.

A lot of technical details are omitted, such as tokenization, distance functions, or scoring rules. I will probably write a follow-up article to cover these topics. But at least it presents the big picture of a geocoding process.

If you are a business and want to improve your geocoding results, please contact us at contact@coordable.co.

After that, if you want to learn more, here are some resources that I found interesting:

Happy geocoding! ⭐

How to Geocode Addresses with BAN (Base Adresse Nationale) API

François Andrieux — Wed, 15 Jan 2025 10:00:00 GMT

If you're working with French addresses, the Base Adresse Nationale (BAN) is your best friend. It's France's official address database, maintained by local authorities and IGN (Institut Géographique National), and it's completely free to use. Whether you need to geocode a single address or process thousands, BAN provides authoritative, accurate results without the licensing restrictions or costs of commercial providers.

Unlike commercial geocoding services that charge per request and restrict how you can use the data, BAN offers unlimited free geocoding with a permissive open license. This makes it ideal for French organizations, government agencies, and anyone building applications focused on France.

Important update: As of 2025, the BAN API has been migrated to the Géoplateforme service managed by IGN. The old endpoint api-adresse.data.gouv.fr is deprecated and will be decommissioned in January 2026. This tutorial covers the new Géoplateforme service endpoints. (Source)

Note: BAN only handles addresses - it doesn't geocode business names, landmarks, or POIs (Points of Interest). For those, you'll need a commercial provider like Google Maps or HERE. But for pure address geocoding in France, BAN is unmatched.

Table of contents:

Introduction: Why use BAN?

Before we dive into the how-to, let's understand why BAN is special and when it makes sense to use it.

What is BAN?

The Base Adresse Nationale (BAN) is France's official national address database. It contains over 25 million addresses compiled from local authority data across all French communes, including overseas territories. What makes BAN unique is that it's:

Authoritative - maintained by official French authorities (IGN and local governments)
Comprehensive - covers every commune in France, including rural areas and small localities
Accurate - provides exact rooftop coordinates rather than interpolated guesses
Free - completely free to use with no quotas or charges
Open - fully open license allowing storage, reuse, and redistribution

Here is an example of a BAN address, shown in the official visualization tool:

Example for "118 rue st charles", Paris (screenshot from the BAN interface).

When to use BAN

BAN is perfect when you: - Need to geocode French addresses (metropolitan France and overseas territories) - Want authoritative, government-maintained data - Need to avoid commercial licensing restrictions - Are building applications that require address validation - Want to geocode large volumes without cost concerns - Need to store and reuse geocoded coordinates permanently

Why BAN works so well: Since BAN is updated by local authorities who know their addresses intimately, it provides exact coordinates rather than estimates. This is especially valuable for rural addresses and small localities that commercial providers might struggle with.

When BAN isn't the right choice

BAN won't work if you need to: - Geocode addresses outside of France - Find businesses, landmarks, or POIs by name - Handle natural language queries or typos (BAN requires well-formatted addresses) - Need real-time business information (hours, ratings, etc.)

For these use cases, you'll want to consider commercial providers like Google Maps, HERE, or Mapbox.

Single address geocoding

Let's start with the simplest use case: geocoding a single address. This is perfect when you need to convert one address into coordinates, perhaps for a form validation or a single lookup.

The new endpoint & parameters (2026)

The BAN geocoding service is now provided through the Géoplateforme service managed by IGN. The endpoint for forward geocoding is:

https://data.geopf.fr/geocodage/search

Important: The old endpoint api-adresse.data.gouv.fr is deprecated and will be decommissioned in January 2026. You should migrate to the new Géoplateforme endpoint. (Source)

This /search endpoint accepts the following parameters:

q (required): The address to geocode
limit (optional): Number of results to return (default is 10)
autocomplete (optional): Enables autocomplete mode (default is true)

Other parameters are available to precise the geocoding context (e.g. city, postal code, etc.), but I won't cover them here. For the full list of parameters, consult the OpenAPI documentation.

Example request

Here's an example with the address "118 Rue St Charles, Paris":

GET https://data.geopf.fr/geocodage/search?q=118+Rue+St+Charles,+Paris&limit=1

And it returns:

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "geometry": {
        "type": "Point",
        "coordinates": [2.283496, 48.844484]
      },
      "properties": {
        "label": "118 Rue Saint-Charles 75015 Paris",
        "score": 0.7424048484848483,
        "housenumber": "118",
        "id": "75115_8513_00118",
        "name": "118 Rue Saint-Charles",
        "postcode": "75015",
        "citycode": "75115",
        "x": 647415.92,
        "y": 6860731.63,
        "city": "Paris",
        "district": "Paris 15e Arrondissement",
        "context": "75, Paris, Île-de-France",
        "type": "housenumber",
        "importance": 0.83312,
        "street": "Rue Saint-Charles",
        "_type": "address"
      }
    }
  ],
  "query": "118 rue st charles, Paris"
}

In this example, we added a limit of 1 to get only one result. The API returns its best guess for the address, ordered by the match score.

What happens? The API searches its database for addresses matching your query and returns a list of possible matches. The response includes the exact coordinates, formatted address, and additional metadata like postal code and city.

The response

The API returns a GeoJSON FeatureCollection. Each feature contains:

ID - the unique identifier of the address in the BAN database (properties.id)
Coordinates - latitude and longitude in the geometry.coordinates field (format: [longitude, latitude]). They are also available as x and y in the properties object.
Formatted address - the standardized address label in properties.label
Address components - housenumber, street, city, postcode, citycode, etc. The housenumber and street name will be mising if not found.
Importance - estimated importance of the address in the database (0-1 scale)
Score - relevance score indicating match quality between your query and the result (0-1 scale)

Note: Results are returned ordered by score (highest first), so the first result is typically the best match. However, always verify the address components (especially city and postal code) to ensure the result is correct, as we'll explain in the next section.

The match score

The API returns a confidence score between 0 and 1. However, a high score doesn't mean the address is correct, and it definitely doesn't mean the address exists.

Take our "118 Rue St Charles, Paris" example. The top result scores 0.74, which sounds reasonable. But peek at the second result at 0.62 - it points to "Rue Charles Paris 33130 Bègles". That's 500km away in Bordeaux's suburbs!

Even trickier: search for "17 Rue St Charles, Paris" and you'll get a respectable 0.74 score... except this address doesn't exist. The API found something that looks similar, but it's matching strings, not verifying reality.

The takeaway? Always sanity-check geocoding results. The score tells you how well your query matched something in the database, not whether that something is what you actually wanted.

Batch geocoding: processing multiple addresses

When you have many addresses to geocode - whether it's a spreadsheet with customer addresses or a database export - you'll want to use batch geocoding. BAN offers two approaches: a web interface for one-time tasks and an API for automation.

Method 1: Using the BAN web interface

The easiest way to geocode a CSV file is through BAN's web interface. This is perfect if you're not a developer or if you're doing a one-time batch job.

Here is how to do it:

Prepare your CSV file - Include columns with address data (street number, street name, postal code, city). Export from Excel if needed.
Upload to BAN CSV tool - Select which columns contain your address components (e.g., Numéro, Rue, Ville).
Download results - Get your original data plus coordinates, formatted addresses, and result_status column.

The BAN CSV tool allows you to upload a CSV file and select the columns containing the address data.

And you're done: once you specified

Method 2: Using the BAN API

For automation, integration into applications, or regular batch processing, you'll want to use the BAN API directly. This gives you full control over the process and lets you build custom workflows.

Understanding batch geocoding with the API

The Géoplateforme service provides a dedicated batch geocoding endpoint that accepts CSV files. This is the recommended approach for processing multiple addresses programmatically.

The batch endpoint is available at https://data.geopf.fr/geocodage/batch/.

The request should be a POST request with the CSV file in the request body. It accept several important parameters: - columns: the columns to concatenate the address. It can be left empty to use all columns. - indexes: the column to use as index. It's useful to be able to identify the address in the original CSV file.

Note: You still can make multiple requests to the /search endpoint, one for each address, but this will be less efficient than using the batch endpoint.

Example request

Here is an example of a CSV file with the addresses to geocode:

id,rue,street,city,postal_code
1,12.0,Avenue des Champs-Élysées,Paris,75008
2,45.0,Rue de la République,Lyon,69002
3,78.0,Boulevard de la Croisette,Cannes,6400
4,,,???????,
5,156.0,Rue Saint-Honoré,Paris,75001

In this case, the columns to concatenate the address are: rue, street, city, postal_code, so we can specify columns=rue,street,city,postal_code.

The request should be:

POST https://data.geopf.fr/geocodage/search/csv
data=addresses.csv
columns=rue,street,city,postal_code

The response will be a CSV file too, returning both the original data and the geocoded data with new columns all prefixed with result_ (result_score, result_score_next, result_label, result_type, result_id, result_housenumber, result_name, result_street, result_postcode, result_city, result_context, result_citycode, result_oldcitycode, result_oldcity, result_district, result_status).

id;rue;street;city;postal_code;longitude;latitude;result_score;result_score_next;result_label;result_type;result_id;result_housenumber;result_name;result_street;result_postcode;result_city;result_context;result_citycode;result_oldcitycode;result_oldcity;result_district;result_status
1;12;Avenue des Champs-Élysées;Paris;75008;2.302859;48.871285;0.8596027272727272;0.6467871900826445;Avenue des Champs Elysées 75008 Paris;street;75108_1733;;Avenue des Champs Elysées;Avenue des Champs Elysées;75008;Paris;75, Paris, Île-de-France;75108;;;Paris 8e Arrondissement;ok
2;45;Rue de la République;Lyon;69002;4.835859;45.761928;0.9157595187165776;0.6972321052631578;45 Rue de la République 69002 Lyon;housenumber;69382_6005_00045;45;45 Rue de la République;Rue de la République;69002;Lyon;69, Rhône, Auvergne-Rhône-Alpes;69382;;;Lyon 2e Arrondissement;ok
3;78;Boulevard de la Croisette;Cannes;06400;7.032336;43.54684;0.9329795565410199;;78 Boulevard de la Croisette 06400 Cannes;housenumber;06029_0880_00078;78;78 Boulevard de la Croisette;Boulevard de la Croisette;06400;Cannes;06, Alpes-Maritimes, Provence-Alpes-Côte d'Azur;06029;;;;ok
4;;;???????;;;;;;;;;;;;;;;;;;;skipped
5;156;Rue Saint-Honoré;Paris;75001;2.339989;48.862052;0.9164409090909089;0.6147660173160173;156 Rue Saint-Honoré 75001 Paris;housenumber;75101_8635_00156;156;156 Rue Saint-Honoré;Rue Saint-Honoré;75001;Paris;75, Paris, Île-de-France;75101;;;Paris 1er Arrondissement;ok

The result_status column contains "ok" if the address was geocoded successfully, "skipped" if the address was not geocoded successfully.

Interesting! In batch CSV mode, the API only returns one result per row. However, you can still now the score of the second best match in the result_score_next column.

Usage and cost

BAN is completely free to use, with no hidden costs or quotas. This makes it an excellent choice for organizations of any size.

Cost structure

API usage: FREE - No charges for API requests
No quotas - Process as many addresses as you need
No subscription fees - No monthly or annual costs
Database download: FREE - You can download the entire BAN database for free

Why BAN is free: BAN is a public service maintained by French government agencies. It's funded by taxpayers and provided as open data to benefit French society and economy.

If you're processing millions of addresses or need offline access, you can download the complete BAN database and run your own geocoding locally.

For a detailed comparison with commercial providers (Google Maps, HERE, Mapbox...), check out my Best Geocoding Providers for France guide.

Rate limits

BAN allows 50 requests per second per IP. If you exceed this, you'll get HTTP 429 errors. Throttle to ~40/second and you'll be fine.

Wrapping up

BAN is free, accurate, and open. For French addresses, it's hard to beat. Just remember: migrate to the new Géoplateforme endpoint (data.geopf.fr) before January 2026 if you're still using the old one.

Full API reference: Géoplateforme OpenAPI documentation.

To get a full overview of the geocoding providers for France and a comparison between them, check out our guide: Best Geocoding Providers for France.

Last updated: 2025-01-15 | Updated by: François Andrieux | Sources: BAN API Documentation, CSV Geocoding Tool, API Migration Announcement, Géoplateforme Capabilities, Géoplateforme OpenAPI Documentation

Disclaimer: This guide is for informational purposes. Always refer to official BAN and Géoplateforme documentation for current endpoints and terms.

How to geocode addresses: Transform text addresses into GPS coordinates

François Andrieux — Wed, 15 Jan 2025 10:00:00 GMT

How to geocode addresses: a practical guide

You've probably found yourself needing to convert addresses into coordinates. Maybe you have a list of customer addresses and want to see them on a map. Or perhaps you're building an app that needs to locate places automatically.

Whatever your situation, you've come to the right place! This guide will walk you through exactly how to convert addresses into coordinates using different methods, from simple web tools to powerful APIs. We'll explain why each method exists and when to use it, so you can choose the best approach for your needs.

Note: If you're curious about how geocoding works behind the scenes (the technical process), check out our guide: How geocoding works: A simple guide. This article focuses on the practical "how-to" - showing you the tools and steps to actually geocode addresses.

Table of contents:

Two main approaches: web interfaces vs APIs

Before we dive into the step-by-step instructions, let's understand why there are different ways to geocode addresses. The truth is, different situations call for different tools.

Web interfaces are perfect for one-time tasks, small batches, or when you want immediate visual results.

APIs and developer tools make sense when you need automation, integration into applications, or to process many addresses regularly.

The good news? You don't need to be a software developer to use APIs. We'll show you both approaches, starting with the simplest one.

Geocoding one address with Google Maps

Let's take an example with a well known interface: Google Maps.

Google Maps is easy to use, and it's free. If you have only one address to convert to coordinates, this is probably the simplest and fastest way to do it.

And it's actually possible to use it geocode addresses and save their latitude/longitude. Here is how to do it:

Open Google Maps in your web browser
Type your address in the search box (e.g., 530 Hancock St, Brooklyn, USA)
Right-click on the red marker that appears on the map
Click on the coordinates that appear in the popup menu
The coordinates are copied to your clipboard, as latitude and longitude (e.g: 40.68421, -73.934043)

How to geocode a single address with Google Maps

That's it! You now have the latitude and longitude for that address.

Google Maps is great for one-off lookups, but it's not designed for batch processing. If you have many addresses, you'll need to repeat this process for each one, which quickly becomes tedious.

It's possible to use Google My Maps to display data, but it requires latitude and longitude coordinates, not the addresses... And do not allow exporting data.

Geocoding multiple addresses with Coordable (Excel/CSV)

If you have multiple addresses in an Excel file and want to see them all on a map, Coordable offers a powerful web interface, with batch processing and visualization. Here is how to do it:

Go to Coordable and create an account (free tier available)
Upload your addresses - you can upload a CSV file or Excel file with a column (or many columns) containing the addresses you want to geocode.
Select your geocoding provider from the dropdown (Google Maps, HERE, Mapbox, etc.). Choose the most appropriate provider for your needs.
Start the geocoding job - Coordable processes all your addresses
View results - you can see the results on a map and in a table
Export your results - you can download the results with latitude and longitude, and other geocoding metadata

The upload interface of Coordable accepts Excel or CSV files.

Coordable transparently handles the geocoding process for you. It gives a clear view on the results and classify addresses for further analysis:

Coordable shows geocoding success rates and types of addresses.

Results are shown on a map and in a table. You can filter on columns to analyse the results, and you can also export.

Table and map views of the results.

There is no limit in the number of addresses you can geocode. Coordable geocoding by batches automatically and notify you when it's done. It's the easiest and fastest way to geocode a large number of addresses.

Try the coordable app

Geocoding multiple addresses with APIs

APIs (Application Programming Interfaces) let you geocode addresses programmatically. This means you can automate the process, integrate it into your applications, or process thousands of addresses at once. Here is how to do it:

Get an API key - you can get an API key from the geocoding provider you want to use.
Make an API HTTP request - you can make an API HTTP request to the geocoding provider you want to use.
Handle the response - save components, coordinates, handle errors, etc.

Using an API usually require some technical knowledge, and you need to handle the response from the API. Geocoding APIs are not uniformized, which can make it somehow hard to change from an API to an other.

Most of the time, APIs return raw coordinates (latitude, longitude), formatted addresses, and confidence scores. Sometimes they also include address components and place types. However, APIs don't provide visual maps of results, table views for batch processing, built-in quality verification, easy export to common formats, or visual feedback on accuracy.

This is why many people use APIs for automation but then need additional tools to visualize and verify results. Coordable fills this gap by providing API-like automation with built-in visualization and quality checks.

Meta-geocoding strategies

It's also possible to combine multiple APIs in a cascade way. Here are at least two benefical ways:

To get higher geocoding rates: You could geocode 90% of the addresses using a local, open-source geocoding provider (e.g. a state geocoding service), then rely on the commercial provider for the remaining 10% that the initial provider cannot geocode.
To pick the best result: Some providers work well for POIs (restaurants, enterprises, etc.) and others for residential addresses. Combining 2 or more geocoding providers can help you get the best result possible. However, such strategy require a good understanding of each provider strengths and weaknesses.

Good to know: Coordable has out-of-the-box capabilities to implement meta-geocoding strategies. The Coordable API allow you to pick one or multiple providers, and even to add a custom endpoint for geocoding.

What to do after geocoding

Geocoding your addresses is just the first step. Here's what you should do next to ensure quality results:

1. Verify your results

Don't trust results blindly! Even the best geocoding services can make mistakes. Always verify:

Check a few results manually - look them up on a map to confirm they're correct
Review confidence scores - if the API provides them, pay attention to low-confidence results
Look for outliers - addresses that seem to be in the wrong country or region
Check for false positives - results that look confident but are actually wrong

Good to know: Coordable includes a built-in verification engine that automatically flags potentially incorrect results, making it easier to spot problems.

2. Visualize and the results

Seeing your geocoded addresses on a map helps you

Spot errors - addresses in wrong locations are obvious on a map
Understand patterns - see clusters, distributions, and geographic relationships
Share results - maps are easier to understand than coordinate lists

Tools like Coordable provide built-in map visualization, or you can use external mapping tools (ArcGIS, QGIS, etc.) to create custom visualizations.

QGIS, as an example, is a free and open-source GIS software that does it very well. Here is an example of a map of the results:

QGIS example of a map of the results.

You can also use mapping libraries (Leaflet, Mapbox GL, Google Maps) to create custom visualizations.

Best practices for quality results

Geocoding is complex problem to solve. An address that seem obvious to you might be difficult to geocode for a machine. Here are some best practices to help a geocoding engine:

Clean your addresses: remove typos, standardize formats (learn more about how geocoding works to understand why this matters)
Add context: include country, postal code when possible
Validate addresses: check if they exist before geocoding, when possible

Pro tip: If you're processing many addresses, start with a small sample (10-20 addresses) to test your workflow and verify quality before processing the full dataset.

Conclusion

Geocoding addresses doesn't have to be complicated. Whether you need to transform text addresses into GPS coordinates for a one-time project or set up automated geocoding for thousands of addresses, there's a method that fits your needs.

Remember:

Don't trust results blindly - always verify geocoding results, especially for critical applications
Analyze your results - check completion rates, accuracy, and identify patterns in failures
Pick the best geocoding provider based on your analysis and completion rate - different providers work better for different regions and address types

The key is choosing the right tool for your specific situation. Start simple with a web interface if you're new to geocoding, then move to APIs if you need to scale up or automate.

If you want to learn more about how geocoding works behind the scenes, check out our guide: How geocoding works: A simple guide.

For country-specific recommendations and provider comparisons, see our country analyses: - Best Geocoding Providers for France - Best Geocoding Providers for the United Kingdom - Best Geocoding Providers for Germany

Ready to get started? If you need to geocode addresses with visualization and quality checks, try Coordable - it's designed to make geocoding easy, whether you have one address or thousands.

Happy geocoding! ⭐