Address Autocomplete APIs Compared

/

Address autocomplete used to be a Google Places checkbox, and in 2026 it’s a genuine build-or-buy decision.

Google’s March 2025 pricing overhaul and the retirement of its legacy Autocomplete widget broke checkout forms across the WooCommerce ecosystem, removed the $200 monthly credit that made it effectively free, and pushed a lot of teams to look at alternatives for the first time in a decade. This post covers every serious option: the free tiers worth using, what each paid provider’s request and response actually look like, what 1,000 lookups really costs once you account for how each vendor bills, and how to build your own autocomplete API on OpenAddresses data if you’d rather own the whole thing.

How These APIs Bill (Read This First)

The single biggest comparison trap is the billing unit, because “per 1,000” means a different thing at almost every vendor:

  • Per keystroke – Every autocomplete request as the user types is billed (Geoapify, Geocode Earth, Radar, Smarty US, sthan, HERE/Placematic). A user finds their address in roughly 5 keystrokes, so multiply accordingly.
  • Per session – Unlimited keystrokes bundled into one billed unit per completed address (Mapbox Address Autofill).
  • Per selection – Keystrokes are free and you pay only when the user picks an address (Loqate, Smarty International).
  • Hybrid session tokens – Google’s model, where typing requests are free or discounted inside a session that ends with a billed Place Details call.

A provider that looks 10x more expensive per unit can be cheaper per completed address, so the table at the end normalizes everything to roughly 1,000 completed addresses.

Free Options for Low Volumes

Geoapify

Geoapify’s free plan is 3,000 credits per day (about 90,000 requests per month), no credit card, and commercial use is allowed. Each keystroke request costs one credit. A request is a plain GET:

GET https://api.geoapify.com/v1/geocode/autocomplete
    ?text=1313 Broad
    &filter=countrycode:us
    &format=json
    &apiKey=YOUR_API_KEY
{
  "results": [{
    "housenumber": "1313",
    "street": "Broadway",
    "city": "Tacoma",
    "state_code": "WA",
    "postcode": "98402",
    "country_code": "us",
    "lon": -122.4394,
    "lat": 47.2509,
    "formatted": "1313 Broadway, Tacoma, WA 98402, United States of America",
    "rank": { "confidence": 1, "match_type": "full_match" },
    "datasource": { "sourcename": "openstreetmap" }
  }]
}

Paid plans are flat subscriptions rather than metered: $59/month for 10,000 credits per day up to $299/month for 100,000 per day, which works out to roughly $0.20 per 1,000 requests on the entry plan. Data comes from OpenStreetMap, OpenAddresses, Who’s on First and Geonames, which means two things: you can store and cache results indefinitely as long as you keep the attribution, and house numbers for new construction are sometimes missing. Their JS components expose a nonVerifiedParts field so you can force a confirmation step when the house number isn’t verified, which is the right pattern for checkout.

sthan.io

The sleeper free tier in this space is sthan.io: 100,000 autocomplete requests per month, recurring, no credit card, US and India only. The API is as simple as it gets:

GET https://api.sthan.io/AutoComplete/USA/Address/123%20main%20st
Authorization: Bearer YOUR_TOKEN
[
  "123 Main St APT 1, Andover, MA 01810-3816",
  "123 Main St APT 1, Delhi, NY 13753-1257",
  "123 Main St STE 1, Caldwell, ID 83605-5476"
]

Note what’s missing: the response is a flat array of formatted strings with no coordinates, no parsed components and no IDs, so filling separate address fields means a second call to their parser or geocoding APIs, which have their own (much smaller) free tiers. Paid pricing is the cheapest published anywhere, $7/month for up to 500K requests scaling to about $0.024 per 1,000 at volume. The caveats: it’s a small operation, data sources are undisclosed (the ZIP+4 output implies USPS-derived data), and there are no published storage terms or SLA. Fine for a side project or a cost-sensitive store; do your diligence before betting an enterprise checkout on it.

Mapbox (free up to 1,000 sessions)

Mapbox Address Autofill includes 1,000 free sessions per month with a card on file (100 per month without one), and since a session covers unlimited keystrokes for a completed address, that’s roughly 1,000 free completed addresses. Details below with the paid providers.

Google Places Autocomplete (And Why It Broke WooCommerce Checkouts)

Google is still the default choice, and 2025-2026 is the period where that stopped being automatic.

Three things happened. First, on March 1, 2025 the legacy google.maps.places.Autocomplete widget and the legacy Places API became unavailable to new customers. Existing projects kept working, but any WooCommerce or WordPress plugin calling the legacy widget against a Google Cloud project created after that date simply failed, with the console error “As of March 1st, 2025, google.maps.places.Autocomplete is not available to new customers.” The symptom pattern confused everyone: existing stores worked fine, while new stores, or stores that rotated to a fresh API key on a new project, got a dead address field. On October 5, 2026 Google closed the last loophole, ending legacy enablement for all new projects entirely.

