Address Autocomplete API: Complete a List of Partial Addresses

Complete a list of half-typed addresses into full addresses with coordinates and split parts. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to take this list of partial addresses, find the matching full address for each one, pick the best match, and give me a table with the matches found, the chosen address, its coordinates, and the house number, street, city and postcode as separate columns. Flag any partial that matched more than one place.

One prompt completes a whole list. 1 min setup · 3-8 hrs saved.

You have the start of an address, such as a street number and half a street name, and you want the right full address back. That is what an address autocomplete API does. This guide is honest about one limit first: calls through Monid took between 2.5 and 7.5 seconds each in our runs, so they cannot power type-ahead in a live browser form where a suggestion has to appear in a fraction of a second. They fit the jobs where a program or an agent completes addresses after the fact: a list of partial addresses from a form export or a call log, a place an agent has to resolve, a set of landmarks to geocode and parse. Below is a real table from a small sweep we ran on 2026-10-23, how to read it, and how to run the same job on your own list.

What is an address autocomplete API?

An address autocomplete API takes a partial address and returns the full addresses it could mean, usually ranked, often with a location attached. Developers add one to a checkout or signup form so a customer types a few characters and picks their address from a dropdown. The same lookup also works away from a form, on text that is already typed.

That second use is the one that matters here. Two jobs get called "autocomplete" and they need different tools:

• Type-ahead in a form. A person types, and suggestions refresh with every keystroke or two. This needs a response in a fraction of a second and a browser-side script. A maps vendor's widget or an index you host is built for this.
• Completing partial addresses in a batch. You already hold the partial text, a program or an agent works through it, and nobody is waiting on a dropdown. Seconds per address is fine.

Monid covers the second job. Its catalogue holds endpoints that suggest addresses from partial text near a map position, and endpoints that turn an address into coordinates and split parts. Your agent calls them one address at a time and builds the table. If you want a live dropdown, jump to the section on other routes; if you have a list, keep reading.

Two terms used below: geocoding takes an address or a place name and returns coordinates and a standard form (it also accepts a partial one and returns its best candidates), and parsing splits an address into house number, street, city and postcode, because a database column wants parts.

What is the easiest way to complete a list of partial addresses?

Monid. Install it once, add a key, and your agent looks up each partial address, returns the candidates and parses the one you keep. There is no maps account to open, no billing profile to attach and no key to restrict to a domain; you get a table back in the chat.

• Pay per call. A geocoding call that takes a partial address and returns candidates with parts is $0.01 (Verified 2026-10-23 on the local data tools page). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free; only a run bills.
• One install, every tool. The same key and balance call the autocomplete endpoint, the geocoder and everything else on Monid.
• Lives inside your agent. Your agent reads SKILL.md and learns the rest. Setup is about a minute.

Here is what came back. We sent three partial addresses on 2026-10-23, all landmarks or public buildings, and had the agent keep one row each. Two more rows from earlier calls the same day show the other endpoint, so the table has five:

The first three rows are one geocoding call each, three candidates asked for, $0.01 a call, $0.03 for the three (Verified 2026-10-23). The last two used the autocomplete endpoint at $0.015 a call, and the Amphitheatre row added one geocoding call for the parts. Five rows cost $0.07 across six calls.

How do you read the address table?

Read each row for one thing: did the partial resolve to a single address you can store, or does a person need to look at it. The advice below is an editorial reading of the five rows, not a measured effect.

What does a row with one clear match mean?

Store it. The Ferry Building row returned two candidates: the building with house number 1 and postcode 94111, and a taxi stand with the same number on a nearby path. A clear match is the thing you meant, ranked first, with a house number present. Keep the full address, the coordinates, and the parts as separate columns.

Why can three matches still be one address?

Because a building holds several places that share its street address. The Wacker Drive row returned Willis Tower, a viewing deck inside it and a restaurant, all at 233 on the same road with postcode 60606. Count distinct addresses, not rows, and keep the first.

What does a row with no house number mean?

That the partial did not resolve to a building. The Lincoln Memorial row returned two road segments with a postcode and no house number. Do not store it as an address. Send it to review, or add the missing detail and run it again.

What should you do when one partial matches several cities?

Add the city and run it again. 350 5th Av returned five suggestions across Brooklyn, Paterson, New York and River Edge, and the Brooklyn one ranked first even with a Manhattan map position. A street name and number repeat across a metro area, so the position is a hint, not a filter. If your list has a known city, discard suggestions from other cities; if not, treat the row as unresolved.

The short rule for the whole table: a row is safe to store when it has one house number, one road and one postcode across its matches. Everything else goes to a person.

How do you set up address completion in five minutes?

Get a key, tell your agent to learn Monid, then give it your list and a position or a city for each batch.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

Then give it your list

Paste the partial addresses into the chat, with the city or area they belong to, and use a prompt like this one:

The city in the prompt does the work of a map position: it stops "Main St" from resolving to the wrong state.

How long does a batch take, and what does it cost?

Plan for about three to four seconds per address and one to two cents per address. Our three geocoding calls took 2.5, 3.7 and 2.5 seconds start to finish (2026-10-23), and the two autocomplete calls took about 3.9 and 7.5 seconds. A list of 400 addresses is 400 calls: a few minutes when run one after another, less when several run at once.

