Between the main OpenStreetMap site, which everyone shares, and a full GIS, which most people will never install, sits uMap: a free tool for making your own map on top of OpenStreetMap data. Community groups map their walking routes with it, journalists drop their reporting locations into it, event organizers publish their venue maps through it. It runs in the browser, it signs you in with your OpenStreetMap account, and its maps can be embedded in a website or kept private. This guide covers the whole surface: the hosted instances, layers, drawing, data import, pop-up templates, permissions, sharing, and the one habit that separates a durable uMap from a fragile one, keeping your own backup.
Home / GIS and Open Map Data for Beginners
OpenStreetMap uMap: Build a Custom Map With Layers, Imports, and a Backup

Photo: Porapak Apichodilok / Pexels
Build It to Last: The uMap Checklist
Check off each step as you finish it. Your progress stays on this page.
0 of 7 complete
0% done
What uMap Is, and Where It Runs
uMap is open-source software that organizations host as public instances. The best known is the French OpenStreetMap community's instance at umap.openstreetmap.fr, alongside instances run by other national communities and organizations. Your maps live on the instance you create them on, under your account, so choose the instance the way you would choose any home for data you care about: a well-run community instance with a track record. You sign in with your OpenStreetMap account, the same login the main map uses, which means no new password and a identity your collaborators may already have. Creating a map takes a name and a blank canvas; everything after that is layers.
Layers: The Unit of Thought
A uMap is a stack of layers, and thinking in layers is the whole craft. One layer for the venues, one for the routes, one for the background reference points you drew once and rarely touch. Each layer has its own settings: its color and icon style, whether its features cluster when zoomed out, whether it shows in the layer browser, whether visitors can edit it. Layers can be toggled by your readers, so a well-layered map lets each audience switch on the slice it needs. The discipline mirrors the one in desktop GIS, at a friendlier scale: data that changes together lives together, data with different owners or different update rhythms gets different layers, and no layer becomes the junk drawer where everything unclassified lands. A map with three honest layers beats a map with one crowded layer every time a reader opens it, and it beats it again the day something needs updating.
Drawing: Markers, Lines, and Polygons
The drawing tools cover the three shapes all maps are made of. Markers for points: a venue, a trailhead, a photo location, each with a name, a description, a color, and an icon chosen from the built-in sets. Lines for routes and boundaries, drawn by clicking vertices, with the same styling controls. Polygons for areas: the festival ground, the study site, the neighborhood. Every feature carries its own properties, and the properties are where a sketch becomes information: the name shows in the pop-up title, the description carries the substance, and links and images can be embedded in the description so a marker becomes a small page about its place. Draw with the snapping and editing aids on, zoom in further than feels necessary while placing points, and remember that your readers will meet this map on phones, where a marker placed carelessly at desktop zoom can sit a street away from its subject.

