Mapbox in Flutter: how the integration works and who can build it
Mapbox Flutter integration starts with the official mapbox_maps_flutter SDK, but a map app that lasts needs more: pins that stay fast at country scale, locations that stay private and a map bill you can predict. Here is how we built all three in FishPRO, our fishing app live since 2023, how the map packages compare, and how to pick the team that builds yours.
Clusters
Nearest places
Area statisticsThis Mapbox Flutter guide shows, in plain words, how a map app is put together, where such projects go wrong and what they cost, so you can brief a team or check one. It is for teams that say: "Our app is the map. Users will add thousands of pins, some of them private, and we have no idea what Mapbox will cost once we grow."
Short answer: Mapbox is a company that sells maps for apps. Flutter is Google's toolkit for building one app for iOS and Android from one codebase. Mapbox Flutter integration in 2026 means the official mapbox_maps_flutter SDK, published by Mapbox itself. An SDK (software development kit) is a ready package of code from the vendor. It gives your app custom and satellite maps, clustering, camera animations, user location and offline maps, and Mapbox bills it per monthly active user. The SDK is the easy part. A map app that lasts also needs pins that stay fast, private locations, a backend that prepares the map data and a panel that feeds it. We show all of it on FishPRO, the fishing app we build on Mapbox.
Why this matters for your budget: in a map app the risk is not the map widget. It sits in three decisions made early: where the pins are grouped, who sees exact locations, and how many users open the map each month. Get them right at the start and growth is cheap. Get them wrong and you pay twice: once for the first version, and again to rebuild the data behind the map when the users arrive.
What you get with Mapbox in Flutter: 6 building blocks in one SDK
In short: with Mapbox in Flutter you get one map widget that shows Mapbox maps on Android, iOS and the web, plus ready tools for styles, pins, grouping, camera, location and offline use. As of November 2026 the latest version of mapbox_maps_flutter on pub.dev is 3.34.1, released at the end of October 2026. It needs Flutter 3.38.1 or newer, iOS 14 or newer and Android minSdk 21 (Android 5.0).
Under the widget sit Mapbox's native map engines for iOS and Android, so the phone draws the map with its own graphics code, and Flutter talks to it through a plugin. Mapbox maps are vector maps: the phone receives roads, water and labels as shapes and draws them itself, a bit like a font that stays sharp at any size, instead of downloading finished pictures. In practice you get six building blocks:
- Styles. A style is the map's look: colours, fonts and which layers show. You get ready Standard, Satellite and Streets styles, and you can design your own in Mapbox Studio, Mapbox's online map editor.
- Pins two ways. Annotations are single pins the app adds one by one, fine for a handful. Style layers draw many points at once from one data source, for example GeoJSON, a standard text format for map points and shapes, and stay fast.
- Clustering. Clustering groups nearby pins into one circle with a number on it. A GeoJSON source can do it on the phone, with settings for how close pins must be (clusterRadius) and the zoom level where groups split (clusterMaxZoom).
- Camera control. The camera is the part of the map the user sees. flyTo and easeTo move it with an animation, for example to a place the user picked.
- User location. A location puck, the dot that shows where the user is, with settings through mapboxMap.location. Asking for the location permission is your job, not the SDK's.
- Offline maps. On iOS and Android the app can download style packs and map regions ahead of time, so the map works without signal. Offline is not supported on the web.
The source for all of the above is the mapbox_maps_flutter page on pub.dev and the Mapbox Maps SDK for Flutter guides, both checked in November 2026.
What this means for you: the SDK already covers the map itself. Your budget goes into what makes your product different: the data on the map, the rules around it and the panel behind it.
Mapbox, Google Maps, flutter_map or MapLibre: which map package fits your app?
In short: choose mapbox_maps_flutter when the map is the product and needs its own look, satellite imagery or offline maps. Choose google_maps_flutter when a standard Google map with markers is enough. Choose flutter_map or MapLibre when you want no vendor lock-in, that is no dependence on one map company, and you are ready to pick and pay a tile provider yourself. A tile provider is the server that sends the map in small square pieces, called tiles.
Two notes on the free options. flutter_map is free, but its docs say plainly that the public OpenStreetMap tile server is not free for everyone and has no uptime guarantee, so a commercial app needs a paid or self-hosted tile source. OpenStreetMap is the free world map made by a community of volunteers. And the newer maplibre package (0.3.7) is still before version 1.0, so for production we would start with maplibre_gl, which began as a fork, a copy that went its own way, of the old flutter-mapbox-gl plugin.
What this means for you: the package decides your monthly bill and how hard it is to switch later. If you are not sure, settle it in the planning stage, before a single screen is built. That is one of the first things we do in a map project.
Google Maps markers in Flutter: fine for a few hundred pins
In google_maps_flutter, markers are a Set of Marker objects passed to the GoogleMap widget. Custom pins use a BitmapDescriptor, the plugin's name for a marker image made from an asset or from bytes, and Advanced Markers need a map ID, an ID you create in Google Cloud for a styled map. Clustering is built in now: markers that share a ClusterManagerId are grouped into clusters, and a tap on a cluster gives you its markers. This covers a few hundred pins well. For tens of thousands of points, the server-side approach further down applies to Google Maps as much as to Mapbox.
Mapbox Flutter integration in 6 steps, with the one decision in each
In short: a production Mapbox Flutter integration takes six steps: keep the access token out of the code, choose the style, pick how to draw pins, set up clustering, control the camera, and handle location permissions on both platforms. Each step has one decision that is cheap to make early and expensive to change later.
Two terms first. An access token is the key that tells Mapbox which account the map belongs to and who pays for it. A permission is the system pop-up where the user allows the app to read their location, or refuses. The steps:
- Step 1Access token out of the repo. Mapbox's install guide passes the public token when the app is built, with the --dart-define flag, and reads it with String.fromEnvironment, so the key is never written into the code. Keep one token per environment, test and live, so you can replace the live one without touching the test app. The token still ships inside the app, so give it only the scopes, the rights of the key, that the map needs.
- Step 2Style. Start from Standard or Standard Satellite, then design your own in Mapbox Studio. The app loads the style from a web address, so changes to colours and labels reach users without a new store release.
- Step 3Pins. Annotations are fine for a few pins the user taps. For many points, Mapbox's own docs point to style layers on a GeoJSON or vector source: faster, and styled with expressions, small rules such as "the bigger the number, the bigger the circle".
- Step 4Clustering. Turn on cluster in the GeoJSON source, then add a circle layer for the clusters, a symbol layer for the counts and one layer for single points. A tap on a cluster zooms in until it splits.
- Step 5Camera. Use flyTo for long jumps and easeTo for short ones. Only one camera animation runs at a time, and a new one cancels the old, so queue user actions instead of firing them all at once.
- Step 6Location permissions. On iOS, add NSLocationWhenInUseUsageDescription to Info.plist, the app's settings file, with a sentence saying why you need the location. On Android, declare ACCESS_COARSE_LOCATION, and ACCESS_FINE_LOCATION only if you need precision. Ask with a package such as permission_handler, at the moment the user needs the map, not at the first launch.
The user can always say no or grant only an approximate location. Android's docs say the app should still work with approximate access, and iOS users can turn off precise location for your app too. Plan the map for that case: start from the last known region or a search box, not from a blank screen. Ask for background location only if a feature really needs it. On Android 10 and higher it is a separate permission (Android location permissions), and both stores check how you use it.
Why this matters: steps 1 and 3 decide security and speed for the life of the app. A key with more rights than it needs can be misused by anyone who copies it out of the app, and pins drawn the slow way have to be rebuilt once the data grows. Both are a day of work at the start and weeks of work later.
Thousands of pins without lag: how FishPRO clusters a whole country
In short: to show thousands of pins without lag, do not send every point to the phone. Clustering on the phone works well up to a few thousand points. Beyond that, the server should prepare the groups ahead of time, and the app should load only what the current view and zoom level need.
Think of an election night map. It shows one number per region, not every single vote, and you zoom into a region to see the details. Server-side clustering works the same way: the backend counts the pins per area ahead of time, and the phone only draws the totals for the part of the map you see. That visible part is called the viewport, and the zoom level is how close you are to the ground.
The FishPRO case, simply. The problem: anglers wanted one app for the catch, the spot and the forecast, and every logged catch becomes a pin, so the map of Poland keeps filling up. What we did: scheduled jobs on the backend build the map clusters with counts ahead of time, and Redis, a very fast in-memory database, keeps the map's location queries quick. The phone draws the result with Mapbox style layers over a satellite style, so the work on the device stays small even as the number of catches grows. The result: clusters with counts across the whole country that split into single pins as you zoom in, in an app that has been in the App Store and Google Play since 2023 and is rated 4.5 stars from 34 App Store reviews.
The rules we follow for markers at scale:
- Pre-aggregate on the server. Clusters per zoom band, built by a scheduled job, not on every request.
- Load by viewport. Ask for the visible area when the camera stops moving, not on every frame while the user pans.
- Update one source. Replace the data of one GeoJSON source instead of removing and adding layers.
- Register icons once. Add marker images to the style at start-up and reuse them by name.
- Test on a cheap Android phone. A flagship hides problems that a budget phone shows in seconds.
What this means for you: the map stays smooth on cheap phones as the data grows, and you do not pay for a rebuild of the data layer a year after launch.
Private locations: how to show a spot on the map without giving it away
In short: decide who sees the exact spot before you build the map, and enforce it on the server. In FishPRO every catch has three visibility levels: public, friends or private. Public catches show blurred to everyone else, Premium users see the exact spot, and friends see what was caught and where.
For an angler, a good spot is worth protecting, and the same is true of a runner's home street or a collector's find. Blurring means moving the pin a little, so it shows the area but not the exact place. The rules that keep such data private:
- Blur on the server, not in the app. If exact coordinates reach the phone, anyone with a proxy, a tool that shows the data an app receives, can read them. Send each user only the precision they are allowed to see.
- Blur the same way every time. A new random offset on every request lets someone average the answers back to the real point. Use a fixed offset per pin, or snap the pin to a grid.
- Make the safe choice the default. Let the user pick the level for each pin when they save it, as FishPRO does with public, friends or private.
- Treat photo metadata as location data. A phone saves hidden data in every photo, including the GPS position and the time. FishPRO takes both from the first photo of a catch, which saves typing. The same data in a public photo file would reveal the spot, so it must never be published as is.
FishPRO applies the same rule to money: a Premium discount code is never sent to a free account, so there is nothing to dig out of the app.
Why it matters: a leaked location is a trust problem, and in some apps a safety one. Fixing it after launch means changing the backend, the app and the data already stored, so it costs far less to design it in from day one.
A map that earns money: partner tiers, nearest places and area statistics
In short: a Mapbox map can earn money, not only show places. In FishPRO the map carries partner tiers for fisheries and tackle shops, a nearest-places search that flies the camera to each result, and statistics for the area on screen. Each is a normal Mapbox feature driven by data from the backend.
In Mapbox terms, "from zoom 8" is the minzoom of a layer, the zoom level where the layer starts to show, and "on top" is layer order or a symbol sort key. So the rule lives in the style and the data, not in the app's code.
- "Where to fish?" shows the 12 nearest fisheries, partners first. Each place is a card at the bottom of the screen, and swiping the cards flies the map to each one.
- Statistics for the visible area. Top baits, catches by hour and catches against air pressure, for the part of the map on screen.
- A web panel behind the map. Owners edit their profile, opening hours, stands, prices and reservations in a Next.js panel with separate roles. The FishPRO team uses the same panel for the feed, banners, push campaigns and challenges, so much of the app changes without a new release.
The same approach in our other map apps
A field sales app we built checks reps in at stores with GPS, gives a reliable proof of each visit and lets reps pick the nearest store from a list or a map. The Pieprzyk loyalty app for petrol stations shows the stations on a map, with a location-based feed of prizes and promotions. And an EV charging app shows chargers on a map and a list, navigates to the chosen one and lets the driver start charging when close to it.
What this means for you: the map can be part of how the app makes money, not only a cost. Tiers, discounts and sponsored places are rules in the data, so you can test them without rebuilding the app.
What Mapbox costs per month, and 5 ways to keep the bill and the lag down
In short: Mapbox bills a Flutter app per monthly active user (MAU), one person who opens a map in your app in a given month, not per map load. As of November 2026 the first 25,000 MAU a month are free, then $4.00 per 1,000 MAU up to 125,000 and $3.20 per 1,000 up to 250,000. One MAU covers that user's vector and raster tile requests.
A worked example: 60,000 users who open the map in a month means 35,000 billable MAU, about $140 for that month. Two details from Mapbox's Flutter pricing guide matter for planning. A user counts as soon as they view a map, and a user who deletes and reinstalls the app counts again. A web panel that shows Mapbox maps is billed separately, per map load (50,000 free a month), and search and geocoding, turning an address into a point on the map, have their own prices on the Mapbox pricing page.
A real example of keeping cost down: FishPRO shows depth maps of Polish lakes in the app and the panel. We built them as our own vector depth tiles instead of a paid Mapbox layer, which keeps costs low as the feature grows. A lake gets a depth map only when real depth data exists, so nothing is guessed.