On cost, at $0.01 a geocoding call (Verified 2026-10-23), 400 addresses cost $4.00. If you add the autocomplete step first at $0.015 a call, 400 addresses cost $6.00 for the suggestions plus $4.00 for the parts, $10.00 together. The autocomplete endpoint bills an empty result like any other search, so test a handful of inputs first.

Why not call it on every keystroke? A user typing a 25-character address with a call per character would cost $0.375 for that one address at the autocomplete price (Verified 2026-10-23), and each call would take seconds. Use the endpoints for the batch and a purpose-built widget for the form.

How do you build address completion into your own pipeline?

Call the geocoder once per partial address, read the candidates, apply the one-address rule from the table, and store the result. This section is for the person wiring it into a script.

Complete one partial address

monid inspect -p api.kadec0.xyz -e /v1/geocode

Inspecting is free. The call is a GET: q takes the partial address, and maxItems sets how many candidates you want and is a string, not a number.

monid run -p api.kadec0.xyz -e /v1/geocode -w \
  --query '{"q":"233 S Wacker Dr Chic","maxItems":"3"}'

Each item has displayName, lat, lon, a category, and an address object with house_number, road, city, state, postcode and country_code.

Get ranked suggestions near a position

When you only have a partial street and a rough area, the autocomplete endpoint takes a map position:

monid run -p serpapi -e /google/maps-autocomplete -w \
  --query '{"q":"1600 Amphitheatre Pk","ll":"@37.4220,-122.0841,14z","gl":"us","hl":"en"}'

q and ll are both required. ll is @ plus latitude, longitude and a zoom such as 14z, or a radius in meters such as 10410m. A suggestion carries a label, a type of place or keyword, and a coordinate on place rows. It does not carry a postcode or a house number, which is why the Amphitheatre row needed a second call for its parts. To find the businesses at a place rather than complete its address, Google Maps scraper alternatives compares the routes.

Loop it over a file

With one partial address per line in partials.txt:

mkdir -p out
n=0
while IFS= read -r partial; do
  n=$((n+1))
  monid run -p api.kadec0.xyz -e /v1/geocode -w \
    --query "{\"q\":\"$partial\",\"maxItems\":\"3\"}" > "out/$n.json"
done < partials.txt

To check or standardise complete addresses next, see Address Validation API.

Turn candidates into a verdict

def address_row(partial, items):
    keys = {(i["address"].get("house_number"),
             i["address"].get("road"),
             i["address"].get("postcode")) for i in items}
    first = items[0]["address"] if items else {}
    return {
        "partial": partial,
        "matches": len(items),
        "one_address": len(keys) == 1 and None not in next(iter(keys)),
        "house_number": first.get("house_number"),
        "street": first.get("road"),
        "city": first.get("city"),
        "postcode": first.get("postcode"),
    }

one_address is the rule from the table. Parse each saved file with json.load and pass the run's output["items"].

What went wrong in our runs

• Two map sources sit behind one endpoint. The Wacker Drive response carried "source": "photon", an osmType of W or N and a null importance; the Ferry Building and Lincoln Memorial responses carried an importance score and an osmType of way or node. Read fields defensively and do not sort by importance.
• A suggestion row of type keyword has no coordinate. Our Amphitheatre response held four keyword rows, completed query strings with no location. Filter on type place when you need a coordinate.

Which endpoint should I use for which job?

We ran the first two rows on 2026-10-23. The validate row was inspected and not run, because its listed price is above the no-run line. Current figures are on monid.ai/tools.

A common pipeline runs the geocoder on every partial, keeps the one-address rows, and sends the rest to a person or to the autocomplete endpoint with a city added.

When is another route a better fit?

You are building a live search box. Our calls took seconds and are billed one by one, so a form that needs a suggestion per keystroke belongs on a maps vendor's widget or a prefix index you host. Those are built for keystrokes, and map vendors often meter by session.

You need deliverable addresses. A match says a place exists on a map. Whether mail reaches a unit is a postal-data question.

Your market is outside the US, or you need house-level precision on every row. We ran US landmarks, and one road-only partial did not resolve to a building. Run fifty of your own addresses first and count the rows without a house number.

Rules apply to your data. Rules on storing addresses differ by country, so check yours.

And the disclosure: we resell these endpoints. The most useful habit here works whoever you buy from: send a known-good partial and a deliberately ambiguous one to any endpoint before trusting it, which costs two calls.

Conclusion

The quickest way to turn a list of half-typed addresses into full addresses with parts is one lookup per address through Monid: $0.01 a call on the geocoder and $0.015 on the autocomplete endpoint (Verified 2026-10-23), one key for both and everything else, about a minute to set up and no monthly plan.

Two things matter more than the endpoint. Decide whether you are batching or typing: this route suits a job or an agent, and a live search box wants a widget or an index of your own. And keep the one-address rule: store a row only when every match shares one house number, one road and one postcode, and send the rest to a person.

How we estimated the time saved: completing a list by hand means searching each partial in a map, picking the right result and copying the parts into columns, about 1 to 2 minutes per address with a lookup open in another tab. For a list of 200 addresses that is 3 to 7 hours; with the extra checking on ambiguous rows, 3 to 8 hours per list. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run the prompt above on three partial addresses and read the table. Start at monid.ai.

FAQ

Published October 2026.