Getting started with content management

You can store and manage content for your applications using the ArcGIS Platform portal. To access content, you can use interactive tools or build custom applications that use the portal service.

What is the portal?

The ArcGIS Platform portal is a geospatial content management system hosted in the cloud. It is used by Esri and many other users, organizations, and developers around the world to securely store, manage, and search for different types of content. You can create and store your own content using tools such as ArcGIS Online and the developer dashboard, or you can create and access content with custom applications. All content is managed with an item, allowing applications to easily read, write, and access it.

As a developer, you can use the portal to:

  • Create and manage geospatial content for your applications, such as maps, scenes, layers, and services.
  • Build content management applications that create, manage, and access content.
  • Build content-driven applications that access existing content in the portal.
  • Share content privately, publicly, or with groups.
  • Search for private or public content.
  • Store and host web mapping apps created with app templates and builders.
  • Store map and layer packages used by ArcGIS Pro, ArcGIS Desktop, and ArcGIS native apps.
  • Store and manage non-spatial content such as Microsoft Word or PDF files.

How the portal works

The ArcGIS Platform portal is powered by the portal service with a base URL of https://www.arcgis.com/sharing/rest.

To access the portal, you need an ArcGIS account. Your account is associated with an organization and it gives you access to a private space where you can store and manage your own content. It also allows you to sign in with tools, such as ArcGIS Online and the developer dashboard to create, manage, share, and search content. With an account you can also create API keys and OAuth 2.0 tokens that can be used to access restricted operations.

When you add content to the portal, an item is created. Items are used to manage content properties such as the title, description, tags, and sharing settings. Items have a unique ID that you can use to easily find the item and access the content they reference.

After items are created, you can build content management applications or content-driven applications to access and display content such as web maps, web scenes, and layers.

Create, manage, and access different types of content in the ArcGIS Platform portal.

Build applications

You can build two different types of applications that work with the portal:

  1. Content management applications
  2. Content-driven applications

Content management applications

A content management application is built with client APIs or REST API, to access the portal service directly, and can perform operations such as creating, accessing, and managing items, users, and groups.

For example, you can build applications that:

General steps for building content management applications

  1. Connect to the ArcGIS Platform portal at https://www.arcgis.com/sharing/rest.
  2. Make requests to the portal service. An access token may be required.

Access tokens are required to make requests to restricted operations in the portal service, such as accessing private content or creating new content. In most cases, you will need to use an OAuth 2.0 token because API keys only provide access to private content such as feature layers and vector tile layers. To access all other restricted operations, an OAuth 2.0 token is required.

Learn more about using access tokens.

Example: Get an item

The examples below show how to access a public and private item by ID.

See more examples in Search, Items, Users and Groups.

APIs

PublicPrivate
ArcGIS REST JSArcGIS JS APIArcGIS Python APIArcGIS iOS API
                           
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
//

import { getItem } from "@esri/arcgis-rest-portal"

getItem("5a5147abe878444cbac68dea9f2f64e7", { portal: "https://www.arcgis.com/sharing/rest" })
  .then((response)=>{
    console.log(response);
  });


import { getItem } from "@esri/arcgis-rest-portal"
import { UserSession } from "@esri/arcgis-rest-auth"
import { ApiKey } from "@esri/arcgis-rest-auth"

const authentication = new UserSession ({
  token: "ACCESS_TOKEN" // Token representing an ArcGIS Identity from performing oAuth 2.0
});

// OR
const authentication = new ApiKey({
  key: "YOUR_API_KEY"
});

getItem("ITEM_ID", { authentication: authentication })
.then((response)=>{
  console.log(response);
});
ArcGIS REST JSArcGIS JS APIArcGIS Python APIArcGIS iOS API
                           
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
//

import { getItem } from "@esri/arcgis-rest-portal"

getItem("5a5147abe878444cbac68dea9f2f64e7", { portal: "https://www.arcgis.com/sharing/rest" })
  .then((response)=>{
    console.log(response);
  });


import { getItem } from "@esri/arcgis-rest-portal"
import { UserSession } from "@esri/arcgis-rest-auth"
import { ApiKey } from "@esri/arcgis-rest-auth"

const authentication = new UserSession ({
  token: "ACCESS_TOKEN" // Token representing an ArcGIS Identity from performing oAuth 2.0
});

// OR
const authentication = new ApiKey({
  key: "YOUR_API_KEY"
});

getItem("ITEM_ID", { authentication: authentication })
.then((response)=>{
  console.log(response);
});

REST API

RequestResponse
          
1
2
3
4
5
6
7
8
9
10
## Public

