We measured our address search on 5,000 real queries. Here is every number.
First-result accuracy of our address search on 5,000 real queries, how it works inside Postgres, and what it costs next to other UK providers.
Every address lookup provider in the UK sells accuracy. Almost none of them publishes a number for it. We built an address search on Ordnance Survey data, measured it on 5,000 real queries drawn from the national register, and this post gives every figure we have, the method behind it, how the thing works inside Postgres, and what it costs next to the providers you might otherwise pay.
The short version
- 92.2% of queries return the right property as the first result, across five ways of typing, including typos and queries with no town. 95.0% have it in the top three.
- 97.1% for a clean address, 96.0% for lower case with no commas, 99.8% with a postcode, 96.2% with one typo, 72.1% for a partial address with no town.
- 88.4% of businesses found by name alone return the right address first; 96.6% land on the right business in the right town.
- 16 ms median search time, 235 ms at the 95th percentile, before network and authentication.
- Address lookup costs 2 credits (2p) a resolve through the API or MCP, 1 credit (1p) by UPRN, with the UPRN and coordinates included and autocomplete free; the same lookups are free inside MarketCode itself.
What we measured and how
We drew 1,000 addresses at random from the register: 100 from each of the nine English regions and Wales, 60 houses and 40 flats in each, stratified so that named houses, new builds and flats in large blocks are all represented in their real proportions. Every address was then typed five ways, the way people actually type:
- Clean, as it appears on a letter: "12 Oak Road, Tewkesbury".
- Natural: lower case, no commas, the flat written as people say it.
- With the postcode.
- With one typo: a letter dropped, doubled or swapped in the street or house name.
- Partial: the house and street with no town and no postcode.
That is 5,000 queries, plus 200 postcode lists checked for whether the right home appears at all. A query counts as right only when the first suggestion carries the correct Unique Property Reference Number (UPRN), the identifier the register gives every address. Text similarity does not count. A plausible-looking wrong answer is a miss.
The runs are made offline against the same warehouse the live service reads, which takes minutes rather than days and has no rate limits. We checked the method against the live API once, on a different draw, and the two agreed within half a point (89.0% live against 88.6% offline, before the rebuild described below). Every change to the matcher has to pass the same gate before it ships: no typing style may fall by more than one point, no large group of addresses by more than two, and the 95th-percentile latency may not get more than a fifth slower.
The results
Overall, across all 5,000 queries: 92.2% right first time, 95.0% in the top three, 96.1% somewhere in the list, 0.2% with no answer at all. Every one of the 200 postcode lists contained the home.
By typing style, first result right (top three in brackets):
- Clean address: 97.1% (98.7%)
- Natural, lower case, no commas: 96.0% (97.9%)
- With postcode: 99.8% (99.9%)
- One typo: 96.2% (97.7%)
- Partial, no town or postcode: 72.1% (81.0%)
By kind of address: flats 95.8%, houses 89.9%. Houses carry almost all of the partial-query penalty, because "12 Oak Road" exists in far more towns than "Flat 3, Thornbury Court" does. Named houses, the group most matchers handle worst, are at 97.0%. New builds are at 94.1%, flats in large blocks at 97.5%, and houses that sit inside a named block (the "85, Block 1 to 126" pattern) at 89.3%.
By region, first result right: between 89.2% (North West) and 94.4% (London). East of England 93.2%, West Midlands 93.6%, South East 92.8%, South West 92.4%, North East 91.8%, Wales 91.8%, East Midlands 91.6%, Yorkshire and The Humber 91.6%.
Businesses were a separate benchmark, because the query is different: 270 businesses drawn from the register, one per postcode, 30 per region, each typed four ways (name and town, name and street, name and postcode, lower case with no commas). The right address came first 88.4% of the time, another address of the same business at the same postcode counts for 93.5%, and the same business in the same town for 96.6%. By name and postcode alone it is 98.1%; by name and town, the hardest form, 84.8%.
Speed, measured as the search itself: median 16 ms, 90th percentile 149 ms, 95th percentile 235 ms, 99th percentile 2.8 s. The long tail is the small share of queries that fall through to a scan of the whole register.
Where it still goes wrong
We would rather you heard this from us.
- A partial address with no town is right 72% of the time. "12 Oak Road" matches hundreds of streets and nothing in the text says which. We considered guessing from the visitor's network location and rejected it: people are not necessarily searching where they are. The fix is to use context the user has already given, the map they are looking at or the place of their last search, and only to order ties with it. That is the next piece of work, and we will not quote a number for it until it is measured.
- A business with several sites in one town cannot be told apart by name and town. A fire service with three stations, a supermarket with two stores. That is most of what the business benchmark still misses.
- A misspelt three-letter word, and a part of a building that the register files under a different line than the one typed, still fall to the slower whole-register pass, or are not found.
- The 99th percentile is 2.8 seconds. Bringing the tail down is the next engineering item after the map context.
The data
The search runs over Ordnance Survey's address data, which we hold in our own warehouse under licence: the OS National Geographic Database (NGD) Address theme and AddressBase Premium. Flattened, that is 34.7 million addresses with a UPRN, a street identifier (USRN), coordinates, a classification and, for 1.64 million of them, the name of the organisation at the address. Coverage is England (29.7 million addresses), Scotland (3.1 million) and Wales (1.7 million). Northern Ireland is not in the register. The release we benchmarked against is the July 2025 release; a refresh is scheduled, and the figures above will be re-run on it with the same method.
The benchmark sample itself is drawn from licensed data, so we publish the method and the aggregate scores and not the sampled rows.
How it works
There is no search engine and no model in the loop. The matcher is Postgres, next to the data, with the matching written as one SQL statement and a scorer. Here is the whole design.
Four gazetteers, built from the register
From the register we build four lookup tables as materialized views: every street by its official identifier, with every locality, town and post town along it (907,000 rows); every named building and house (3.4 million); every place name with the postcode districts it covers (110,000); and every business by name, street and postcode (1.56 million). Each row carries two keys: a spaceless, upper-case form of the name, so that "Hills borough Court" and "HILLSBOROUGH COURT" are the same bytes, and a consonant skeleton, so that "Parksttone House" meets PARKSTONE HOUSE on a single index probe. The views are clustered on the name key, so all the rows of one name sit on a few adjacent pages. That last detail mattered more than it sounds: before it, a search for "tesco tewkesbury" read 3,213 rows from 2,229 scattered pages on a cold cache, 720 milliseconds; after it, under a millisecond.
Spelling is corrected before anything is searched
A fifth table holds every word that appears in those names (499,000 words) and, for each, every spelling with one letter deleted (1.66 million keys). This is the SymSpell idea: to correct "Tasny", we delete one letter from it in each position and look those forms up with one indexed query; any dictionary word that shares a deleted form is within two edits. Candidates are ranked by their count among street and building names first and business names second, so that a brand never crowds out a street ("Tasny Road" is TANSY ROAD, not TASTY). The last word of a query that is still being typed is never corrected, because "hillsb" is the start of HILLSBOROUGH and not HILLS with a letter too many. Trigram similarity, the usual first resort, is our last: it runs only for a word the dictionary has never met in any form.
One statement
The typed words are cut into windows: every run of one or more adjacent words, with the words that remain treated as the candidate name's place. Each window becomes a range probe on a B-tree in C collation against the spaceless keys. Every name the probes return is checked against the remaining words: is each of them in the name's own context (its street, localities, towns, council), or a place that the place gazetteer puts in one of the name's postcode districts? A name that explains every other typed word is "placed", and placed names outrank everything else. Among thousands of namesakes ("The Grange" is 2,116 buildings), the rows the other words place are read first, before the per-window limit cuts. A bounded number of groups (twelve) then expands into real addresses: the building itself, the typed flat through a flat index, the typed house number first and a sample of the rest. Every stage has a fixed limit (2,000 rows per window, 12 groups, 150 candidates) and the whole statement runs under a 1.5-second budget, so the worst query is bounded and a slow one falls through to the next tier rather than hanging.
Two rules in that statement came straight out of the benchmark's failures. A typed place that no name can be placed by is no answer from this tier at all, even when a house number matches: "22 Dion Close, Sale" is not 22 Don Close in Reading because 22 was typed. And a business name is read like a building name, as one explanation of the typed words and never a second credit, so that "The Thorndale" the business cannot outscore "The Thorndale" the building a flat is in.
The scorer
The 150 candidates are scored in Python with explicit features and no training: the house number (including the register's numeric building names, "12A"), the flat in any of its forms (A0808, B306 Block B, 31A to 31B, Ground Floor, "the flat"), the building or business name, the street, the place words, how much of the typed text the candidate explains and how much of the candidate's own name was never typed, the size of the place as a prior, and whether the candidate's postcode agrees with a typed one. Names are scored by whole-word coverage, with a word-level allowance for misspellings and for words run together. Ties are interleaved across buildings so that one long block cannot fill the list. A confidence figure comes from the gap between the first and second candidate.
The cascade and the caches
The search is a cascade of tiers, each a fallback for the one before: an exact match of a whole pasted address from its postcode's rows; the gazetteers above; an older name lookup; and, last, a bounded scan of the register by trigram similarity. Answers are cached in Redis for a day and at the edge for an hour, with the cache keys versioned, so that a ranking change never serves yesterday's order.
How we know it got better
The harness that produced these numbers is part of the codebase. Every run is registered with the commit it measured, and every change is compared with the previous run query by query: the flips, improved and regressed, are listed, grouped by failure pattern, and read before anything ships. The matcher went from 88.6% to 92.2% in one day of this: a scorer with explicit features (to 91.0%), the gazetteers and the spelling dictionary (to 92.2%), then businesses by name with the residential figures held. The gate stopped three candidate versions on the way that measured better in one place and worse in another.
What it costs
Inside MarketCode, on the map, in a Valuation or an Appraisal, address lookup is free. Through the API and MCP the lookups that return a licensed Ordnance Survey record carry a small price, the same everywhere: resolving an address to its UPRN costs 2 credits (2p), a lookup by UPRN 1 credit (1p), every address at a postcode 2 credits (2p), every address in a building 2 credits (2p). Autocomplete is free for everyone. A credit is 1p, bought from £10, and it never expires; there are no packs and nothing to top up on a date. Each result carries the UPRN and coordinates. The rate limits are 50,000 calls a day on an API key (120 a minute) and 3,000 interactive searches a day without one. Create a key and start with the address endpoint; the current price of every capability, in credits and pounds, is on the pricing page.
For comparison, the published pay-as-you-go prices of the UK providers, from their own pricing pages on 25 October 2026:
- Ideal Postcodes: 4.5p per completed lookup on the £9 pack, falling to 2.8p on the £900 pack. Suggestions are free; the credit is spent when a full address is returned. Credits last 12 months. UPRN and rooftop geocode included.
- Loqate (GBG): 7.3p per retrieved address on a £50 top-up, falling to 4.2p at £1,000, excluding VAT. Find is free, Retrieve is charged. Credit lasts 12 months.
- Ordnance Survey, OS Places API: £0.0282 per request on the Premium plan as listed on the OS Data Hub plans page, excluding VAT, and outside the plan's £1,000 monthly free allowance.
- Google, Places Autocomplete: $2.83 per 1,000 requests after the first 10,000 in a month, with Address Validation at $17 per 1,000, as listed on Google's pricing page. Neither returns a UPRN.
- getAddress.io, long the budget option, stopped operating in February 2026.
For a product that resolves 100,000 addresses a month, that is roughly £2,800 to £4,500 at Ideal Postcodes, £4,200 to £7,300 at Loqate, £2,820 at OS Places, about $1,700 for Google's validation, and £2,000 here (200,000 credits), with the UPRN in every answer. Check the providers' pages before you budget; prices change.
We also could not find a first-result accuracy figure published by any of them. If one exists we will link to it. The head-to-head, the same 5,000 queries through each provider's API and scored by the same rule, is built and waiting on API keys; it will be the next post.
What is next
Map and session context for partial queries. The head-to-head. A re-run on the refreshed register. Telling a chain's branches apart by name and town. And the 99th percentile.
If you are matching customer addresses, cleaning a list, or keying property data on the UPRN, the API is open. The numbers above are the ones you will get. For why the UPRN is the key to join property data on, read UPRN vs postcode; to resolve an address from inside Claude or ChatGPT, connect your assistant.
Keep reading: UPRN vs postcode: what to key your property data on, Connect your AI assistant to MarketCode and value a property and Produce an area report in ten minutes.
Related guides
- Airbnb yield: estimating short-term rental income in the UKA short let can gross almost twice what a tenancy pays and still net less. How to estimate nightly rate, occupancy and the costs people forget, then compare.
- How to assess planning risk on a development sitePlanning risk is a probability, a cost and a delay, and all three belong in your land bid. How to read the local plan, the history and the policy tests first.
- How to find out who owns land or a building in England and WalesCompany, public body and overseas owners are in bulk registers you can query in one call. Individuals are not. Here is what each route can tell you.