Send push with Airship through Courier

Prerequisites

An Airship account with a project
Your Airship auth token and base URL

Setup

Create an Airship auth token

In Airship, open your project at go.airship.com and create a bearer token. The base URL is your project’s region endpoint.

Configure in Courier

Open the in Courier, enter your auth token and base URL, then click “Save.”

Profile requirements

Device tokens live on the user profile rather than on the send, so one profile can hold tokens for several devices and every push provider reads them from the same place. covers the model. Airship addresses the recipient by audience and device types, both under airship on the profile. Store them once with , which merges into the profile and creates it if it does not exist:

const profile = await client.profiles.create('user_123', {
  profile: {
    airship: {
      audience: {
        named_user: 'user_123',
      },
      device_types: [
        'ios',
      ],
    },
  },
});

profile = client.profiles.create(
    user_id="user_123",
    profile={
        "airship": {
            "audience": {
                "named_user": "user_123",
            },
            "device_types": [
                "ios",
            ],
        },
    },
)

curl --request POST \
  --url https://api.courier.com/profiles/user_123 \
  --header "Authorization: Bearer $COURIER_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "profile": {
      "airship": {
        "audience": {
          "named_user": "user_123"
        },
        "device_types": [
          "ios"
        ]
      }
    }
  }'

profile = courier.profiles.create(
  "user_123",
  profile: {
    airship: {
      audience: {
        named_user: "user_123"
      },
      device_types: ["ios"]
    }
  }
)

profile, err := client.Profiles.New(
	context.TODO(),
	"user_123",
	courier.ProfileNewParams{
		Profile: map[string]any{
			"airship": map[string]any{
				"audience": map[string]any{
					"named_user": "user_123",
				},
				"device_types": []any{"ios"},
			},
		},
	},
)

ProfileCreateParams params = ProfileCreateParams.builder()
    .userId("user_123")
    .profile(ProfileCreateParams.Profile.builder()
        .putAdditionalProperty("airship", JsonValue.from(java.util.Map.of(
            "audience", java.util.Map.of(
                "named_user", "user_123"),
            "device_types", java.util.List.of("ios"))))
        .build())
    .build();
ProfileCreateResponse profile = client.profiles().create(params);

$profile = $client->profiles->create('user_123', profile: [
  'airship' => [
    'audience' => [
      'named_user' => 'user_123',
    ],
    'device_types' => ['ios'],
  ],
]);

ProfileCreateParams parameters = new()
{
    UserID = "user_123",
    Profile = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
        """
        {
          "airship": {
            "audience": {
              "named_user": "user_123"
            },
            "device_types": [
              "ios"
            ]
          }
        }
        """
    ),
};
var profile = await client.Profiles.Create(parameters);

courier profiles create \
  --api-key "$COURIER_API_KEY" \
  --user-id user_123 \
  --profile '{"airship":{"audience":{"named_user":"user_123"},"device_types":["ios"]}}'

With Courier MCP, save the Airship named user user_123 on user_123, for iOS.

Then send to user_id and Courier resolves the address. For a one-off with no stored profile, pass it inline instead: "to": { "airship": { "audience": { "named_user": "user_123" }, "device_types": ["ios"] } }.

Send by user id

The call in every language, and the rest of the profile object.

Send to a recipient

Send to user id
Send to airship

Courier reads airship off the saved profile, so preferences apply and the value can change without touching this code.

const { requestId } = await courier.send.message({
  message: {
    to: {
      user_id: "user_123",
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
  },
});

response = client.send.message(
    message={
        "to": {
            "user_id": "user_123",
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
    },
)

curl -X POST https://api.courier.com/send \
  -H "Authorization: Bearer $COURIER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": {
      "to": {
        "user_id": "user_123"
      },
      "template": "nt_01kx4h2jdafq8bk9aftxak4b40"
    }
  }'

response = courier.send_.message(
  message: {
    to: {
      user_id: "user_123"
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40"
  }
)

response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
	Message: courier.SendMessageParamsMessage{
		To: courier.SendMessageParamsMessageToUnion{
			OfUserRecipient: &shared.UserRecipientParam{
				UserID: courier.String("user_123"),
			},
		},
		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
	},
})

SendMessageParams params = SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(UserRecipient.builder().userId("user_123").build())
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .build())
    .build();
SendMessageResponse response = client.send().message(params);

$response = $client->send->message(
  message: [
    'to' => [
      'user_id' => 'user_123',
    ],
    'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new UserRecipient { UserID = "user_123" },
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
    },
};

var response = await client.Send.Message(parameters);

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"user_id": "user_123"}' \
  --message.template nt_01kx4h2jdafq8bk9aftxak4b40

