Use Offline Maps

With preloaded offline maps you can access whole countries or even continents completely offline without using any internet connection or consuming OTA bandwidth.

Offline maps (also known as persistent maps or preloaded maps) offer the same features as the map data that is available online: You can search for places, calculate routes, start guidance (only available for the Navigate Edition), and - of course - you can interact with the MapView in the same way as with online map data.


In addition to the MapView, there are two engines that support offline map data:

  • Use the OfflineSearchEngine as equivalent to the online operable SearchEngine to search for places.
  • Use the OfflineRoutingEngine as equivalent to the online operable RoutingEngine to calculate routes.

Note that the above engines need to be executed on already downloaded or cached map data to make use of offline features. Other engines will not return results when they are executed offline - even if offline data is available.

In addition, the Navigator and the VisualNavigator work fully with offline map data to support offline turn-by-turn guidance. Worth to mention: The Navigator works headless (without a MapView), but it also requires map data to deliver events.

Once a Region has been downloaded with the MapDownloader - or when an area has been cached by panning the map - the MapView is fully operable for this area without an internet connection. However, other engines like the SearchEngine or the RoutingEngine will never make use of the cached or downloaded map data.

Below we describe how to get offline map data integrated into your application with the MapDownloader.


This is a beta release of this feature, so there could be a few bugs and unexpected behaviors. APIs may change for new releases without a deprecation process.

Why use offline maps? There can be situations when an internet connection may lag, drop - or is completely off for a longer time. Especially, while on-the-go, a stable connection may not always be available. A mobile device may also be offline due to the user's decision to save bandwidth. This means: There can be multiple reasons to use offline maps - and last but not least, offline maps will speed up the user's experience with unbeatable response times. However, in most situations - when limited bandwidth and data consumption is not an issue - accessing online map data offers more accurate and up-to-date map data. Also, some features may not be available on offline maps, for example, search results may contain not all data that is available online.

What is the difference between the map cache and offline maps?

You have two ways to access map data offline:

  • Map Cache: By default, all map data is cached onto the device while using the map. This storage is persisted between sessions, but the storage size is limited and old cache data may be replaced with newer map data. Note: You can change the default cache path and the size with the SDKOptions you can pass into the SDKNativeEngine when you initialize the HERE SDK programmatically. Cached map data is stored in the local map cache storage. More about the cache can be found here. Note that you can use a RoutePrefetcher to actively fill data into the cache (see below.)

  • Offline Maps: With offline maps you can download entire regions or even continents to preload their map data for offline use - including places, routing and other data. A dedicated MapDownloader enables you to get and to maintain this data. Offline maps data is persisted between sessions and the data will not be deleted unless the user decides so. Offline maps are stored in the local persistent map storage. This is a second map storage and fully separated from the map cache. Usually, downloading offline maps happens over Wi-Fi as there are gigabytes of data to be loaded. Offline map data is used as a complete alternative to online services and the cached map when there is no connectivity.


Offline maps work for all map schemes that are vector based. Satellite based map schemes are not part of the downloaded map data.

Can I enforce my app to use offline map data to operate radio-silent?

An application must decide which map storage to use as there is no automatic switching logic for features such as routing or search. However, when showing a map view an app cannot enforce offline map usage - unless the device operates without connectivity:

When interacting with a map view, the HERE SDK will automatically make use of online data, the local map cache and the persistent map storage to provide the best possible user experience:

  1. The HERE SDK will first check if map data can be shown from the map cache storage for the current viewport area - even if the device is online.
  2. If no cached data is available for the current viewport, the HERE SDK will look for offline maps data in the persistent map storage - even if the device is online. If no offline maps data is found:
    • If the device is offline: The map will be shown with less details or even no details.
    • If the device is online: New map data will be shown and downloaded into the cache. When the cache is full, a least recently used (LRU)) strategy is applied.


