Skip to content

BlogFor experts

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.

For experts22 min readPublished By Eryk Kruk, CEO
Clusters screenClustersNearest places screenNearest placesArea statistics screenArea statistics
FishPRO, our Flutter app on Mapbox: catch clusters with counts across Poland, the 12 nearest fisheries on a satellite map, and statistics for the area on screen.

This 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.

Flutter map packages compared, from pub.dev and the vendors' pricing pages (as of November 2026)
PackageLatest versionMap data and pricingStyles and satelliteOfflinePick it when
mapbox_maps_flutter3.34.1Mapbox tiles, billed per monthly active user (MAU). 25,000 MAU a month free.Standard, Satellite, Streets and custom Mapbox Studio styles, 3D layersStyle packs and tile regions on iOS and AndroidThe map is the core of the product
flutter_map8.3.2Vendor-free, pure Flutter. You choose a tile provider and follow its terms.Any raster tile provider, satellite if the provider has itBuilt-in caching since 8.2. Region downloads through a plugin under the GPL-3.0 licence, whose copyleft terms you check before you shipA simple map, or tiles you host
google_maps_flutter2.19.0Google Maps Platform. Maps SDK listed as unlimited at no charge. Needs an API key.Normal, satellite, hybrid and terrain map types, map stylingNo region downloads for your usersStandard map with markers and Google places
maplibre_gl0.27.1Open-source MapLibre. No account or key needed. You bring the tiles.Any style in the MapLibre style specOffline regions on iOS and AndroidNo lock-in and full cost control

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.

FishPRO: clusters with counts across Poland, then single pins as you zoom in.
How map content reaches the phone in FishPRO, in five layers. A Next.js web panel where owners edit their places and the team runs challenges and banners. A Strapi backend with PostgreSQL that stores catches, places, partner tiers and who may see each pin. Scheduled jobs that build the clusters with counts for the whole country ahead of time. Redis that keeps the map's location queries fast. The Flutter app with Mapbox and a satellite style that draws the clusters and pins and flies the map to a place.Web panelNext.jsOwners edit places, hours and offers. The team runs challenges and banners.1BackendStrapi, PostgreSQLCatches, places and partner tiers, plus who may see each pin.2Scheduled jobsAhead of timeBuild clusters with counts for the whole country.3RedisLocation queriesKeeps the map's location queries fast.4Flutter + MapboxOn the phoneSatellite style, clusters and pins. Swipe a card, the map flies there.5
How map data flows in FishPRO, from the web panel to the Mapbox map on the phone.

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: move the map under the pin, then choose public, friends or private.

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.

Partner tiers on the FishPRO map, from the bottom up
TierOn the mapIn return
BasicShown from zoom 8Nothing, it is the default
VerifiedDetails checked by FishPROFree
PartnerAlways on the map and higher on the listsA discount for Premium anglers, at least 10% at fisheries
PremiumOn top of the map and first on the lists. Its challenges show on the map for everyoneA Premium partnership

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.

Pieprzyk, a loyalty app we built for a network of petrol stations: stations on a map, points, prizes and a code for the register.

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.

Where map cost and lag come from, and what we do about it
SourceWhat we do
Users who never need the mapDo not open a map on the first screen if most sessions do not use it. A user counts as active once they view a map.
Too many features on screenPre-aggregated clusters, style layers instead of annotations, and data loaded by viewport.
Chatty requests while panningFetch when the camera stops moving, and cache the last responses by area and zoom.
Heavy stylesDrop layers the product does not use. Satellite imagery is heavier than a vector style, so test it on a slow network.
Low-end phonesProfile on a budget Android phone, keep marker images small and dispose of the map when the screen closes.

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.

Satellite map of Lake Talty in the FishPRO app, with depth lines on the water and depth labels of 50.8 m, 11.6 m and 4.5 m.
FishPRO: our own depth layer on Lake Talty, 50.8 m at its deepest, over the satellite map.

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.

Three ways to find Mapbox developers (as of November 2026)
OptionWhat you getCheck before you sign
Talent marketplaces (Toptal, Lemon.io, Flexiple, Cortance)An individual developer, paid by the hourWho builds the backend, the panel, the design and the store release. Many Mapbox profiles are web (Mapbox GL JS), not Flutter
Mapbox Developer NetworkIndependent developers and consultants you email directlyThe directory does not describe vetting, and its skill filters list Android, iOS, JavaScript, React and GIS, with no Flutter tag
Product teams (software houses)App, backend, web panel and store release under one contractA live map app you can install, not a list of technologies

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.

Six questions to ask any Mapbox Flutter team, with our answers
QuestionA good answerOur answer
Can we install a live app of yours where the map is the main screen?A link to a store pageFishPRO: Flutter and Mapbox with a satellite style, in the App Store and Google Play since 2023, rated 4.5 stars from 34 App Store reviews.
Where are the clusters on your biggest map built?A clear answer: on the server or on the phone, and whyOn the server: scheduled jobs build clusters with counts for the whole of Poland, and Redis keeps location queries fast.
Who sees exact locations in your app?Named levels and a rule for eachPublic, friends or private for every catch. Public catches show blurred to others and exact to Premium users.
What do you send to a user who is not allowed to see something?Nothing: the server leaves it outA Premium discount code never reaches a free account, so there is nothing to dig out of the app.
What did you do to keep the map bill down?A concrete decision with its effectOur own vector depth tiles for Polish lakes instead of a paid Mapbox layer, which keeps costs low as the feature grows.
Who builds the backend and the panel behind the map?The same team, under one contractThe same developers build the FishPRO app, backend, web panel with more than 60 screens and the in-app game.

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

Rate this article

Keep reading.

All posts

Let's make something together.

No overengineering. No wasted time. Just straight-up execution.

Or book a call with Eryk (opens the booking calendar)[email protected]
Who are you?
Budget