License

Before you deploy your ArcGIS Runtime app into production, you're required to license it with one of the four ArcGIS Runtime licensing capabilities levels: Lite, Basic, Standard, or Advanced. ArcGIS Runtime extension licenses can also be applied to bring additional functionality into your app.

Other costs may be incurred when deploying your app, such as transactions used with ArcGIS Location Services. Refer to deployment and our FAQ for more information on the terms and conditions.

Develop and test

You can download and install an ArcGIS Runtime SDK using the downloads page. You then have access to all of the functionality in the API for development and testing purposes. In this mode, the app will adopt the following behavior:

• Any map or scene will be watermarked with the words Licensed For Developer Use Only.
• A message will be written to the console or log that states that the app is Licensed For Developer Use Only.

Licensing your app for deployment will remove the watermark and console output and provide the appropriate capabilities to your app users.

Licensing options

Before you can use your app in production, you are required to license the ArcGIS Runtime app. Esri provides four ArcGIS Runtime license levels: Lite, Basic, Standard, or Advanced. Each additional level opens more capabilities for your app users.

Two options are available to set the license level in your app:

User authentication

A user (obtained through user authentication) refers to an ArcGIS account that is a member of a portal. The ability to license an ArcGIS Runtime app from a user is one feature of user authentication. You need to include code in your ArcGIS Runtime app to enable a user to sign in to a portal and return license details associated with their account.

Use user authentication licensing if your target audience has access to ArcGIS Online or ArcGIS Enterprise and use devices that will be online at least once every 30 days (timeout for a user authentication license for ArcGIS Runtime). One notable benefit of this model is the license for ArcGIS Runtime travels with the user, not the app, so one user can license many ArcGIS Runtime apps.

License string

A license string is a text string that contains license details. A free Runtime Lite license string can be obtained below by signing in with your ArcGIS Location Platform or ArcGIS Online account. A Basic, Standard, or Advanced license string can be purchased as one or more ArcGIS Runtime deployment packs. License strings are usually compiled into your ArcGIS Runtime app. Each installation of your app available to a single user counts as a deployment.

Use a license string if your target audience does not have access to ArcGIS accounts with ArcGIS Online or ArcGIS Enterprise, needs to use an application that will remain offline indefinitely, or needs to guarantee an application will function if offline more than 30 days. Customers are required to track the number of ArcGIS Runtime deployments at the Basic, Standard, and Advanced level. Each installation of your app available to a single user counts as a deployment.

Licensing capabilities

The functionality associated with each license level is described below, including the available licensing options and how to acquire a license. For details on API classes and members that require a paid license or extension, see Licensing details in the API reference.

Extension licenses

ArcGIS Runtime offers extensions that provide access to additional capabilities, analysis tools, or data.

Store geocode results from ArcGIS Online

The Geocoding service includes a for_storage parameter. Storing the results of a geocode or reverse geocode operation using this service (by setting the for_storage parameter to true) requires one of the following methods of authentication:

• API key authentication. Add a long-lived API key access token, that has a location services privilege of Geocode (stored), to your app.
• User authentication. Allow users with an ArcGIS Location Platform or ArcGIS Online account to sign in and access the geocoding service. This uses the credits from the member's account. Additionally, the user performing a paid operation must be assigned a user role that includes the Geocoding privilege. For more information, see pricing information in ArcGIS Location Platform pricing and User types, roles, and privileges in ArcGIS Online documentation.

User authentication

In March of 2019, user types were introducted with ArcGIS Enterprise 10.7 and replaced named user license levels. Members of any user type can be used to license an ArcGIS Runtime app. Members assigned a user type of Viewer will be licensed at the Lite license level, while members assigned a user type of Editor, Mobile Worker, Creator, or GIS Professional will be licensed at the Basic license level.

Starting with ArcGIS Enterprise 10.8 and newer, ArcGIS Runtime license levels can be licensed through user types or through a license string. Administrators must assign a user type with the appropriate ArcGIS Runtime license level to members of the organization based on the level of access they require.

• Members assigned a Viewer or Lite user type will be licensed at the ArcGIS Runtime Lite license level.
• Members assigned an Editor, Mobile Worker, or Basic user type will be licensed at the ArcGIS Runtime Basic license level.
• Members assigned a Creator, GIS Professional Basic, or Standard user type will be licensed at the ArcGIS Runtime Standard license level.
• There are no capabilities requiring an Advanced license level at this time for the ArcGIS Runtime SDK for iOS.

User types explicitly include ArcGIS Runtime licenses and extensions when applicable. ArcGIS Runtime 100.7 and higher is licensed on the basis of these explicit license entitlements when used with such user types.

Starting June 26th, 2024 with ArcGIS Online, ArcGIS Runtime license levels can be assigned by Administrators as follows:

• Viewer or Lite user types will be licensed at the ArcGIS Runtime Lite license level.
• Contributor, Mobile Worker or Basic user types will be licensed at the ArcGIS Runtime Basic license level.
• Creator or Standard user types will be licensed at the ArcGIS Runtime Standard license level.
• There are no capabilities requiring an Advanced license level at this time for the ArcGIS Runtime SDK for iOS.

Use tile packages from ArcGIS Online basemaps

App developers may use ArcGIS Online basemaps for their apps. Esri has designed a use policy that seeks to maximize the use of these basemaps by the ArcGIS Runtime developer community. The rules for using these basemaps are conditioned on how the basemaps are used.

A developer can only export basemaps from services that support the export tiles operation.

