Skip to content

Address Autocomplete

In short

The Address Autocomplete documentation covers authentication, the suggestion endpoint, how partial and misspelled input is matched, the response fields for each suggestion, error handling and copy-ready examples. Requests use the same bearer token as the rest of the Geoverio platform.

Last reviewed 11 September 2026

Key facts

authentication method
bearer token
address coverage
200+ million US addresses
response time
a few milliseconds
typo handling
fast, typo-tolerant

Fast, typo-tolerant US address autocomplete

Base URL https://autocomplete.geoverio.com

Overview

What Address Autocomplete does

Type-ahead address suggestions from 200+ million US addresses, in a few milliseconds. Wire it to your address field and users pick their verified address in 3-4 keystrokes — with city, state, ZIP and coordinates filled in automatically.

Perfect for Checkout and signup forms Delivery address entry CRM data entry that stays clean Anything that hates typos in addresses

Authentication

Every request needs a key

Send your key as a bearer token in the Authorization header. That is the only accepted scheme — there is no query-string key and no cookie login.

Header Authorization: Bearer gv_live_…
Question Answer
Where do I get one? Select a plan first — the free tier counts — then open Dashboard → Projects. Keys belong to a project: open one and choose Create key. If you are not signed in yet, that link takes you through sign-in first.
What does it look like? A long string beginning gv_live_. Copy the whole thing — a truncated key returns 401.
Where do I keep it? On your server, in an environment variable. Never in browser JavaScript, a mobile app bundle, or a public repository — anyone who reads it can spend your quota.
Leaked it? Revoke it from the project that owns it under Projects and create a new one. Revoking takes effect immediately.

New here? The getting started guide walks through account, plan, key and first call step by step.

Reference

Every endpoint, explained

Copy a sample, swap in your key, and you are live. Each endpoint lists exactly what it accepts and returns.

GET /v1/autocomplete Get address suggestions

Returns ranked address suggestions for a partial query. Call it on every keystroke after the 2nd character.

Parameters

Name Type Required Description Example
q string required What the user has typed so far — part of a street address, a city name, or a ZIP prefix. Minimum 2 characters. 1600 amph
limit integer optional Maximum suggestions to return (1-20). Default is 8 — a good dropdown size. 5
state string optional Two-letter state code (e.g. CA) to bias results toward that state. If omitted, we auto-detect the caller's state from their IP so nearby addresses rank first. CA

Code samples

# Keep the key in the environment, not in your shell history:
#   export GEOVERIO_API_KEY="gv_live_…"

curl --fail-with-body "https://autocomplete.geoverio.com/v1/autocomplete?q=1600%20amph&limit=5&state=CA" \
  -H "Authorization: Bearer $GEOVERIO_API_KEY"
// Call this from your server, never from the browser:
// front-end JavaScript ships your key to every visitor.
const KEY = process.env.GEOVERIO_API_KEY;

async function main() {
  const res = await fetch("https://autocomplete.geoverio.com/v1/autocomplete?q=1600%20amph&limit=5&state=CA", {
    headers: {
      Authorization: `Bearer ${KEY}`
    }
  });

  // Never parse the body before checking the status: an expired key answers
  // 401 with a perfectly valid JSON envelope.
  if (!res.ok) {
    throw new Error(`HTTP ${res.status} — ${await res.text()}`);
  }

  console.log(await res.json());
}

main().catch((err) => {
  console.error(err);
  process.exitCode = 1;
});
# pip install requests
import os, requests

url = "https://autocomplete.geoverio.com/v1/autocomplete?q=1600%20amph&limit=5&state=CA"
headers = {"Authorization": "Bearer " + os.environ["GEOVERIO_API_KEY"]}

r = requests.get(url, headers=headers)
r.raise_for_status()   # turns 4xx / 5xx into an exception instead of silent bad data
print(r.json())
<?php
// Read the key from the server environment — never commit it.
$key = getenv('GEOVERIO_API_KEY');

