# Intro to Channels

Channels represent the various devices, users, and addresses that make up your audience. Channels are a concept fundamental to Airship. Understanding the various applications of channels can help you better understand and target your audience.

> **Important:** **Channels** can also refer to *engagement channels*, a medium for engaging with your users, e.g., app, web, SMS, email.
> See [Disambiguation](#disambiguation) below.


## Origin and Purpose

Airship introduced *channels* in 2014 as a new means of addressing
apps via the *channel ID*. Prior to channels, in order to target a
device for a push notification, we used the *push address*, the identifier
provided by the downstream delivery service for the given mobile OS. For
example, to deliver to an iOS device, we used the *device token* provided by
Apple Push Notification service (APNs).

Because a push address can change without notice, we introduced channel IDs to
abstract the notion of an addressable app from the push address. This change
lessened the burden on our customers of having to store push addresses, e.g.,
device tokens. We simply map the channel ID to a device token if it changes.

Channels also became a useful framework for us to develop new services around
the concept of an addressable entity and to move beyond apps into new
engagement mediums such as web browsers, email, and SMS. We subsequently
introduced [Named Users](https://www.airship.com/docs/reference/glossary/#named_user) as a way
to map multiple channels together, and
[Channel Coordination](https://www.airship.com/docs/reference/glossary/#channel_coordination) features, which rely on
both channels and named users to help you optimize your multi-channel
marketing campaigns.


## Disambiguation {#disambiguation}

You will find that throughout our documentation and in the Airship
[Dashboard](https://www.airship.com/docs/reference/glossary/#dashboard)
we use the term *channel* differently, depending on context: engagement vs. development.

### Engagement Channels {#engagement-channels}

At a high level, we use the term *channel* to denote an **engagement
channel** over which you can reach your end users. We support the following
channels, some of which encompass more than one *platform*, e.g.,
_The iOS platform is a supported **app** channel_.

| Engagement channel | Platform |
| --- | --- |
| App   | iOS, Android, Fire OS, Windows, Apple News  |
| Web          | Chrome, Firefox, Edge, Safari, Opera       |
| Email        | n/a                                                |
| SMS          | n/a                                                |
| Open         | *Configurable*                                       |


### Development Channels {#development-channels}

In the development context, a channel describes a **deliverable endpoint**,
such as an email address, SMS number, or iPhone app installation.

The defining property of a development channel is the
[*channel ID*](#channel-ids), but development channels are also associated with other information. This information varies depending on the associated
[engagement channels](#engagement-channels),
and also for the platforms within a type of engagement channel. For
example, an email channel has a `sender_name`, and an SMS
channel has a `msisdn`.

Development channels can further be thought of as one of two basic types: *native* and
*open*. This distinction is largely tied to how you interact with the channels — either via an installed SDK for a native platform, or our channels API for
open platforms. See
[Native vs Open Platforms](#native-open) below.

**Example iOS Channel Object**:

```json
{
   "channel": {
      "channel_id": "01234567-890a-bcde-f012-3456789abc0",
      "device_type": "ios",
      "installed": true,
      "background": true,
      "opt_in": true,
      "push_address": "FE66489F304DC75B8D6E8200DFF8A456E8DAEACEC428B427E9518741C92C6660",
      "created": "2013-08-08T20:41:06",
      "last_registration": "2018-05-01T18:00:27",
      "named_user_id": "some_id_that_maps_to_your_systems",
      "tags": [
         "one_fish",
         "two_fish"
      ],
      "tag_groups": {
         "fish_colors": [
            "red",
            "blue"
         ],
         "fish_ages": [
            "old",
            "new"
         ]
      },
      "ios": {
         "badge": 0,
         "quiettime": {
            "start": null,
            "end": null
         },
         "tz": "America/Los_Angeles"
      }
   }
}
```



## Channel IDs {#channel-ids}

[Development channels](#development-channels) are addressable
via the *channel ID*. A channel ID is a unique identifier generated by
Airship for each channel.

In cases where a downstream service (such as APNs for iOS devices) provides the
[push address](#terminology) for ultimate delivery, the channel
ID maps to that delivery address. This mapping ensures consistency of channel
metadata — information about the channel, such as segmentation information —
even if the mapped service changes its own delivery address, e.g., device
token for iOS or registration token for Android.


## Channels API {#channels-api}

Airship’s
[Channels API](https://www.airship.com/docs/developer/rest-api/ua/operations/channels/)
provides a set of endpoints for the management of
[engagement channels](#engagement-channels) and their
platforms.

You can create, look up, list, and manage channel information, as well as
extend Airship by defining new platforms for use with our core platform
services, e.g., segmentation, scheduling, automation.

> **Tip:** If you use an AI coding assistant, you can connect it to Airship with Skills and an MCP server. See [Airship AI Tools](https://www.airship.com/docs/developer/ai-tools/ai-tools/).

## Native vs Open Platforms {#native-open}

App and web platforms are supported by an
[Airship SDK](https://www.airship.com/docs/guides/getting-started/developers/sdk-api/) and as such are considered *native*.

**Native Platforms**:

| Channel | Platform |
|---------|----------|
| App     | iOS      |
| App     | Android  |
| App     | Fire OS   |
| Web     | Chrome   |
| Web     | Safari   |
| Web     | Firefox  |
| Web     | Opera    |
| Web     | Edge     |

Email, SMS, and Open channels are supported by our Channels API for channel registration,
and other operations, e.g., adding tags, opt-out, unsubscribe/uninstall, etc.

Open platforms are not supported by an Airship SDK because the delivery mechanism is not a traditional client application like an app or web browser.


**Open Platforms**:

| Channel | Platform | API reference |
| --- | --- | --- |
| [Email](https://www.airship.com/docs/developer/api-integrations/email/) | n/a | [Email Channels API reference](https://www.airship.com/docs/developer/rest-api/ua/operations/email/) |
| [SMS](https://www.airship.com/docs/developer/api-integrations/sms/) |  n/a | [SMS Channels API reference](https://www.airship.com/docs/developer/rest-api/ua/operations/sms/)     |
| [Open](https://www.airship.com/docs/developer/api-integrations/open/) | *Configurable* | [Open Channels API reference](https://www.airship.com/docs/developer/rest-api/ua/operations/open-channels/) |


### Channel Registration

For **native platforms**, [channel IDs](#channel-ids) are created and persisted during the registration process: When your app runs for the first time (it may run in the background or when a user opens the app for the first time), our SDK creates a [(development) channel](#development-channels) and maps it to that installation. For example, on iOS it will map a device token to that channel. The channel ID then becomes the primary identifier used to address notifications/messages to the device. If iOS ever changes the device token, we can update the device token behind the scenes without changing the channel.


For **open platforms**, channel registration and manipulation are handled via
our [Channels API](#channels-api), giving you maximum
flexibility to create and update, opt-in or -out, look up, or uninstall
channels, and add or remove tags and other metadata.

Delivery addresses on open platforms can be an IP address, webhook URL, phone number, or email address, depending on the channel type.

## Terminology

<!-- We define these above, mostly. Can we do tooltips or something and toss this section? -->

Channel (Development)
: A *channel* is an instance representing an entity addressable via the Airship service, e.g., an iOS device, email address, SMS number or web browser. The channel instance or [channel object](/docs/developer/rest-api/ua/#schemas-channelobject) contains all relevant information about a channel, including metadata used for targeting, opt-in status, device-specific information, and, importantly, a unique identifier for the channel, the *Channel ID*.

Channel (Engagement)
: A *channel* is a communication medium supported by the Airship service. Supported channels include app, web, email, SMS, and *Open Channels*. Within some channels there may be specific *platforms* with individual characteristics. Example platforms include Chrome for the web channel and Android for the mobile app channel.

Channel ID
: A *Channel ID* is an Airship-specific unique identifier for a channel instance, e.g., a smartphone, web browser, email address.

Platform
: A *platform* is an external OS or other system to which notifications are delivered. Mobile platforms include iOS and Android, web platforms include Chrome and Firefox, etc. Airship-supported platforms may be either *native platforms*, which require an installed SDK, or *open platforms*, which do not.

Native platform
: A *native platform* is a platform for which an installed SDK is required to register and manipulate channels. Examples: iOS, Chrome.

Open platform
: An *open platform* is a platform for which an SDK is not available, and channel registration and manipulation are handled via the Channels API. Examples: Open Channels, Email.

Push address
: The *push address* is the underlying device identifier that maps to a Channel ID for message delivery. The push address is analogous to a phone number and has the information necessary to locate and authenticate an installation of an app or browser. Because a push address can change, Airship maps push addresses to channels, which do not change. An example of a push address is a *device token* in the case of iOS.