A developer may:

• Export basemaps as tile packages for use with an ArcGIS Runtime app, up to the limits imposed by the basemap for a single tile package.
• Use an ArcGIS Runtime app to export basemaps on demand. Authorization must be as a member of a portal or with an app login.
• Embed or bundle basemap tile packages in an ArcGIS Runtime app.
• Use an ArcGIS Runtime app to download pre-created basemap tile packages hosted by ArcGIS Online or ArcGIS Enterprise, but only if the ArcGIS Online organization or ArcGIS Enterprise is licensed for production use.

A developer may not:

• Allow their users to use the exported content outside of ArcGIS technology.
• Allow their users to unbundle the exported content and publish the exported content as a map service.
• Allow their users to unbundle the exported content or redistribute to other users.
• Systematically harvest map tiles using the service (a practice often referred to as "scraping tiles").

License your app

Follow these steps to license your app with a license string or user authentication. If you use API key authentication to access ArcGIS services, the Runtime app itself must still be licensed with a Runtime license string or user authentication. After licensing the app, the watermark and debug messages will no longer display and your app will be ready for distribution and use in production.

License your app with a license string

Using a license string involves adding code to set the license level at compile time so that the license string is built into the application.

1. Read the end user license agreement.
2. Find a location in your code that runs before any ArcGIS Runtime functionality is used.
3. Call the setLicenseKey() method on the AGSArcGISRuntimeEnvironment singleton object to license the app with a license string.

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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
// License the app with the supplied license string.
do {
 let result = try AGSArcGISRuntimeEnvironment.setLicenseKey("runtimelite,1000,rud#########,day-month-year,####################")
 print("License Result : \(result.licenseStatus)")
}
catch let error as NSError {
 print("error: \(error)")
}

Your app is now licensed for deployment.

License your app through user authentication

Use of an ArcGIS account involves adding user authentication code to enable a sign in experience. At runtime, a user must sign in successfully to return their license information which will be used by the app to set the license level. Follow these steps to license your app using the user's account:

1. Read the end user license agreement.
2. Find a location in your code that runs before any ArcGIS Runtime functionality is used.
3. Allow the app user to authenticate with an ArcGIS account using a portal. Upon loading the AGSPortal obtain the AGSLicenseInfo and use this to license the app. As part of the process, save the license information in preparation for your app being used in an offline environment for up to 30 days.

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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
// Construct the portal class and ensure that the user provides their credentials.
let theURL = URL(string: "https://myportal.com")

// Request that the user signs in with their credentials.
let portal = AGSPortal(url: theURL!, loginRequired: true)

// Load the portal.
portal.load { (error) in
 if let error = error {
  print(error)
 }
 else {

  // Get the users license info from the portal.
  portal.fetchLicenseInfo { (licenseInfo,error) in

    guard let error = error {
     print("Error fetching user's licenses... \(error)")
     return
    }

     // Set the license using the user's licenseInfo.
    do {
      let result = try AGSArcGISRuntimeEnvironment.setLicenseInfo(licenseInfo!)
    }
    catch let error as NSError {
     print("error: \(error.localizedDescription)")
    }

    // The app is now licensed.

    // Save the license information so that the app can be started and licensed offline.
    // In this example, the licenseDictionary is stored in keychain.

    var licenseDictionary: NSDictionary?

    do {licenseDictionary = try licenseInfo?.toJSON() as! NSDictionary?
    } catch {
     print("LicenseInfo not available")
    }

    let keychainItem = AGSKeychainItem(identifier: "com.your_org.your_app_name", accessGroup: nil, acrossDevices: false)
    keychainItem.writeObject(toKeychain: licenseDictionary!, completion: { (writeError) in
     if let error = writeError {
      print("Error writing to the Keychain... \(error)")
     }
    })
  }
 }
}

If you saved the license information on local storage, your app can be started and licensed in an offline environment using the saved license information. Retrieve the license from storage and license your app.

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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
// Locate the keychain.
let keychainItem = AGSKeychainItem(identifier: "com.your_org.your_app_name", accessGroup: nil, acrossDevices: false)

// Return the license JSON from the keychain.
let licenseDictionary = keychainItem.readObjectFromKeychain() as? NSDictionary

// Construct the license info from the JSON.
let licenseInfo = try! AGSLicenseInfo.fromJSON(licenseDictionary!) as? AGSLicenseInfo

// License the app with the license Info.
AGSArcGISRuntimeEnvironment.setLicenseInfo(licenseInfo!, error: errorPointer)

License extensions with a license string

1. Read the end user license agreement.
2. Find a location in your code that runs before any ArcGIS Runtime functionality is used.
3. Call the setLicenseKey() method on the AGSArcGISRuntimeEnvironment singleton object to license the app with a main license string and any extension licenses.

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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
let error : NSErrorPointer = nil

AGSArcGISRuntimeEnvironment.setLicenseKey("runtimeadvanced,1000,rud#########,day-month-year,####################",
 extensions: ["runtimesmpna,1000,rud#########,day-month-year,####################",
              "runtimesmpla,1000,rud#########,day-month-year,####################" ], error: error)

Your app is now licensed to use the extensions.

Attribute Esri in your app

Esri requires that when you use an ArcGIS Online basemap, Esri data services, or Esri API technology in your app you must also include Esri attribution. There are specific requirements for attribution you may be required to address in your app depending on how your app is built and the data it uses. This is outlined in detail in the Attribution in your app topic.