Second, the replacement isn’t a drop-in. PlaceAutocompleteElement is a web component that injects its own <gmp-place-autocomplete> element instead of attaching to your theme’s existing input, so checkout field markup and CSS need rework. The event changed (place_changed became gmp-select), data retrieval became a two-step async flow, and every field name changed casing (address_components/long_name became addressComponents/longText), silently breaking the component-mapping loop in every plugin that migrated naively. Plugin vendors spent most of 2025 catching up, and some never did.

Third, the money changed. The $200 monthly credit died on March 1, 2025, replaced by per-SKU free tiers: 10,000 free Autocomplete requests and 10,000 free Place Details Essentials calls per month. Past that you pay $2.83 per 1,000 Autocomplete requests and $5.00 per 1,000 Details calls. An un-debounced plugin firing a request per keystroke burns 20+ requests per address, and abandoned sessions bill per request, which is how stores that had paid $0 for years woke up to real invoices.

The current implementation looks like this:

const { PlaceAutocompleteElement } = await google.maps.importLibrary('places');
const autocomplete = new PlaceAutocompleteElement();
document.querySelector('#address-wrap').appendChild(autocomplete);

autocomplete.addEventListener('gmp-select', async ({ placePrediction }) => {
  const place = placePrediction.toPlace();
  await place.fetchFields({ fields: ['addressComponents'] });
  // map place.addressComponents (longText/shortText) into your form fields
});

Or server-side against the Places API (New):

POST https://places.googleapis.com/v1/places:autocomplete
X-Goog-Api-Key: YOUR_API_KEY

{ "input": "1600 Amphitheatre", "sessionToken": "TOKEN" }
{
  "suggestions": [{
    "placePrediction": {
      "placeId": "ChIJ5YQQf1GHhYARPKG7WLIaOko",
      "text": { "text": "1600 Amphitheatre Pkwy, Mountain View, CA, USA" },
      "structuredFormat": {
        "mainText": { "text": "1600 Amphitheatre Pkwy" },
        "secondaryText": { "text": "Mountain View, CA, USA" }
      }
    }
  }]
}

Cost for a well-built address form: with session tokens and an Essentials-level Details call, you pay for up to 12 keystroke requests plus one $0.005 Details call, roughly $0.014-$0.039 per completed address past the free tier, or about $14-$39 per 1,000 completed addresses. Debouncing and a 3-character minimum are no longer optional politeness; they’re your bill. Google remains the strongest dataset and the best typo tolerance, but for a pure address form at checkout it’s now among the most expensive options, you can’t store results, and the forced web component limits your UI.

Mapbox Address Autofill

Mapbox is the most checkout-shaped product in the list: it binds to standard HTML autocomplete attributes, so it layers onto an existing form without remapping fields, and it bills per session rather than per keystroke.

import { AddressAutofillCore, SessionToken } from '@mapbox/search-js-core';

const autofill = new AddressAutofillCore({ accessToken: 'pk.your-token' });
const session = new SessionToken();

const { suggestions } = await autofill.suggest('1600 Penn', { sessionToken: session });
const { features } = await autofill.retrieve(suggestions[0], { sessionToken: session });

Suggestions return parsed components (address_line1, address_level2, postal-code, plus an accuracy flag of rooftop/parcel/interpolated/street you can gate deliverability on); the retrieve step adds coordinates. Pricing: 1,000 free sessions per month, then $12.50 per 1,000 sessions dropping to $7.50 at 100K+. One session is one page view’s worth of typing, so cost per 1,000 completed addresses is simply $12.50, which beats Google for any un-debounced or chatty form.

The licensing is the catch: coordinates from Autofill “should be used ephemerally and not persisted,” and suggestions can’t be rendered on a non-Mapbox map. You can store the user’s confirmed address text as order data, but if you want to save lat/lng on orders or plot them in an admin dashboard on Google Maps, Mapbox’s terms say no.

Smarty

Smarty’s US Autocomplete Pro returns only USPS-verified deliverable addresses, which makes it the strongest pure-checkout option for US stores: what the user picks is already validated, no second verification pass needed.

GET https://us-autocomplete-pro.api.smarty.com/lookup
    ?key=YOUR_EMBEDDED_KEY
    &search=123 mai
    &prefer_states=MA
{
  "suggestions": [{
    "street_line": "123 E 103rd St",
    "secondary": "",
    "city": "Chicago",
    "state": "IL",
    "zipcode": "60628",
    "entries": 0
  }]
}

