Google Maps is the default mapping API for a reason. The data is comprehensive, the geocoding is accurate, and the JavaScript SDK is well-documented. But the pricing model has bitten every team we have worked with at least once. We build location-heavy applications — fleet routing, service area mapping, geocoded claims data — and we have learned the hard way which API calls are cheap, which are expensive, and which will generate a surprise invoice that ruins your month.
This guide breaks down how the billing actually works, which of the half-dozen Maps products fits each job, and the caching patterns that keep the invoice boring.
How Google Maps API Pricing Actually Works
Google gives you a $200 monthly credit. That covers about 28,000 map loads, 40,000 geocoding requests, or 10,000 directions requests per month. Sounds generous until you realise how fast those numbers add up. Every time a user loads a page with a map, that is a map load. Every time you convert an address to coordinates, that is a geocode. Every time you calculate a route, that is a directions request.
The credit is shared across every Maps product on your billing account, and there is no hard cap unless you configure quota limits yourself. Nothing stops the meter at $200 — it just keeps running, and you find out at the end of the month.
Here is how that plays out. We built an internal tool that geocoded addresses on form submission. In testing, that was maybe 50 requests a day. In production, field reps were entering 200 addresses daily. Our first real month cost $340 in Maps API fees on what was supposed to be an internal tool. That was the moment we got serious about caching.
Which Google Maps API Should You Use?
"Google Maps" is not one API — it is a family of separately billed products. Picking the wrong one for the job is the most common way teams overspend.
Maps JavaScript API
The interactive map — pan, zoom, markers, info windows. Use it only on pages where the user genuinely needs to interact with the map, because every page view is a billable map load.
Geocoding API
Converts addresses to coordinates and back. The workhorse for any application that stores location data. Cache the results — more on that below.
Places API
Autocomplete, place details, place search. The most expensive product in the ecosystem and the easiest to misuse.
Directions and Routes APIs
Point-to-point routing and multi-stop optimisation. The Routes API is the newer replacement, with traffic-aware routing.
Static Maps and Street View Static APIs
Plain image URLs — no JavaScript, no interactivity, and dramatically cheaper than a live map. Underrated enough to deserve their own section.
Static Maps and Street View Static API Pricing
The Static Maps API generates map images as PNGs from a single URL. We use it for embedding maps in emails, PDF reports, and printed documents. It is cheaper than loading the JavaScript SDK and works everywhere — no JavaScript required. Our claims reports include a static map showing the property location with a marker, and the cost is about $2 per thousand images. Next to interactive map loads, that is a rounding error.
# a complete "map" — one URL, one image, no SDK
https://maps.googleapis.com/maps/api/staticmap?center=-28.0167,153.4000&zoom=15&size=600x300&markers=color:red%7C-28.0167,153.4000&key=SERVER_SIDE_KEY
# the Street View Static API works the same way
https://maps.googleapis.com/maps/api/streetview?location=-28.0167,153.4000&size=600x300&key=SERVER_SIDE_KEYThe Street View Static API follows the same model: a plain URL that returns street-level imagery for a location, billed per image request. Check the live rate card in the Cloud console before shipping it at volume — the image APIs are priced per thousand requests and the tiers change. The important pattern is identical for both: these are static images, so generate each one once, store it in your own bucket, and serve it from there forever. There is no reason to pay Google twice for the same picture of the same house.
Geocoding: Cache Everything, Geocode Once
Geocoding the same address twice is burning money. Our pattern is simple — before hitting the Google API, check your database for a cached result. We store the input address, the normalised address Google returns, the latitude, the longitude, and a cached_at timestamp.
create table geocode_cache (
input_address text primary key,
formatted_address text not null,
lat double precision not null,
lng double precision not null,
cached_at timestamptz not null default now()
);
-- check the cache before you spend money
select lat, lng from geocode_cache
where input_address = lower(trim('4 Example St, Southport QLD'));Cache hit rates above 60 percent are common on applications where users enter addresses in the same geographic area. For our Queensland-based field operations tool, the hit rate is over 80 percent because reps visit the same suburbs repeatedly. We invalidate entries after 90 days, which is conservative. Addresses do not move.
The Places API Will Destroy Your Budget
The Places API — autocomplete, place details, place search — is the most expensive part of the Google Maps ecosystem. Autocomplete alone costs $2.83 per thousand requests. That does not sound like much until you realise autocomplete fires on every keystroke. A user typing a 30-character address generates 30 API calls. At scale, that is terrifying.
Our mitigation strategy has three layers: debouncing, a minimum input length, and session tokens.
const sessionToken = new google.maps.places.AutocompleteSessionToken();
let timer;
input.addEventListener('input', (event) => {
clearTimeout(timer);
const query = event.target.value;
if (query.length < 3) return; // no requests under three characters
timer = setTimeout(() => {
service.getPlacePredictions({ input: query, sessionToken }, render);
}, 300); // wait for the user to stop typing
});We wait 300 milliseconds after the user stops typing before sending a request, require a minimum of three characters before triggering autocomplete, and attach a session token to every autocomplete session so Google charges per session instead of per keystroke — the session token alone can cut costs by 90 percent. If Places Autocomplete is still too expensive after all that, switch to a free geocoding service for basic address entry and keep Google purely for the map rendering.
Directions, Routes, and Waypoint Limits
The Directions API calculates routes between points. The Routes API, its newer replacement, adds traffic-aware routing and route optimisation for multiple waypoints. We use these for field rep routing — given 15 jobs for the day, what is the optimal order to minimise drive time?
The critical detail is waypoint limits. The standard Directions API supports up to 25 waypoints, and the Routes API supports up to 25 intermediate waypoints. For our use case, that is enough. If you need more, you are looking at the Route Optimisation API, which has different pricing and is designed for fleet logistics.
The cost-saving pattern here is pre-calculation. We compute routes nightly and store them in Supabase, so reps see their optimised route when they open the app in the morning. Recalculation only happens if jobs are added or removed during the day — never on every page load.
Keep Every Call Server-Side
Every Google Maps API call in our stack goes through a server-side function. The API key is never exposed to the browser. We use Supabase Edge Functions for geocoding and directions, and only load the JavaScript Maps SDK on pages that actually need an interactive map. This protects the key from abuse, lets us enforce the caching layer on every single request, and keeps the client bundle smaller on pages that do not need maps.
Alternatives Worth Considering
Mapbox is a legitimate competitor with better pricing for high-volume use cases and more flexible styling. OpenStreetMap with Leaflet is free and works well for display-only maps where you do not need geocoding or directions. For Australian addresses specifically, the GNAF dataset from Geoscape provides free geocoding data that is surprisingly accurate.
We still use Google Maps for most client projects because the familiarity and data quality are hard to beat. But for internal tools where cost matters more than polish, Mapbox or the free alternatives can save thousands per year.
The Verdict
Treat Google Maps like metered infrastructure, because that is exactly what it is. Pick the cheapest API that does the job — a static image beats a live map for anything non-interactive. Cache every geocode. Debounce and session-token every autocomplete. Route every call through your server. Do that, and the $200 credit stretches surprisingly far. Skip it, and you will learn the same $340 lesson we did.