When the HERE SDK uses backend services such as for search and routing, you need to use dedicated offline engines to access cached or pre-downloaded offline map data. Use the OfflineSearchEngine and OfflineRoutingEngine to access map data offline. Their counterparts, the SearchEngine and RoutingEngine, will only provide results when an online connection is available - otherwise you will get an error. Therefore, you need to decide which engine to use.

Get Started

Downloading and using offline maps can be achieved in two simple steps.

1) Download a list of Region objects. Optionally, this list can be localized with local region names. Once you have this list, you can pick the RegionId you want to download and pass it as download request to the MapDownloader.

2) Use the MapDownloader to download a single Region or a list of regions. You can also download several regions in parallel. Show the download progress to the user by setting a DownloadRegionsStatusListener.

3) Use the MapUpdater to update already downloaded regions and the map cache to a newer map version.

Once the download has completed, the map is ready to be used. If a device is offline, it will automatically show the downloaded region when the camera's target is pointed to that region.


If a download failed, the HERE SDK will still be in a fully operable state. Just try to download again, until the progress has reached 100% and the status finally indicated that the operation has completed.

Since map data for regions, countries or whole continents can contain several hundreds of megabytes, a download may take a while - depending on factors such as available bandwidth. A download may also fail, when a connection gets timed out and cannot recover. For best user experience, it is recommended to allow the user to cancel ongoing operations and to watch the progress until a map download succeeds.


To get a quick overview of how all of this works, you can take a look at the offline_maps_app class. It contains all code snippets shown below and it is part of the offline_maps_app example app you can find on GitHub.

Create a MapDownloader Instance

You can create the MapDownloader once per SDKNativeEngine:

