What "real-time" location data actually requires
Real time gets used as a synonym for fast. What it should mean is that the answer reflects the current state of the world, not last quarter's snapshot.
Tag
#api-design
How we treat null and low-confidence results
When a query genuinely cannot be resolved reliably, returning nothing is a better answer than returning a guess dressed up as a fact. Here is the reasoning behind that choice.
Why elevation data gets treated as an afterthought
Elevation data rarely gets its own line on a pricing page, and that absence tells you something real about how seriously it actually gets built.
The case against charging extra for basic authentication methods
A header, a bearer token, and a query parameter all authenticate a request the same way. Charging more for one of them is charging for a preference, not a feature.
Rate limit differences to expect when you switch providers
Rate limits vary in structure, not just in number, across providers. Here is what to check before assuming your current logic still applies.
Why we would rather answer with an error than a wrong guess
A wrong answer that looks confident is worse than an honest failure. An error tells you to check something. A confident wrong guess tells you nothing is wrong.
Migrating a server-side integration without touching the client
A server-side geocoding migration can often be invisible to the client applications that depend on it. Here is how to design it that way.
Why per-country pricing tiers are a bad idea
Charging more to look up an address in one country than another treats geography itself as a pricing lever instead of plain, ordinary data to serve.
The case for treating postal code lookups as first class
A postal code endpoint priced and documented like an afterthought will get built like one too. Treating it seriously starts with treating it equally.
What IPv6 adoption still gets wrong across this industry
An IP lookup API that still treats IPv6 as a minor edge case is quietly treating a growing share of real internet traffic as an afterthought.
Why account-level and network-level quotas should both exist
An account-level quota tracks who you are. A network-level quota tracks where your traffic actually comes from. A serious system needs both.
A cleaner error format across every endpoint
Every endpoint now returns errors in a single, consistent format, making failures easier to detect, log and handle programmatically.
Why webhook-only APIs quietly exclude batch users
A webhook works well for one request at a time. It works badly for a script that just wants to send a thousand lookups and wait for a thousand answers.
Why we publish our error codes instead of hiding them
An undocumented error code turns every failed request into a guessing game. Publishing the list is a small thing that saves real debugging time.
Why batch pricing should match single-request pricing
A thousand lookups sent one at a time and a thousand lookups sent as a batch are the same amount of work. The price should not depend on how they were packaged.
The case for boring, stable API versioning
An exciting new API version is a migration project for everyone downstream of it. Boring, stable versioning is a feature, not a lack of ambition.
Why we didn't build a browser SDK first
A browser SDK for a server-side lookup mostly just moves your API key somewhere a visitor's browser can see it. That is not a convenience worth having.
What network-level rate limiting solves that per-key limits don't
A per-key limit alone assumes one key means one user. Rate limiting by network closes the loophole where that assumption quietly breaks down.
Postal codes deserve more respect than they get
Postal code lookups get treated as a minor utility next to geocoding, but they carry real structure and real regional variation that deserves the same care.
Why documentation quality matters more than feature count
A feature you cannot figure out how to use might as well not exist at all. Documentation is not a support cost, it is part of the actual product.
The quiet cost of vendor lock-in
Lock-in rarely shows up as a single bad decision. It shows up as a hundred small ones that quietly make leaving cost far more than simply staying put.
Rate limits should be documented, not discovered
Finding your rate limit through a 429 error in production is not documentation. It is a support ticket that should never have needed to exist.
Why we count bulk requests per item, not per call
A batch call with a thousand addresses still does a thousand separate lookups. Counting it as one request would just hide where the real usage actually went.
The case against proprietary response formats
A proprietary field name or a custom object model saves a provider nothing and costs a customer a rewrite later. Plain, predictable JSON is not a missing feature.
What per-product billing gets wrong about how APIs are used
Real applications mix geocoding, IP lookups, and time zone calls in a single request path. Billing them as separate products ignores how they are used together.
Open time zone data should not be a premium feature
Time zone lookups run on a public, actively maintained data source. Charging a separate premium for that lookup does not reflect a real added cost.
Why compatibility hosts matter more than a new SDK
An SDK asks you to trust one company's client library for the life of your project. A compatibility host asks you to change one line of configuration.
Why we priced this per request, not per seat
A per-request price matches what an API actually costs to run. Seat pricing measures headcount, not usage, and geocoding traffic rarely follows either.