With Courier MCP, send my template to user_123 by email.

Pass it inline instead and nothing is stored. Swap this to object into the call on the other tab.

const { requestId } = await courier.send.message({
  message: {
    // A provider recipient is a profile field, so it sits outside the typed union.
    to: {
      airship: {
        audience: {
          named_user: "user_123",
        },
        device_types: ["ios"],
      },
    } as any,
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
  },
});

response = client.send.message(
    message={
        "to": {
            "airship": {
                "audience": {
                    "named_user": "user_123",
                },
                "device_types": ["ios"],
            },
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
    },
)

curl -X POST https://api.courier.com/send \
  -H "Authorization: Bearer $COURIER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": {
      "to": {
        "airship": {
          "audience": {
            "named_user": "user_123"
          },
          "device_types": [
            "ios"
          ]
        }
      },
      "template": "nt_01kx4h2jdafq8bk9aftxak4b40"
    }
  }'

response = courier.send_.message(
  message: {
    to: {
      airship: {
        audience: {
          named_user: "user_123"
        },
        device_types: ["ios"]
      }
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40"
  }
)

// A provider recipient is a profile field, so it sits outside the typed union.
to := param.Override[shared.UserRecipientParam](
	json.RawMessage(`{"airship": {"audience": {"named_user": "user_123"}, "device_types": ["ios"]}}`),
)

response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
	Message: courier.SendMessageParamsMessage{
		To: courier.SendMessageParamsMessageToUnion{OfUserRecipient: &to},
		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
	},
})

// A provider recipient is a profile field, so it sits outside the typed union.
UserRecipient to = UserRecipient.builder()
    .putAdditionalProperty("airship", JsonValue.from(Map.of(
            "audience", Map.of(
                "named_user", "user_123"),
            "device_types", List.of("ios"))))
    .build();

client.send().message(SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(to)
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .build())
    .build());

$response = $client->send->message(
  message: [
    'to' => [
      'airship' => [
        'audience' => [
          'named_user' => 'user_123',
        ],
        'device_types' => ['ios'],
      ],
    ],
    'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
  ],
);

// A provider recipient is a profile field, so it sits outside the typed union.
UserRecipient to = UserRecipient.FromRawUnchecked(
    JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
        """{"airship": {"audience": {"named_user": "user_123"}, "device_types": ["ios"]}}"""
    )
);

var response = await client.Send.Message(new() { Message = new() { To = to, Template = "nt_01kx4h2jdafq8bk9aftxak4b40" } });

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"airship": {"audience": {"named_user": "user_123"}, "device_types": ["ios"]}}' \
  --message.template nt_01kx4h2jdafq8bk9aftxak4b40

With Courier MCP, send my template to the Airship named user user_123.

Overrides

covers the two levels and which one wins. lists the fields every push provider takes. A provider override changes what Courier sends to Airship’s API. For example, use basic auth on one send request:

const { requestId } = await courier.send.message({
  message: {
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    to: {
      airship: {
        audience: {
          named_user: "user_123",
        },
        device_types: [
          "ios",
        ],
      },
    },
    data: {
      dataForPushMessage: true,
    },
    providers: {
      airship: {
        override: {
          body: {},
          headers: {
            Authorization: "Basic <EncodedAppKey:AppSecret>",
          },
        },
      },
    },
  },
});

response = client.send.message(
    message={
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "to": {
            "airship": {
                "audience": {
                    "named_user": "user_123",
                },
                "device_types": [
                    "ios",
                ],
            },
        },
        "data": {
            "dataForPushMessage": True,
        },
        "providers": {
            "airship": {
                "override": {
                    "body": {},
                    "headers": {
                        "Authorization": "Basic <EncodedAppKey:AppSecret>",
                    },
                },
            },
        },
    },
)

curl -X POST https://api.courier.com/send \
  -H "Authorization: Bearer $COURIER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": {
      "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
      "to": {
        "airship": {
          "audience": {
            "named_user": "user_123"
          },
          "device_types": [
            "ios"
          ]
        }
      },
      "data": {
        "dataForPushMessage": true
      },
      "providers": {
        "airship": {
          "override": {
            "body": {},
            "headers": {
              "Authorization": "Basic <EncodedAppKey:AppSecret>"
            }
          }
        }
      }
    }
  }'

response = courier.send_.message(
  message: {
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    to: {
      airship: {
        audience: {
          named_user: "user_123"
        },
        device_types: [
          "ios"
        ]
      }
    },
    data: {
      dataForPushMessage: true
    },
    providers: {
      airship: {
        override: {
          body: {},
          headers: {
            Authorization: "Basic <EncodedAppKey:AppSecret>"
          }
        }
      }
    }
  }
)