$ch = curl_init("https://autocomplete.geoverio.com/v1/autocomplete?q=1600%20amph&limit=5&state=CA");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer $key",
    "Accept: application/json",
]);

$body   = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
curl_close($ch);

if ($status < 200 || $status >= 300) {
    fwrite(STDERR, "Request failed — HTTP $status: $body\n");
    exit(1);
}

print_r(json_decode($body, true));
See a sample response
{
    "query": "1600 AMPH",
    "count": 3,
    "suggestions": [
        {
            "label": "1600 Amphitheatre Py, Mountain View, CA 94043",
            "house": "1600",
            "street": "Amphitheatre Py",
            "city": "Mountain View",
            "state": "CA",
            "zip": "94043",
            "lat": 37.4220221,
            "lon": -122.0842902,
            "tax_query": "1600 AMPHITHEATRE PY MOUNTAIN VIEW CA 94043"
        },
        {
            "label": "1600 Amphitheatre Pkwy, Mountain View, CA 94043",
            "house": "1600",
            "street": "Amphitheatre Pkwy",
            "city": "Mountain View",
            "state": "CA",
            "zip": "94043",
            "lat": 37.4220018,
            "lon": -122.0849364,
            "tax_query": "1600 AMPHITHEATRE PKWY MOUNTAIN VIEW CA 94043"
        },
        {
            "label": "1600 Amphitheatre Parkway, Mountain View, CA 94043",
            "house": "1600",
            "street": "Amphitheatre Parkway",
            "city": "Mountain View",
            "state": "CA",
            "zip": "94043",
            "lat": 37.4230075,
            "lon": -122.0830662,
            "tax_query": "1600 AMPHITHEATRE PARKWAY MOUNTAIN VIEW CA 94043"
        }
    ]
}

Response fields

What every field means

No mystery keys. Here is a plain-English explanation of everything the API sends back.

suggestions[].label
The full address formatted for display, ready to drop into a dropdown row: "1600 Amphitheatre Pkwy, Mountain View, CA 94043".
suggestions[].house / street / city / state / zip
The same address already split into components, so you can fill five form fields from one pick instead of parsing the label yourself.
suggestions[].lat / lon
Coordinates for the address, for map pins, distance checks and delivery-zone logic.
suggestions[].tax_query
A normalised, upper-cased address string built to be passed straight into the Sales Tax Finder API. Pick an address here, send this string there, and you get a rooftop-confidence tax rate with no address parsing in between.
count
How many suggestions came back. 0 means no match — show your "enter it manually" fallback rather than an empty dropdown.
query
The normalised form of what you sent. Because typeahead responses can arrive out of order, compare this against the current input before rendering — if it no longer matches what the user has typed, drop the response.

Good to know

Wiring it into a real form

A typeahead lives or dies on details. These are the ones that matter.

Debounce, and drop out-of-order responses
Calling on every keystroke is what this API is built for, but the network is not ordered: a request for "160" can easily land after the one for "1600 amph". Debounce roughly 120-150 ms, and before rendering compare the response's query field against the current input — if they differ, throw the response away. Those two rules are the difference between a typeahead that feels instant and one that flickers.
Results are biased to the caller's state automatically
With no ?state= parameter we detect the caller's US state from their IP and rank nearby addresses first, so the right suggestion usually appears within three or four keystrokes. If you proxy these calls through your own backend, the API sees your server's IP rather than the user's — either forward the real address in X-Forwarded-For, or pass ?state= explicitly.
Keep your API key on the server
A typeahead runs in the browser, which makes it the easiest place to leak a key. Call this API from a thin endpoint on your own backend that adds the Authorization header, and let the browser talk only to your endpoint. Never ship gv_live_ keys to the client.
Sensible limits
q must be at least 2 characters; limit accepts 1-20 and defaults to 8, which is about as many rows as a dropdown can show before it stops being scannable. Asking for 20 costs no more than asking for 8, but it does give the user more to read.

Errors

When things go wrong

Every failure is JSON, and every failure carries the same field. Here is the shape, then every status code you can actually receive.