Billing is per keystroke on subscription tiers starting around $21/month for 5,000 lookups ($4.00 per 1,000 keystrokes, cheaper at volume: $2.50 per 1,000 at 200K). At Smarty’s own ~5 keystrokes per address estimate, that’s $12.50-$20 per 1,000 completed addresses. There’s no overage billing: a depleted plan returns HTTP 402 rather than silently charging, which is either a safety feature or an outage risk depending on your temperament. Free tier is a 42-day/1,000-lookup trial only. Validated results are yours to keep permanently (the exception is rooftop geocodes, which require an active subscription). US-only; their separate International product covers 249 countries and bills per selection instead of per keystroke.

Loqate

Loqate (GBG) inverts the billing model: its Find type-ahead calls are explicitly free, and you’re charged one credit only when the user selects an address and you call Retrieve.

GET https://api.addressy.com/Capture/Interactive/Find/v1.20/json6.ws
    ?Key=AA11-AA11-AA11-AA11&Text=1600 Penn&Countries=US&Limit=10

GET https://api.addressy.com/Capture/Interactive/Retrieve/v1.30/json6.ws
    ?Key=AA11-AA11-AA11-AA11&Id=US|...  (this call bills)

Pricing is prepaid credits: US/Canada captures run 4.3-5.0 cents per completed address ($43-$50 per 1,000), international 6.1-10.8 cents, credits expire after 12 months. That headline rate is 10x Smarty’s per-unit price but only 2-3x per completed address once you account for free keystrokes, and it buys the most pedigreed data in the business: a proprietary global database built from 250+ postal authority partnerships, CASS, AMAS and SERP certified, covering 250 countries. This is the enterprise answer when international address quality is the requirement and the per-address cost is a rounding error. Free tier is a 45-day trial.

Geocode Earth

Geocode Earth is hosted Pelias (the open-source geocoder) run by the team that built it, on fully open data: OpenAddresses, OpenStreetMap, Who’s on First and Geonames.

GET https://api.geocode.earth/v1/autocomplete
    ?api_key=KEY&text=1313 broadw&boundary.country=US

Responses are GeoJSON features with a Pelias label, layer and source per result. Flat plans: $100/month for 150K requests, $200 for 400K, $500 for 2M, which is $0.25-$0.67 per 1,000 keystroke requests, with soft limits that 403 rather than overbill. You can store results forever with no royalties, and they commit to never selling your users’ location data. Same open-data coverage caveats as Geoapify (new construction lags), same unlimited-storage upside. 14-day trial, no recurring free tier.

Radar

Radar bundles autocomplete into its Core Maps tier at a published floor of $0.50 per 1,000 requests, the cheapest per-request price from a venture-scale vendor, with rich responses (components, coordinates, layer) and global open-plus-commercial data.

GET https://api.radar.io/v1/search/autocomplete?query=1600 penn&layers=address
Authorization: prj_live_pk_...

Two things changed recently: Radar no longer offers its old 100,000 calls/month free tier (the pricing page now says every plan starts with a sales quote on an annual commitment), so third-party roundups still quoting the free tier are stale. And its terms cap caching at 30 days, so no permanent storage. It’s a strong value at volume if you’re fine with the sales process.

Geocodio (Not Actually Autocomplete)

Geocodio earns a mention because it keeps appearing in autocomplete comparisons while its own docs say it doesn’t belong there: there is no type-ahead endpoint, and Geocodio recommends Geocode Earth, Google, Mapbox or Smarty for that job. What it does offer is backend address completion (send a partial address, get a standardized full address with coordinates) at $1.00 per 1,000 lookups with the most generous recurring free tier anywhere: 2,500 lookups per day, forever, no credit card, plus near-unrestricted storage rights including resale. The right tool for cleaning and completing addresses you already have, not for the checkout form.

Placematic (HERE in a Trench Coat)

Placematic markets its own address autocomplete, but it’s a HERE Technologies Gold Partner reselling HERE Location Services under a single US contract; every product in its documentation is a HERE API. HERE’s list rate for Geocoding & Search (which includes autocomplete) is $0.88 per 1,000 requests under 5M annually, with a 30,000 request/month free tier, on strong proprietary data covering 190+ countries. One flag from the research: Placematic’s marketing claims unrestricted storage of results, while HERE’s standard terms cap caching at 30 days. If storage matters, get the negotiated term in writing rather than trusting the landing page.

Build Your Own with OpenAddresses

If you want no meter, no caching TTL and no vendor risk, the raw material is free.

OpenAddresses collects government address point files (county assessors, city GIS departments, national cadastres) into a standard schema: 3,220 sources, roughly 600M+ addresses globally with the US as its strongest region, updated on a weekly pipeline at batch.openaddresses.io. Downloads are line-delimited GeoJSON per source, or regional collection zips (the four US regions total about 24.5 GB compressed; addresses alone are about 7.8 GB).