Importing Data: GeoJSON, GPX, KML, OSM, and CSV
Drawing is for dozens of features. For hundreds, import. uMap accepts GeoJSON (the native format, and the one that preserves the most), GPX from GPS devices and route apps, KML from Google Earth and My Maps, OSM format data, and CSV files with coordinate columns. The import dialog lets you choose which layer receives the data and whether to add to it or replace it, a choice worth pausing on: replace is how a refreshed dataset updates a layer cleanly, add is how duplicates are born. Imported features keep their properties where the format carries them, so a GeoJSON exported from QGIS or from OpenStreetMap tooling arrives with its names and attributes ready to style and pop up. The realistic workflow for any serious map is mixed: import the bulk from a file, draw the exceptions by hand, and let the layer structure keep the two apart so next season's re-import does not trample this season's hand edits.
Pop-Ups and Templates: What a Click Says
Clicking a feature opens its pop-up, and uMap lets you shape that pop-up rather than accepting the default dump of properties. A pop-up template arranges the feature's fields into a readable card: title, image, description, and selected properties in the order a reader wants them. The difference between a raw property table and a templated card is the difference between a database and a publication, and it costs minutes. Set the template at the layer level so every feature in the layer speaks in the same format, use the feature's own fields as the variables, and test the result on the ugliest feature in the layer, the one with the missing image and the long name, because that is the one your template actually has to survive.
Permissions, Sharing, and Embedding
Every uMap has an owner and a set of choices about everyone else. A map can be public and listed, public by link, or private to its editors; editing can be restricted to the owner, opened to named collaborators through their OSM accounts, or, for throwaway collaborative maps, opened more widely with the risks that implies. For anything you would mind losing, keep editing tight: the map is a publication, and its edit rights are its keys. Sharing is a link; embedding is an iframe snippet the Share panel generates, sized and centered for your page, which is how uMaps end up inside club websites, event pages, and news articles. The embedded map stays live: update the uMap and every page embedding it updates too, which is either the feature or the hazard, depending on whether you remembered it was embedded in fourteen places.
The Backup Habit: Export or Lose It
Here is the lesson the training pages assume and experience teaches. A uMap lives on someone else's server, under an account, inside a service that is generous but not immortal. Instances change, accounts get locked, services retire. uMap therefore offers a full backup export, downloading the entire map, layers, features, settings, as a single .umap file, from which the map can be restored or moved. Export one after every significant editing session and keep it with the rest of the project's files. A uMap you cannot export is a map you can lose, and the export takes ten seconds. This is the same discipline this site preaches for every format: the map is the file, not the service. If you also keep the underlying data as GeoJSON per layer, you hold two independent copies in two shapes, and no single service's bad day can take your work.
What uMap Is Not
Honesty about the edges makes the tool more useful, not less. uMap is not a GIS: there is no spatial analysis, no reprojection workbench, no attribute table to compute in; data preparation belongs in QGIS or similar tools before import, which is why our guide to creating a custom map pairs uMap-style publishing with heavier tools for heavier jobs. It is not a navigation product: readers view and explore, they do not route. And it is not the place for data that must be corrected in OpenStreetMap itself; a wrong street name belongs in the main map's editor, not pinned as a correction in your private layer where only your readers benefit. Used inside its edges, though, uMap is the fastest honest route from "I have places to show people" to a map those people can open, and that is a job worth a dedicated tool.
Remote Data Layers: A Map That Updates Itself
One layer type deserves attention once your first maps work: a layer fed by remote data, a URL from which uMap fetches GeoJSON (with the option to refresh it as readers pan and zoom, using the view's bounding box in the request). Point such a layer at a dataset you maintain elsewhere, a city's open data feed, your organization's live export, a sensor or fleet GeoJSON your systems publish, and the map stops being a snapshot: it shows the data as it stands when each reader opens it. The discipline this demands is the mirror of the import discipline. A remote layer is a dependency, and dependencies fail: if the source moves, slows, or changes its fields, your map inherits the failure in public. Use remote layers for data that genuinely changes (closures, availability, live positions) and static imports for data that merely accumulates, and keep a periodic backup export that captures the remote layer's definition even when its contents live elsewhere. A map that updates itself is a small marvel; a map that updates itself from a source you control is a system.
The First Map to Make: A Small One, Finished
If you are learning uMap, resist the atlas as a first project. Make the map of one thing, your running club's routes, your street's trees, the venues of one small festival, and finish it: three layers at most, every feature named, every pop-up templated, the permissions set, the backup exported. A finished small map teaches every mechanic in this article at a scale where mistakes are visible and cheap, and it leaves you with something genuinely useful to show for the lesson. The second map can be bigger. Most failed uMaps are not failed tools; they are unfinished atlases, begun at continental ambition and abandoned at the layer where the work stopped being fun. The tool rewards finishers: a small map, complete and backed up, is worth more to its readers and its maker than a grand one at forty percent, and it is the rehearsal that makes the grand one, when its turn comes, a weekend instead of a season.
Related Guides
If this page answered part of the question, these GIS guides cover the rest of the same ground:
- Create a Custom Map: My Maps and the Wider Toolbox: The comparison this article deepens, Google My Maps against the alternatives.
- Embed an OpenStreetMap Map: The Iframe, the URL, and the Libraries: The embedding route in full, for uMap and for the base map itself.
- OpenStreetMap Download: Get the Data Behind the Map: Where bulk OSM data comes from when a uMap import is not enough.
- OpenStreetMap Report Errors: Notes, the Fixer's Front Door: When the base map under your uMap is wrong, this is how it gets fixed.
- QGIS Cloud: The Hosted Route from Desktop Project to Web Map: Another hosted publishing route, for full QGIS projects and their services.
Frequently Asked Questions
Is uMap free to use?
Yes. uMap is open-source software, and the community instances, such as the one run by OpenStreetMap France, are free to use with an OpenStreetMap account. Your maps are hosted on the instance you choose, so pick a well-established one.
What is the difference between uMap and Google My Maps?
Both make custom maps in the browser. uMap builds on OpenStreetMap data, signs you in with an OSM account, imports GeoJSON, GPX, KML, OSM, and CSV data, and offers a full backup export of the entire map in its own format. My Maps builds on Google's map and account system. The data ecosystem you work in decides which fits.
Can I import a spreadsheet into uMap?
Yes, if the spreadsheet is saved as CSV with coordinate columns for latitude and longitude. For richer data with names and attributes, GeoJSON preserves the most through import. Choose whether the import adds to a layer or replaces it; replace is the clean way to refresh a dataset.
How do I back up a uMap?
Use the full backup export in the map's settings, which downloads the complete map, layers, features, and settings, as a single .umap file. Export after significant edits and store the file with your project. The map can be restored or moved to another instance from that file.
Can other people edit my uMap?
Only if you let them. Permissions range from owner-only editing to named collaborators signed in with OpenStreetMap accounts. Keep editing restricted for any map you would mind losing, and treat the public link as view-only by default.
Photo credits: Porapak Apichodilok (Pexels); Rukiye Ağaçayak (Pexels). Photos are served from this site; follow the credit to the library page for the original.