Change the basemap style

Learn how to change the static basemap tiles style.

The ArcGIS Static Basemap Tiles service provides access to raster basemap tiles for the world. The service supports a number of ArcGIS styles such as navigation, streets, outdoor, and light-gray. The tiles are returned as PNG files.

In this tutorial, you use the dropdown menu to toggle between the different static basemap tiles.

Prerequisites

Steps

Get the starter app

Select a type of authentication and follow the steps to create a new app.

Set up authentication

Set developer credentials

Use the API key or OAuth developer credentials so your application can access ArcGIS services.

Add a style selector

1. Create a <div> tag to contain the <select> dropdown menu, which you will populate in a later step.

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
       <div id="map"></div>
   
       <div id="basemaps-wrapper">
         <select id="basemaps"></select>
       </div>
   

2. In the <style> element, add CSS styling to the basemaps-wrapper and basemaps.

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
       <style>
       body {
         margin: 0;
         padding: 0;
       }
   
       html,
       body,
       #map {
         height: 100%;
       }
   
   
       #basemaps-wrapper {
         position: absolute;
         top: 20px;
         right: 20px;
         background: rgba(255, 255, 255, 0);
       }
   
       #basemaps {
         font-size: 16px;
         padding: 4px 8px;
       }
   
   
       </style>
   

Update the map's viewpoint

1. Change the map's center to [-91.2996, 37.1174] and zoom level to 4. This will focus the map on the United States of America.

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
       const map = new maplibregl.Map({
         container: "map",
         style: {
           version: 8,
           sources: {
             "raster-tiles": {
               type: "raster",
   
               tiles: [
                 url(basemapEnum)
               ],
   
               tileSize: 512
             }
           },
           layers: [
             {
               id: "raster-basemap",
               type: "raster",
               source: "raster-tiles",
               minzoom: 0,
               maxzoom: 22
             }
           ]
         },
   
         zoom: 4,
         center: [-91.2996, 37.1174]
   
       });
   

Set the basemap

Use a function to reference the ArcGIS Static Basemap Tiles service and a style enumeration to update the map. This will be used when a selection is made.

1. Create a url function to append the name of the basemap selected from the dropdown menu.

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
       /* Use for API key authentication */
       const accessToken = "YOUR_ACCESS_TOKEN";
   
       // or
   
       /* Use for user authentication */
       // const session = await arcgisRest.ArcGISIdentityManager.beginOAuth2({
       //   clientId: "YOUR_CLIENT_ID", // Your client ID from OAuth credentials
       //   redirectUri: "YOUR_REDIRECT_URI", // The redirect URL registered in your OAuth credentials
       //   portal: "YOUR_PORTAL_URL" // Your portal URL
       // })
   
       // const accessToken = session.token;
   
       const basemapEnum = "arcgis/navigation";
       const baseUrl = "https://static-map-tiles-api.arcgis.com/arcgis/rest/services/static-basemap-tiles-service/v1";
   
       const url = (style) => `${baseUrl}/${style}/static/tile/{z}/{y}/{x}?token=${accessToken}`;
   
       const map = new maplibregl.Map({
         container: "map",
         style: {
           version: 8,
           sources: {
             "raster-tiles": {
               type: "raster",
   
               tiles: [
                 url(basemapEnum)
               ],
   
               tileSize: 512
             }
           },
           layers: [
             {
               id: "raster-basemap",
               type: "raster",
               source: "raster-tiles",
               minzoom: 0,
               maxzoom: 22
             }
           ]
         },
   
         zoom: 4,
         center: [-91.2996, 37.1174]
   
       });
   
       // Add Esri and data attribution
       // Learn more in https://esriurl.com/attribution
       arcgisRest.request(`${baseUrl}/${basemapEnum}/static`, {
         httpMethod: "GET",
         authentication: arcgisRest.ApiKeyManager.fromKey(accessToken)
       }).then((data) => {
         map._controls[0]._innerContainer.innerText += " | Powered by Esri | " + data.copyrightText;
       });
   

   Expand

2. Modify the tiles property of the map to use the url function with basemapEnum as the default basemap style.

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
       const map = new maplibregl.Map({
         container: "map",
         style: {
           version: 8,
           sources: {
             "raster-tiles": {
               type: "raster",
   
               tiles: [
                 url(basemapEnum)
               ],
   
               tileSize: 512
             }
           },
           layers: [
             {
               id: "raster-basemap",
               type: "raster",
               source: "raster-tiles",
               minzoom: 0,
               maxzoom: 22
             }
           ]
         },
   
         zoom: 4,
         center: [-91.2996, 37.1174]
   
       });
   

   Expand

3. Retrieve the select element by storing it in a basemapsSelectElement variable.

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
       const basemapsSelectElement = document.querySelector("#basemaps");
   
   

   Expand

4. Import arcgisRest.request() to make a request to the static basemap tiles service. This dynamically fetches the available basemap styles and populates the select element.

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
       <!-- REST JS -->
       <script src="https://unpkg.com/@esri/arcgis-rest-request@4/dist/bundled/request.umd.js"></script>
   
   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
       arcgisRest.request(`${baseUrl}/self`, {
         httpMethod: "GET",
         authentication: arcgisRest.ApiKeyManager.fromKey(accessToken)
       }).then((response) => {
         response.styles.forEach((style) => {
           const option = document.createElement("option");
           option.value = style.path;
           option.textContent = style.name;
           basemapsSelectElement.appendChild(option);
         });
       });
   

   Expand

5. Run the code to ensure that the <select> element contains different basemap enumerations.

Add an event listener

Use an event listener to register a basemap change in the <select> element and to update the map.

1. Add an event listener to store the selected basemap.

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
       const basemapsSelectElement = document.querySelector("#basemaps");
   
       arcgisRest.request(`${baseUrl}/self`, {
         httpMethod: "GET",
         authentication: arcgisRest.ApiKeyManager.fromKey(accessToken)
       }).then((response) => {
         response.styles.forEach((style) => {
           const option = document.createElement("option");
           option.value = style.path;
           option.textContent = style.name;
           basemapsSelectElement.appendChild(option);
         });
       });
   
       basemapsSelectElement.addEventListener("change", (e) => {
         const style = e.target.value;
         const tilesUrl = url(style);
   
       });
   

   Expand

2. Update the map's raster-tiles with the new basemap style.

   Expand

   Use dark colors for code blocks

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
   100
   101
   102
   103
   104
   105
   106
   107
   108
   109
   110
   111
   112
   113
   114
   115
   116
   117
   118
   119
   120
   121
   122
   123
   124
   125
   126
   127
   128
   129
   130
   131
   132
   133
   134
   135
   136
   137
   138
   139
   140
   141
   142
   143
   144
       const basemapsSelectElement = document.querySelector("#basemaps");
   
       arcgisRest.request(`${baseUrl}/self`, {
         httpMethod: "GET",
         authentication: arcgisRest.ApiKeyManager.fromKey(accessToken)
       }).then((response) => {
         response.styles.forEach((style) => {
           const option = document.createElement("option");
           option.value = style.path;
           option.textContent = style.name;
           basemapsSelectElement.appendChild(option);
         });
       });
   
       basemapsSelectElement.addEventListener("change", (e) => {
         const style = e.target.value;
         const tilesUrl = url(style);
   
         map.getSource("raster-tiles").setTiles([tilesUrl]);
   
       });
   

   Expand

Run the app

Run the app.

You should be able to use the <select> element to switch between basemap styles.

What's next?

Learn how to use additional location services in these tutorials: