Adding a map to an app sounds like a one-afternoon task. Drop in an API key, render a map, ship it. That assumption is how founders end up with a $4,000 surprise on their Google Cloud invoice three months after launch.
The truth is that mapping features have a split cost structure almost no one talks about upfront: there is the cost to build it, and there is the cost to run it. The build cost is a one-time payment to the team. The running cost compounds every time a user loads a map, searches an address, or gets a route. Get the architecture wrong early, and the running cost scales faster than your revenue.
Here is what you actually need to budget, broken down by feature.
How do mapping APIs like Google Maps and Mapbox work?
Every map you see in an app is powered by a mapping API, a commercial service that handles the hard parts: storing global map data, rendering tiles, processing addresses, and calculating routes. You do not build any of that yourself. You pay for access to it.
Google Maps Platform is the most widely used option. It covers maps, geocoding (turning addresses into coordinates), reverse geocoding (turning a GPS pin into a readable address), routing, and place search. Mapbox is the main alternative. It offers more visual customization and slightly different pricing, but the feature set largely overlaps.
The API charges on a per-request basis. Every time your app loads a map view, that is a request. Every address your user types into a search bar that gets converted to a pin is a request. Every time someone asks for directions is a request. None of these feel expensive individually. The problem is that each active user can generate dozens of requests per session without noticing.
According to Google's 2022 pricing, the Maps JavaScript API costs $7 per 1,000 loads. Geocoding costs $5 per 1,000 requests. The Directions API costs $10 per 1,000 requests. Google provides a $200 monthly credit, which covers about 28,500 map loads at no charge. Mapbox offers a free tier of 50,000 map loads per month before billing starts, more generous upfront, but comparable at scale.
What does basic map display cost versus geocoding and routing?
Map display is the cheapest feature. Rendering a static map or an interactive map view consumes one API request per load. At 10,000 monthly active users who each view a map once per session, that is roughly $70/month after Google's free credit, a manageable line item.
Geocoding is where costs start to add up. Search bars that convert text to pins are common in delivery apps, booking platforms, and marketplaces. A user who types three partial addresses before selecting one has generated three geocoding requests. At 10,000 users, a poorly optimized search bar can generate 40,000–60,000 requests per month. That is $200–$300/month just for address search.
Routing is the most expensive individual feature. Calculating a route from point A to point B costs $10 per 1,000 requests. A logistics app where drivers request routes multiple times per shift can generate 100,000+ routing calls per month at modest scale, pushing the Directions API cost alone to over $1,000/month before any other features are counted.
| Feature | API cost per 1,000 requests | 10K users/month (est.) | 100K users/month (est.) |
|---|---|---|---|
| Map display (Google Maps JS) | $7 | $70 | $700 |
| Geocoding / address search | $5 | $200–$300 | $2,000–$3,000 |
| Routing / directions | $10 | $300–$600 | $3,000–$6,000 |
| Place search / autocomplete | $17 | $500–$800 | $5,000–$8,000 |
Place autocomplete, the dropdown of suggestions when a user starts typing an address, is the most expensive line item on the table. At $17 per 1,000 requests and one autocomplete call fired per keystroke, it is the feature that most often causes surprise invoices. A common fix is to debounce the search input so it fires only after the user pauses typing, cutting request volume by 60–80%.
Should I use one mapping provider or combine several?
For most early-stage products, pick one provider and stay there. Managing two billing relationships, two API keys, two SDK versions, and two sets of rate limits adds overhead that is not worth it until you have a clear reason to split.
The case for splitting comes at scale, when specific features have materially different pricing across providers. Mapbox's routing is priced at $1 per 1,000 requests in its navigation product, versus Google's $10. For a logistics app generating 500,000 routing requests per month, that is a $4,500/month difference. That gap justifies the integration complexity. Below 50,000 routing requests per month, it almost never does.
One pattern that works well for cost-conscious products at early scale: use Mapbox for the visual map display (generous free tier, good customization) and fall back to Google's Geocoding API for address search, since Google's address database is more complete outside North America and Western Europe. This requires two API integrations but keeps the monthly cost lower than running Google Maps end-to-end for international products.
The right answer depends on your geography and your dominant feature. A food delivery app in a single US city is fine on Google Maps alone. A logistics platform serving Southeast Asia will find Mapbox's coverage thinner and may need Here Maps or a regional alternative for accurate routing.
What per-request API pricing should I expect at scale?
The $200 monthly Google credit disappears fast. A product with 5,000 active users who each perform two geocoding lookups and one route per session will burn through the credit entirely and start paying real money within the first month.
A useful planning benchmark: budget $0.03–$0.06 per active user per month for a product that uses maps as a supporting feature (show a location on a listing, display a delivery pin). Budget $0.10–$0.20 per active user per month for a product where maps are a core interaction loop (route planning, driver tracking, location search).
At 50,000 monthly active users, that translates to $1,500–$10,000/month purely in API fees, depending on how heavily users engage with location features. This is the number most founders do not put in their financial model until after launch.
Western agencies typically quote $20,000–$40,000 to design and build a location-heavy feature set (maps, geocoding, routing, and a basic admin view). An experienced global engineering team delivers the same scope for $5,000–$9,000, including architecture decisions that minimize ongoing API spend. The difference is not the quality of the code. It is overhead: US office costs, US salaries, and billing rates set in 2019 that have not moved.
How much does building geofencing or custom overlays add?
Geofencing, triggering an action when a user enters or exits a defined geographic area, sounds simple and prices out surprisingly high. The API calls themselves are not the cost driver. The complexity is in the logic: defining zones, storing them, checking user location against them in real time, and firing the right event reliably.
A basic geofencing implementation for a single use case (notify a user when they arrive near a pickup point, for example) adds $2,000–$3,500 to the build cost. That covers zone management, location polling, and the trigger logic. A more flexible geofencing system (multiple zone types, admin controls for drawing zones, event history logging) runs $6,000–$10,000 to build from scratch.
Custom map overlays fall into two types. Data overlays draw information on top of the map: heat maps, delivery zones, service area polygons. These are primarily a frontend engineering task, typically adding $1,500–$3,000 depending on how dynamic the data is. Real-time overlays (showing moving vehicles, live delivery status, driver positions) require a persistent connection between the app and your servers, which adds infrastructure complexity. Expect $4,000–$8,000 more for a real-time tracking layer on top of a basic map integration.
| Feature add-on | Build cost (global team) | Build cost (Western agency) | Monthly API add-on |
|---|---|---|---|
| Basic map display + geocoding | $2,500–$4,000 | $12,000–$18,000 | $100–$400 |
| Routing and directions | $3,000–$5,000 | $14,000–$22,000 | $200–$800 |
| Place search / autocomplete | $2,000–$3,500 | $10,000–$16,000 | $300–$1,000 |
| Basic geofencing (single use case) | $2,000–$3,500 | $10,000–$15,000 | $50–$150 |
| Flexible geofencing (admin controls) | $6,000–$10,000 | $25,000–$40,000 | $50–$200 |
| Real-time tracking overlay | $4,000–$8,000 | $18,000–$30,000 | $200–$600 |
The ongoing API cost in the last column is separate from and in addition to the base map display cost. A product with routing, place search, and real-time tracking can run $700–$2,400/month in API fees at 10,000 active users, before a single line of application hosting is counted.
The single highest-impact decision you make in a location feature build is how aggressively you cache. Geocoding results for the same address do not change. Storing them means you pay once instead of every time a user searches. Route results for common pairs can be cached for minutes or hours depending on traffic sensitivity. A well-cached location architecture cuts ongoing API spend by 40–70% compared to a naive implementation that fires a live request for every user action.
The team you hire either knows these patterns or they do not. A senior engineer who has built location features before will cache by default. A junior team following documentation examples will not. That difference shows up as a 3–5x gap in your monthly API bill within six months of launch.
If you are budgeting a location feature for the first time: plan for $3,000–$8,000 to build a solid foundation with a global engineering team, $300–$1,200/month in API fees at early scale, and a clear caching strategy documented before the first line of code is written. The API fees are the part that compounds. Get the architecture right once and they stay manageable. Get it wrong and they scale faster than your user base.
Book a free discovery call with Timespade to walk through your location feature scope and get a fixed-price estimate within 24 hours.