The honest build looks like this:

  1. Acquire and filter by license. Each source carries its own license metadata with attribution and share-alike booleans. Pull per-source files, exclude share-alike and presumed-license sources for commercial use, and generate an attribution manifest for the rest. This step is not optional.
  2. Normalize. OpenAddresses standardizes field names, not values. USPS Pub 28 suffix and directional standardization, ZIP normalization, junk-row rejection and deduplication across overlapping county/state sources will consume 10-25% of rows and most of your engineering time. This is where DIY projects die.
  3. Load and ETL in BigQuery or DuckDB. A 500M row address table is only ~60 GB logical in BigQuery, about $1/month to store and $0.36 per full-table scan, which makes it a great place to run the dedupe joins.
  4. Serve from Postgres or a search engine, not BigQuery. This is the trap in the outline’s premise: a clustered BigQuery autocomplete query scans 0.5-2 GiB, costing $3-$12 per 1,000 queries at $6.25/TiB with 0.5-2 second latency. That’s more expensive than every commercial API above and too slow for type-ahead. Export the cleaned table and serve it from Postgres (text_pattern_ops for prefix matching, pg_trgm for typos, PostGIS for proximity bias) or Typesense/Meilisearch with edge n-grams, on a $40-$150/month box that handles unlimited requests.
CREATE TABLE addresses (
  id bigserial PRIMARY KEY,
  number text, street text, unit text,
  city text, region text, postcode text,
  lon double precision, lat double precision,
  search_key text  -- "123 MAIN ST ANDOVER MA 01810"
);

CREATE INDEX addr_prefix_idx ON addresses (search_key text_pattern_ops);
CREATE EXTENSION pg_trgm;
CREATE INDEX addr_trgm_idx ON addresses USING gin (search_key gin_trgm_ops);

Break-even math: against sthan’s free 100K/month it never pays off at low volume, and against Radar’s $0.50 per 1,000 it breaks even around 300-400K requests/month on infrastructure alone, before valuing the 2-6 weeks of normalization engineering. The real reasons to build are ownership: permanent storage, no per-request meter, no terms-of-service surprises like the ones that burned Google’s users in 2025. Or skip the build and run Pelias, the open-source engine behind Geocode Earth, which ships an OpenAddresses importer and costs you an Elasticsearch cluster instead.

Where the Data Comes From

Almost every provider above is a layer over the same handful of upstream sources, and the differences you’re paying for are freshness, merging quality and licensing terms:

  • USPS – The master list of deliverable US addresses, licensed to validation vendors. CASS certification (Smarty, Loqate) means output conforms to it.
  • County and city records – Parcel, assessor and E911 address points; the raw feed behind both OpenAddresses and commercial compilers.
  • Federal open data – Census TIGER street ranges and the DOT’s National Address Database.
  • Open projects – OpenAddresses and OpenStreetMap, powering Geoapify, Geocode Earth and parts of Mapbox.
  • Commercial compilers – HERE, TomTom, LightBox, Regrid and Precisely merge all of the above, add their own collection, and license the result to the APIs that look proprietary.

The Comparison, Normalized

Approximate cost per 1,000 completed addresses (assuming ~5 billed keystrokes per address where billing is per request), as of October 2026:

Provider ~$/1,000 addresses Free tier Store results? Coverage
sthan.io $0.12-$0.35 100K/mo forever Terms unpublished US + India
Geoapify ~$1 (flat plans) 3K/day forever Yes, with attribution Global, open data
Geocode Earth $1.25-$3.35 14-day trial Yes, forever Global, open data
Radar ~$2.50+ None (sales only) 30-day cache max Global
HERE / Placematic ~$4.40 30K req/mo 30-day cache (standard terms) 190+ countries
Mapbox Autofill $7.50-$12.50 1K sessions/mo Text yes, coordinates no US + ~45 countries
Smarty (US) $12.50-$20 42-day trial Yes (geocodes excepted) US (intl separate)
Google Places $14-$39 10K req/mo No Global, best data
Loqate $43-$50 US / $61+ intl 45-day trial Unpublished 250 countries
DIY OpenAddresses ~$40-150/mo flat n/a Yes, you own it US-strong, uneven

My recommendations after living through the Google migration with client checkouts this year: for a US eCommerce checkout where deliverability matters, Smarty’s verified-only suggestions earn their price. For general forms at startup volume, Geoapify’s free tier or Mapbox’s session pricing are the sane defaults. For international enterprise, Loqate. And if you’re still on Google’s legacy Autocomplete widget on a pre-2025 project, migrate on your own schedule before Google picks one for you; the twelve-month shutdown notice they’ve promised will not feel like a long time.