The error envelope

The API returns one field, detail, with a human-readable explanation. Parse that and you have handled every error on every endpoint.

401 https://autocomplete.geoverio.com
{
  "detail": "Invalid API key"
}
Status Name What to do
401 Missing or invalid API key The Authorization header is missing, malformed, or the key does not exist. Double-check you copied the whole key, including the gv_live_ prefix.
403 Key not allowed Your key is valid but not allowed to call this API — usually the key was revoked or your plan does not include this module.
422 Invalid parameters A required parameter is missing or out of range. The response body tells you exactly which one.
429 Rate limit exceeded You sent too many requests this minute. Check the X-RateLimit-Reset header for when the window resets, then retry.
400 Bad request The query string or JSON body could not be parsed — an unencoded character, a truncated body, or the wrong Content-Type. Fix the request; retrying it unchanged will fail again.
404 No such endpoint The path does not exist on this API. Check the base URL and the version prefix — every path on this page starts with /v1.
405 Wrong method Right path, wrong verb — for example a GET against an endpoint documented as POST. The reference above lists the verb for every endpoint.
429 Monthly quota exhausted Different from the rate limit above: your plan's allowance for the calendar month is gone, so waiting a minute will not help. X-RateLimit-Remaining is 0 and X-RateLimit-Reset points at the start of the next period. Upgrade your plan or wait for the reset.
500 Internal error Something failed on our side. The request was not your fault and was not billed — retry with backoff.
502 Bad gateway An upstream hop failed mid-request. Safe to retry with backoff.
503 Temporarily unavailable The API is draining or deploying. Safe to retry with backoff; honour Retry-After when it is present.
504 Upstream timeout The request took longer than the gateway allows. Safe to retry with backoff — and make sure your own client timeout is generous enough not to abandon a request the API is still answering.

Retrying safely

4xx means stop. The request is wrong and will stay wrong — fix it rather than repeating it. The one exception is 429: wait for the window in X-RateLimit-Reset and try again.

5xx means retry, but back off. Every endpoint on this page is a read, so a retry is safe. Wait 1s, then 2s, then 4s, then 8s — up to four attempts — and add a random 0–250 ms jitter so a fleet of your servers does not retry in lockstep. Give up after that and surface the failure; honour Retry-After whenever the response carries one.

Limits

How much you can call, and how fast

Two separate budgets, and you can hit either one. Quota is a monthly total, counted per account — every key in every project spends the same pool. Rate is a per-minute ceiling on how quickly you spend it. Both are reported on every response by the X-RateLimit-* headers, so your code can see either limit coming before it arrives.

Plan Requests / month Requests / minute API keys
Free 1,000 30 1
Pay As You Go Metered — no monthly cap 600 5
Starter 100,000 300 3
Growth 1,000,000 1,200 10
Scale 5,000,000 5,000 50

Pay As You Go is metered rather than capped: it has no monthly allowance to exhaust, it draws on a prepaid balance, and it stops when that balance runs out. Every other plan returns 429 with X-RateLimit-Remaining: 0 once its monthly quota is spent, until the next period begins. Full pricing lives on the pricing page.

Rate limits

Headers that keep you informed

Check these response headers to see exactly how much room you have left — before you ever hit a limit.

Header Meaning
X-RateLimit-Limit Your plan's requests-per-minute allowance.
X-RateLimit-Remaining Requests you have left in the current minute.
X-RateLimit-Reset Unix timestamp when the window resets.

Ready for your own key?

Create a free account, mint a key, and try every endpoint live from your dashboard’s Test APIs page.

Frequently asked questions

What does the Address Autocomplete API do?
Fast, typo-tolerant US address autocomplete.
How do I authenticate with the Address Autocomplete API?
Send your key as a bearer token: `Authorization: Bearer <your key>`. One key works across every Geoverio API your plan includes.
Is there a free tier?
Yes. Every plan reaches every API; the free tier differs on monthly volume and rate limit, not on which endpoints you may call.