You added an interactive map to your app. It looked great in development. Then your first real traffic month hit and you opened the billing dashboard.
The number was not what you expected.
This happens more than people talk about. Maps look like a simple embed until you understand how the pricing actually works — and by then, you're already paying.
Here's what's going on, and how to think about it differently.
How Most Providers Charge for Map Tiles
When a user loads an interactive map, they're not downloading one image. They're downloading dozens of tiles — small square chunks of the map stitched together to fill the viewport. Every pan, every zoom, every flyTo animation loads new tiles at the edges of the viewport.
Google's Map Tiles API charges per tile request (see Google's official pricing). Here's what a single delivery driver session actually costs under that model, compared to Mapsi's per-session pricing:
| Google Maps Tile API | Mapsi | |
|---|---|---|
| Billing model | Per tile request | Per session |
| Map load | ~20 tiles | 1 credit |
| 2 pans during shift | ~10 tiles | 0 credits |
| 2 zoom interactions | ~20 tiles | 0 credits |
| 10 delivery stops (recentre) | ~80 tiles | 0 credits |
| Total per session | ~130 tile events | 2 credits |
| 200 drivers/day | ~26,000 tile events | 400 credits |
| Monthly (30 days) | ~780,000 tile events | 12,000 credits |
| Free cap | 100,000/month | 3,000 credits/day |
| Billed usage | ~680,000 tiles | Within $15 Hobby plan |
| Monthly cost | ~$408 | $15 |
The tile count per session (130) is a conservative estimate — it accounts for tile overlap when recentring to nearby stops. Live-tracking maps that follow a driver's GPS position in real time would load significantly more.
A Real Example: What Google Actually Charges a Delivery App
Let's make this concrete. 200 active drivers a day, each with a map open for a 4-hour shift, making 10 deliveries.
Here's a conservative breakdown of tile requests per session:
- Map load: ~20 tiles
- 2 pans during the shift: ~10 tiles
- 2 zoom interactions: ~20 tiles
- 10 stops — map recentres to next address (~8 new tiles each, accounting for overlap): ~80 tiles
~130 tile requests per driver session. Conservative — we're allowing for overlap between consecutive stops.
Monthly: 130 tiles × 200 drivers × 30 days = 780,000 tile requests
Using Google's published pricing at developers.google.com/maps/billing-and-pricing/pricing:
| Tier | Tiles | Rate | Cost |
|---|---|---|---|
| Free cap | 100,000 | $0 | $0 |
| Up to 1,000,000 | 680,000 | $0.60 / 1,000 | $408 |
| Monthly tile total | 780,000 | $408 |
That's $408/month just for map tiles — before any geocoding for address lookup, routing for turn-by-turn directions, or other API calls. Add those and a typical delivery operation at this scale lands at $600–$700/month.
For a bootstrapped product, that's a significant line item before you've found product-market fit.
The Alternative: Charge Per Session, Serve Tiles Free
There's a different pricing philosophy: charge once when the map initializes, then serve all subsequent tile fetches — pans, zooms, animations — at no additional cost via CDN.
This is how Mapsi works.
1 credit when the map loads. 1 credit when the map style loads. After that, every tile request — every pan, zoom, flyTo, route animation — is served through Bunny CDN and doesn't touch your credit balance at all.
You're looking at 2 credits per user session, total, regardless of how long they spend interacting with the map. For the delivery app above, that's 400 credits a day instead of 26,000 tile events.
What This Means in Practice
Back to the delivery app. 200 drivers, 30 days.
Google Maps (Map Tiles API): ~$408/month on map tiles alone, based on Google's published pricing. Add geocoding and routing and the real-world bill for this fleet is $600–$700/month.
Mapsi (per-session model): 200 drivers × 2 credits × 30 days = 12,000 credits/month.
Mapsi's Hobby plan is $15/month for 50,000 credits/day. Your entire driver fleet for the month fits inside a single day's quota — with room to spare for geocoding, routing, and everything else your app does. The monthly bill: $15.
At $600–$700/month vs $15/month, the gap isn't subtle. And it compounds with every driver you add.
The Free Tier Math
Mapsi's free tier is 3,000 credits per day.
Google's Map Tiles API includes 100,000 free tile requests per month. For 200 drivers at 130 tiles/session, you consume ~780,000 tiles/month — exhausting the free cap after roughly the first week of the month.
Under Mapsi's per-session model, 3,000 credits/day means up to 1,500 real user sessions per day (2 credits each — map load + style load). That's a meaningful free tier. Enough to build, test, and get to early users without touching a credit card.
When Per-Tile Pricing Makes Sense
To be fair: if your users load a map and barely interact with it — a static location pin on a contact page, for example — per-tile billing can be cheap. You load maybe 15 tiles once and the session ends.
But most apps aren't built that way. If your map is functional — routing, tracking, search, dispatch — users interact with it. That's where tile costs compound silently, and that's where the pricing model matters.
Predictable Billing Is Underrated
When your map cost is "2 credits per session," you can calculate your infrastructure costs from a spreadsheet before you launch. You can model what 10,000 daily active users looks like without guessing at interaction rates or tile overlap.
That predictability changes how you build. You stop making product decisions — like whether to add smooth flyTo animations or keep the map open between stops — based on whether they'll trigger extra tile charges. You just build what's right for the user.
Getting Started
Mapsi's free tier covers 3,000 credits per day across geocoding, routing, and map sessions — with all tile fetches served free via CDN after the initial load. The Hobby plan is $15/month for 50,000 credits/day, with no per-tile metering at any tier.
If you're evaluating mapping providers for a new project, or re-evaluating an existing one after a surprise bill, mapsi.dev is worth running the numbers on before you commit.