What this means for you: you know the map bill before launch, you can see which choices move it, and growth does not come with a surprise invoice.
Who should build your Mapbox app? 6 questions that separate a live app from a demo
In short: hire a team that has a live app where the map is the main screen and that builds the backend and panel too. You can find a freelance Mapbox developer on a talent marketplace, contact someone from Mapbox's own directory, or hire a product team that delivers the app, backend and panel together. A freelancer fits a team that only lacks map skills. A product team fits a company that needs the whole product.
Six questions show quickly whether a team has shipped a map app before. You do not need to judge the technical details: a team that has done it answers each one with a specific example, and a team that has not answers in general terms. Here are the questions, what a good answer looks like, and our own answers from FishPRO.
Red flags: a demo with a dozen hard-coded pins, blurring of private locations done in the app, no estimate of the monthly map bill, and no plan for the panel that feeds the map.
Why companies bring their map apps to us
We are a small team of senior engineers, and for a map app that is the point: the people you talk to are the people who build your map, your backend and your panel. Here is what that means in practice, with the proof for each point.
- A live map app, not a demo. FishPRO runs on Flutter and Mapbox with a satellite style, in 5 languages, and has been in both stores since 2023.
- Senior engineers on every project, no layers in between. You talk directly to the engineers who write and review the code, not to an account manager who passes messages on. In FishPRO, three developers build the app, the backend, the panel and the game, so the person who answers your question about the map is the person who built it.
- One team for the whole product. App, backend, web panel and store release under one contract. FishPRO's partners, banners and challenges run from the panel we built, so the client changes much of the app without waiting for a release.
- Fast to launch, ready to grow. The first version of FishPRO reached the stores in about two months, as a quick MVP to test the market. Version 2.0 later rebuilt every feature on a new architecture, with a new design.
- Flutter is what we do. Codigee is rated 5.0 on Clutch from 19 reviews, is named a 2026 Top Flutter Developer in Poland by Clutch, and is listed in Google's Flutter Consultants directory.
Why one team for the app, the backend and the panel saves you time and handoffs is the subject of One team, not three vendors.
What a Mapbox app costs with us, and how fast it can launch
In short: at Codigee, a map app is an MVP / App Launch project: from $15k, typically $15-50k, in 8-12 weeks, with a fixed price per milestone. A milestone is a defined piece of work with its own price, agreed before it starts, so you know the cost of each step up front. The price covers the Flutter app for iOS and Android, the backend, the admin panel and the release in both stores.
It starts with Prototype to Plan: $5k, 1-2 weeks, 100% credited to the build. For a map app, this is where we settle the package, the clustering approach, the privacy rules and an estimate of the monthly map bill, before any money goes into building. If you already have a team and only need Flutter and map skills in it, Team up is $60/h, with a minimum of 120 h a month.
For scale: the first version of FishPRO reached the stores in about two months in 2023, as a quick MVP to test the market. Version 2.0 later rebuilt every feature on a new architecture, with a new design. A map app does not have to be big to launch, but its data model, the way the data is organised, should be ready to grow.
See every price on our pricing page, the milestones step by step in how we work, from the first call to launch, and what drives the cost of an app in How much does it cost to build an app in 2026?.
Common questions
01Is mapbox_maps_flutter the official Mapbox SDK for Flutter?
Yes. It is published by mapbox.com on pub.dev and wraps the native Mapbox Maps SDKs for iOS and Android, with web support too. As of November 2026 the latest version is 3.34.1. It needs Flutter 3.38.1, iOS 14 and Android minSdk 21 or newer.
02Is Mapbox free for a Flutter app?
Yes, up to 25,000 monthly active users a month (as of November 2026). Above that, Mapbox charges $4.00 per 1,000 MAU up to 125,000. Search, geocoding, navigation and maps in a web panel are billed separately.
03Should I use Mapbox or Google Maps in Flutter?
Use Google Maps when a standard map with markers is enough: its Maps SDK for mobile is listed as unlimited at no charge (as of November 2026). Use Mapbox when the map is the product and you need custom or satellite styles, data-driven layers or offline regions.
04Can a Mapbox Flutter app work offline?
Yes, on iOS and Android. You download style packs and tile regions with the SDK's offline manager and set a disk quota. Offline maps are not supported on the web. Your own data, such as pins, needs its own offline cache.
05Can we move from Mapbox to MapLibre later?
Yes, but plan it. MapLibre uses a similar style spec, yet its Flutter API differs from mapbox_maps_flutter, and you need a new tile source. Keep map code behind your own layer, so a switch touches one module, not every screen.
06How do I hire a Mapbox developer for a Flutter app?
Ask for a live app where the map is the main screen, then ask how they cluster points, protect locations and keep the map bill under control. Marketplaces give you a person, a product team gives you the app, backend and panel together. At Codigee that live app is FishPRO, and you talk directly to the engineers who built it.
Was this article useful?
4.8 / 5 · 5 ratings