SDKNativeEngine? sdkNativeEngine = SDKNativeEngine.sharedInstance;
if (sdkNativeEngine == null) {
  throw ("SDKNativeEngine not initialized.");

// Create MapDownloader in background to not block the UI thread.
MapDownloader.fromSdkEngineAsync(sdkNativeEngine, (mapDownloader) {
  _mapDownloader = mapDownloader;

Usually, the SDKNativeEngine is automatically initialized when you start the app to show a MapView. Therefore, you can access its instance at runtime and obtain the MapDownloader from it.


Consider to use a separate loader method or class with - for example - multiple Futures to wait until all instances are ready. Optionally, show a loading indicator while waiting. As a benefit, you can then use the instance(s) in your class without null checks. Usually, the creation of MapDownloader and MapUpdater (see below) happens within a second.

By default, the downloaded map data will be stored to a default location:

// Note that the default storage path can be adapted when creating a new SDKNativeEngine.
String storagePath = sdkNativeEngine.options.cachePath;
_showDialog("This example allows to download the region Switzerland.", "Storage path: $storagePath");

As stated in the comment, you can change that storage location, if you wish so - but then you need to create a new SDKNativeEngine instance as shown in the Key Concepts section and set the new cache path together with your credentials as part of the SDKOptions. Note that the storage path is unique for your credentials key.

Download a List of Regions

Each downloadable Region is identified by a unique RegionId. In order to know, which regions are available and which RegionID belongs to which Region, you need to download a list of all available offline maps. This contains regions from the entire world.


Each Region can contain multiple children and each child represents a subset of its parent Region - when you download the parent, then the child regions are automatically included. If you are interested only in smaller portions of an area you can traverse the child regions. Usually, the top-level regions represent continents with countries as children. For the sake of simplicity, below we only look for downloadable countries and ignore any children of children and their children (and so on).

The code below downloads the list of downloadable regions and stores the available Region elements in a list for later use:

// Download a list of Region items that will tell us what map regions are available for later download.
    (MapLoaderError? mapLoaderError, List<Region>? list) {
  if (mapLoaderError != null) {
    _showDialog("Error", "Downloadable regions error: $mapLoaderError");

  // If error is null, it is guaranteed that the list will not be null.
  _downloadableRegions = list!;

  for (Region region in _downloadableRegions) {
    print("RegionsCallback: " +;
    List<Region>? childRegions = region.childRegions;
    if (childRegions == null) {

    // Note that this code ignores to list the children of the children (and so on).
    for (Region childRegion in childRegions) {
      var sizeOnDiskInMB = childRegion.sizeOnDiskInBytes / (1024 * 1024);
      String logMessage = "Child region: " +
          ", ID: " +
          ", Size: " +
          sizeOnDiskInMB.toString() +
          " MB";
      print("RegionsCallback: " + logMessage);

  var listLenght = _downloadableRegions.length;
  _showDialog("Contintents found: $listLenght", "Each continent contains various countries. See log for details.");


The response contains either an error or a result: MapLoaderError and List<Region> can never be null at the same time - or non-null at the same time.

Each region can contain child regions. For example, Europe contains Germany, France and Switzerland - and many more child regions. The sizeOnDiskInBytes parameter tells you how much space the downloaded map will occupy on the device's file system when it's uncompressed after download has completed. It makes sense to show this to the user before starting the download - as the available space on a device may be limited.

Screenshot: Showing an example how downloadable maps could be indicated to users.

Download a Region

Once you know the RegionId, you can use it to start downloading the map data. Each Region instance contains a localized name and other data, such as the size of the downloaded map. When the map data is downloaded, all data is compressed and will be unpacked automatically onto the device's disk once the download is complete.

Below we search the downloaded list of regions to find the Region element for Switzerland. Note that we have requested the region list to be localized in German in the step above:

// Finds a region in the downloaded region list.
// Note that we ignore children of children (and so on): For example, a country may contain downloadable sub regions.
// For this example, we just download the country including possible sub regions.
Region? _findRegion(String localizedRegionName) {
  Region? downloadableRegion;
  for (Region region in _downloadableRegions) {
    if ( == localizedRegionName) {
      downloadableRegion = region;

    List<Region>? childRegions = region.childRegions;
    if (childRegions == null) {

    for (Region childRegion in childRegions) {
      if ( == localizedRegionName) {
        downloadableRegion = childRegion;

  return downloadableRegion;

Once we know the Region, we can use it's RegionId to start the download. We pass the unique ID into a list, so we can download multiple regions with the same request. Here, we download only one region:

// Find region for Switzerland using the German name as identifier.
// Note that we requested the list of regions in German above.
String swizNameInGerman = "Schweiz";
Region? region = _findRegion(swizNameInGerman);

if (region == null) {
  _showDialog("Error", "Error: The Swiz region was not found. Click 'Get Regions' first.");

// For this example we download only one country.
List<RegionId> regionIDs = [region.regionId];

MapDownloaderTask mapDownloaderTask = _mapDownloader.downloadRegions(
    DownloadRegionsStatusListener((MapLoaderError? mapLoaderError, List<RegionId>? list) {
      // Handle events from onDownloadRegionsComplete().
      if (mapLoaderError != null) {
        _showDialog("Error", "Download regions completion error: $mapLoaderError");

      // If error is null, it is guaranteed that the list will not be null.
      // For this example we downloaded only one hardcoded region.
      String message = "Download Regions Status: Completed 100% for Switzerland! ID: " + list!;
    }, (RegionId regionId, int percentage) {
      // Handle events from onProgress().
      String message =
          "Download of Switzerland. ID: " + + ". Progress: " + percentage.toString() + "%.";
    }, (MapLoaderError? mapLoaderError) {
      // Handle events from onPause().
      if (mapLoaderError == null) {
        _showDialog("Info", "The download was paused by the user calling mapDownloaderTask.pause().");
      } else {
            "Download regions onPause error. The task tried to often to retry the download: $mapLoaderError");
    }, () {
      // Hnadle events from onResume().
      _showDialog("Info", "A previously paused download has been resumed.");


The DownloadRegionsStatusListener provides four events. The second one tells us the progress while the download is ongoing, while the first one notifies once the download has completed. Note that the download can also complete with a MapLoaderError, so it's worth to check if something went wrong.


The response for lambda_onDownloadRegionsComplete() contains either an error or a result: MapLoaderError and List<RegionId> can never be null at the same time - or non-null at the same time.

The pause event notfies when a download was paused by the user or the task itself. Internally, the HERE SDK will retry to download a region when it was interrupted, ie. due to a bad network connection. If this happens too often, the MapLoaderError for lambda_onPause() is populated and the download pauses. A paused MapDownloaderTask can only be resumed by the user, which will be also indicated by the related event. Especially for larger regions it may be convenient to pause a download until the connection gets better, for example. When resumed, the download will continue at the progress where it stopped and no already downloaded map data will be lost. Note that calling downloadRegions() for a paused region will have the same effect as calling resume() on the original task and the progress will continue where it left off.

After kicking off the download, we get an immediate return value to be able to cancel the ongoing asynchronous download operation. Above, we store the MapDownloaderTask into a list, as a user might trigger the above code multiple times.

To cancel all ongoing downloads, you can use the following code snippet:

for (MapDownloaderTask mapDownloaderTask in _mapDownloaderTasks) {
int taskLength = _mapDownloaderTasks.length;
_showDialog("Note", "Cancelled $taskLength download tasks in list.");

Note that a MapDownloaderTask that was cancelled cannot be resumed again, but you can start a fresh download request again.

A usage example is available on GitHub as part of the offline_maps_app example app.

Update Map Data and Map Version

With the MapUpdater class you can check if newer map versions are available and - if available - update the already installed regions. Each HERE SDK version comes hardcoded with a specific map version. This defines the map data in the cache and the downloaded regions (if any).

Note that certain HERE SDK features may require a specific map version - as indicated in the related API Reference documentation or in this guide.

When an app update is installed that integrates a new HERE SDK version, it will most likely also feature a new map version. However, the map data will not be automatically updated, unless the MapUpdater is used to perform this task. Of course, map updates can also be installed for older HERE SDK versions.

  • Check the currently used map version by calling mapUpdater.getCurrentMapVersion().
  • Check if an update is available by calling mapUpdater.checkMapUpdate().

By calling mapUpdater.performMapUpdate() you can download and install the latest map data. An example for this is shown in the offline_maps_app example app on GitHub.

If no offline maps have been installed, calling mapUpdater.performMapUpdate() will only clear the cache and the cache will be subsequently filled with new data for the latest available map version.

The cache will always use the same map version as offline maps. If offline maps are updated, the cache will be also updated. The cache version will never be older than the offline maps version.


Once mapUpdater.performMapUpdate() has completed, it is required to call getDownloadableRegions() to update the internal catalog data that is needed to download, update or delete existing Region data.

It is not possible to enforce a map update by uninstalling all downloaded regions via deleteRegions() and then downloading the desired regions again. In that case, the same map version would be downloaded. However, if performMapUpdate() is executed beforehand then a map update may be indicated and can be installed.


During an ongoing map update and related operations, not all MapDownloader and MapUpdater features may be accessible. While many operations can be performed in parallel, in some cases, a failure may be indicated by an error message. If this happens, wait until the current operation succeeds before trying again.

When you call deleteRegions() and you get a retryable error, then there was probably an internet connectivity issue: In this case, DownloadRegionsStatusListener fires an onPause() event - and the affected download is in a paused state. If any download is in a paused state, it is not possible to delete a region, because the storage might be in an inconsistent state: To solve this issue, unpause the download or cancel it - then try again.

Get Current Map Version

Sometimes, it may be useful to know the map version used for the map cache and the installed Region data. You can use the following code snippet to log the currently used map version:

SDKNativeEngine? sdkNativeEngine = SDKNativeEngine.sharedInstance;

if (sdkNativeEngine != null) {
  // Create MapUpdater in background to not block the UI thread.
  MapUpdater.fromSdkEngineAsync(sdkNativeEngine, (mapUpdaterConstructionCallback) {
    try {
      MapVersionHandle mapVersionHandle = mapUpdaterConstructionCallback.getCurrentMapVersion();
      String versionInfo = mapVersionHandle.stringRepresentation(",");
      print("Info: Current Map Version: " + versionInfo);
    } on MapLoaderExceptionException catch(e) {
      // Handle exception.  
      print("Get current map version failed: " +;
else {
  print("Error: SDKNativeEngine not initialized.");

This information is mostly useful for debugging purposes. Note that the map version is also logged by the HERE SDK when the map view is shown for the first time.

It has the format [cache-version].[offline-maps-version],[japan-cache-version].[japan-offline-maps-version]. An example result my look like "47.47,47.47".

Repair Broken Maps

It is not recommended to keep downloading or updating map data while an app is running in background.

However, it may happen that an app gets closed before a map update operation can be completed - for example, due to a crash. So, in worst case an intermediate state may occur on the disk of the device.

The HERE SDK provides a convenient way to check for such issues with the getInitialPersistentMapStatus() method. It also allows to repair a broken map - if possible.

_checkInstallationStatus() {
  // Note that this value will not change during the lifetime of an app.
  PersistentMapStatus persistentMapStatus = _mapDownloader.getInitialPersistentMapStatus();
  if (persistentMapStatus != PersistentMapStatus.ok) {
    // Something went wrong after the app was closed the last time. It seems the offline map data is
    // corrupted. This can eventually happen, when an ongoing map download was interrupted due to a crash.
    print("PersistentMapStatus: The persistent map data seems to be corrupted. Trying to repair.");

    // Let's try to repair.
    _mapDownloader.repairPersistentMap((PersistentMapRepairError? persistentMapRepairError) {
      if (persistentMapRepairError == null) {
        print("RepairPersistentMap: Repair operation completed successfully!");

      print("RepairPersistentMap: Repair operation failed: " + persistentMapRepairError.toString());

Either way, it is recommended to inform the user that there might be an issue with the downloaded map data. This should be done before performing a repair operation.

In worst case, if the repair operation fails, the map data needs to be removed and downloaded again. You can try to call deleteRegions() programmatically and clear the map cache via SDKCache by calling clearCache​().

Alternatively, you can manually delete the data: The path for downloaded regions and the cache can be retrieved from the SDKOptions via the persistentMapStoragePath and cachePath properties.

Prefetch Map Data

You can use a RoutePrefetcher to load map data into the cache in advance - for example, to improve a turn-by-turn navigation experience.

Look here for more details.

Questions And Answers

  • How does offline search work? By default, the OfflineSearchEngine searches in the persistent offline map data, but in case there is no Region loaded, it will try to use the map cache. Find out more about this here.

  • How does offline routing work? Offline routing is intended to be used with offline maps and not solely with cached map data. If no offline map data is available, the OfflineRoutingEngine tries to find the missing data in the map cache. If map data is missing for any part of a route, then the route calculation will fail. Find out more about this here.

  • How is the map cache different from offline maps? Caching happens automatically, when the map view is panned. With the RoutePrefetcher you can request data to be fetched into the map cache. The data in the map cache is not meant to be stored permanently and it can be replaced with newer data when there's a need for this - for example, when the cache is full. More about the cache can be found here. Offline maps, on the other hand, are persisted and they are stored at a different path on the device. With dedicated APIs like the MapDownloader, specific areas in the world can be downloaded permanently - and also updated or deleted upon a user's request.

  • Is it possible to pre-install offline maps on a device? Upon request, it is possible to manually create such packages. However, there is no API available for this and you need to contact us to clarify the details.

results matching ""

    No results matching ""