curl https://www.arcgis.com/sharing/rest/content/items/5a5147abe878444cbac68dea9f2f64e7 \
-d 'f=pjson'

## Private

curl https://www.arcgis.com/sharing/rest/content/items/<ITEM_ID> \
-d 'f=pjson' \
-d 'token=<ACCESS_TOKEN>'

Response

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
// Public

{
  "id": "5a5147abe878444cbac68dea9f2f64e7",
  "owner": "esri_devlabs",
  "orgId": "GVgbJbqm8hXASVYi",
  "created": 1569537110000,
  "modified": 1569537111000,
  "guid": null,
  "name": null,
  "title": "Seven Natural Wonders of the World Map",
  "type": "Web Map"
}

// Private

{
  "id": "ITEM_ID",
  "owner": "OWNER",
  "orgId": "ORG_ID",
  "created": "DATE_CREATED",
  "modified": "DATE_MODIFIED",
  "guid": null,
  "name": null,
  "title": "ITEM_TITLE",
  "type": "ITEM_TYPE"
}

Content-driven applications

Content-driven applications are built following a tools-first workflow, where you first create content in the portal with an interactive tool, such as ArcGIS Online or the developer dashboard, and then build a custom application to access the content.

Some examples of tools that can create content for applications are:

  • Map Viewer: Create and style layers in a web map.
  • Scene Viewer: Create and style layers in a web scene.
  • ArcGIS Online or the developer dashboard: Import data as a feature layer and set its properties.
  • ArcGIS Online or the developer dashboard: Publish a vector tile layer.
  • ArcGIS Vector Tile Style Editor: Style a basemap layer.

General steps for building content-driven applications

  1. Create content such as a web map, web scene, or hosted layer with tools.
  2. Manage the content items with tools.
  3. Access the content items with a custom application.

See the tutorial workflows below for examples.

Tutorials

Use tools to create different types of content and build content-driven applications.

Web maps

The Map Viewer can be used to interactively create and style a map for your applications. The Map Viewer provides a number of features to help you style layers and pop-ups to produce high-quality cartography in your map. Once styled and saved in the portal, you can access the web map by its item ID and use it in your applications. Web maps are stored as a JSON object in a web map item.

Workflow

  1. Create a web map with the Map Viewer.
  2. Style the layers and configure pop-ups.
  3. Display the web map in an application.

Web scenes

The Scene Viewer can be used to interactively create and style a 3D web scene for your applications. Similar to the Map Viewer, the Scene Viewer allows you access and style layers to create high-quality 3D visualizations. You can also set the initial camera viewpoint. Once styled and saved in the portal, you can access the web scene by its item ID and use it in your 3D applications. Web scenes are stored as a JSON object in a web scene item.

Workflow

  1. Create a web scene with the Scene Viewer.
  2. Style the layers and configure pop-ups.
  3. Display the web scene in an application.

Feature layers

Tools such as ArcGIS Online and the developer dashboard can be used to import data in different formats such as CSV, GeoJSON, and Shapefile, and host the data in the portal as a hosted layer item. Once imported, you can use the tools to manage the layer item and access the data service. For example, you can add or remove fields that are accessible, change the default layer style, or change the sharing settings to private, public, or shared with a group. Applications can access hosted layers by the layer item ID or the data service URL. Learn more about hosting data in Data hosting.

Workflow

  1. Import data as a feature layer.
  2. Configure the feature layer.
  3. Display the feature layer in an application.

Vector tile layers

You can also use tools such as ArcGIS Online and the developer dashboard to publish vector tile layers from feature layers. If the feature layer contains styles, the styles will be exported and applied to the new vector tile layer. Vector tile layers and their styles are stored as tile layer items in the portal. Once in the portal, you can manage the layer properties and easily access the vector tile layers from applications.

Workflow

  1. Create a feature layer, style it, and then publish a new vector tile layer.
  2. Display the layer in an application.

Basemap layers

The Vector tile style editor can be used to create your own custom basemap styles and use them in applications. The editor allows you to create a new style with custom colors, fonts, and images and store them as new vector tile layer items in the portal. Once stored in the portal, applications can access the vector tile layer and styles easily from applications.

Workflow

  1. Create a new basemap style with the Vector tile style editor.
  2. Display the basemap style in an application.

Services

Portal service

Store, manage, and access private and public content.

API support

Full supportPartial supportNo support
  • 1. Limited operations
  • 2. Requires ArcGIS REST JS

Tools

Use tools to access the portal and create and manage content for applications.

Your browser is no longer supported. Please upgrade your browser for the best experience. See our browser deprecation post for more details.