// This provider addresses the recipient with fields outside the typed
// UserRecipient model, so pass the recipient as raw JSON.
to := param.Override[shared.UserRecipientParam](json.RawMessage(`{
  "airship": {
    "audience": {
      "named_user": "user_123"
    },
    "device_types": [
      "ios"
    ]
  }
}`))

response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
	Message: courier.SendMessageParamsMessage{
		To: courier.SendMessageParamsMessageToUnion{OfUserRecipient: &to},
		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
		Data: map[string]any{
			"dataForPushMessage": true,
		},
		Providers: shared.MessageProvidersParam{
			"airship": shared.MessageProvidersTypeParam{
				Override: map[string]any{
					"body": map[string]any{},
					"headers": map[string]any{
						"Authorization": "Basic <EncodedAppKey:AppSecret>",
					},
				},
			},
		},
	},
})

SendMessageParams params = SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        // This provider addresses the recipient with fields outside the
        // typed UserRecipient model, so pass them as additional properties.
        .to(UserRecipient.builder()
            .putAdditionalProperty("airship", JsonValue.from(java.util.Map.of(
                "audience", java.util.Map.of(
                    "named_user", "user_123"
                ),
                "device_types", java.util.List.of(
                    "ios"
                )
            )))
            .build())
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .data(JsonValue.from(java.util.Map.of(
            "dataForPushMessage", true
        )))
        .providers(MessageProviders.builder()
            .putAdditionalProperty("airship", JsonValue.from(java.util.Map.of("override", java.util.Map.of(
                    "body", java.util.Map.of(),
                    "headers", java.util.Map.of(
                        "Authorization", "Basic <EncodedAppKey:AppSecret>"
                    )
                ))))
            .build())
        .build())
    .build();
SendMessageResponse response = client.send().message(params);

$response = $client->send->message(
  message: [
    'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
    'to' => [
      'airship' => [
        'audience' => [
          'named_user' => 'user_123',
        ],
        'device_types' => [
          'ios',
        ],
      ],
    ],
    'data' => [
      'dataForPushMessage' => true,
    ],
    'providers' => [
      'airship' => [
        'override' => [
          'body' => [],
          'headers' => [
            'Authorization' => 'Basic <EncodedAppKey:AppSecret>',
          ],
        ],
      ],
    ],
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        // This provider addresses the recipient with fields outside the
        // typed UserRecipient model, so build it from raw JSON.
        To = UserRecipient.FromRawUnchecked(
            JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
                """
                {
                  "airship": {
                    "audience": {
                      "named_user": "user_123"
                    },
                    "device_types": [
                      "ios"
                    ]
                  }
                }
                """
            )
        ),
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
        Data = new Dictionary<string, JsonElement>()
        {
            { "dataForPushMessage", JsonSerializer.SerializeToElement(true) },
        },
        Providers = new Dictionary<string, MessageProvidersType>()
        {
            {
                "airship",
                new()
                {
                    Override = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
                        """
                        {
                          "body": {},
                          "headers": {
                            "Authorization": "Basic <EncodedAppKey:AppSecret>"
                          }
                        }
                        """
                    ),
                }
            },
        },
    },
};

var response = await client.Send.Message(parameters);

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"airship": {"audience": {"named_user": "user_123"}, "device_types": ["ios"]}}' \
  --message.template nt_01kx4h2jdafq8bk9aftxak4b40 \
  --message.data '{"dataForPushMessage": true}' \
  --message.providers '{"airship": {"override": {"body": {}, "headers": {"Authorization": "Basic <EncodedAppKey:AppSecret>"}}}}'

With Courier MCP, send my template through Airship using basic auth on this one send.

Overrides are deep-merged into the request. Fields you set replace their counterparts, and everything you leave out is still sent. The full field list is in Airship’s API docs.

Tracking events

Courier puts the tracking URL in the global_attributes data bag. See for details.

Provider details

airship

Courier recommends routing to the channel. Naming this key in routing.channels instead is supported, and sends through just this provider.

Send to a specific provider

When that is worth doing, and what you give up: failover, channel priority, and providers you add later.

Get started

Available integrations

Send push with Airship through Courier

Prerequisites

Setup

Profile requirements

Send by user id

Send to a recipient

Overrides

Tracking events

Provider details

Send to a specific provider

​Prerequisites

​Setup

​Profile requirements

Send by user id

​Send to a recipient

​Overrides

​Tracking events

​Provider details

Send to a specific provider

Prerequisites

Setup

Profile requirements

Send to a recipient

Overrides

Tracking events

Provider details