iOS
Push Notifications

Push Notifications for iOS

A push notification is a message which is immediately delivered to a user device when the device is either idle or running your client app in the backgroud. Push notifications for iOS client apps are sent using Apple Push Notification service (APNs) and include custom data your app needs to respond to the notifications. When a message is sent to Sendbird server through our Chat SDK for iOS, the server communicates with APNs, and then APNs delivers a push notification to an iOS device where your client app is installed.

Note: By default, when a user to receive messages is being disconnected from Sendbird server, the server sends notification requests to APNs for the messages. The Chat SDK for iOS automatically detects when a user's client app goes into the background from the foreground, and updates the user's connection status to disconnected. Therefore, in normal cases, you don't need to explicitly call the disconnectWithCompletionHandler: method.

Notifications can also be configured to display an alert, play a sound, or badge your app’s icon and are only applicable to group channels. They can't be applied to an open channel or a super group channel due to the massive number of users and messages.

Push notifications support both single and multi-device users and they are delivered only when a user is fully offline from all devices even when they use only one device. In other words, if a user is online on one or more devices, notifications aren't delivered and thus not displayed on any devices.

Additional multi-device support for push notifications is also provided. If selected from your dashboard, for multi-device users, notifications are delivered to all online and offline devices. However, through iOS, notifications are displayed only on offline devices.

Note: Depending on how you implement your client app, push notifications can be displayed even when the app is in the foreground, given that additional multi-device support for push notifications is selected in your dashboard. Refer to Apple Developer Documentation to learn how.

This page describes how to obtain iOS and APNs credentials from the Apple Developer portal and how to implement our push notifications in your iOS client app.


Step 1: Create your certificate signing request

Note: Before you begin, you should already have an app ID assigned to your client app.

To obtain a signing certificate required to sign apps for installation on iOS devices, you should first create a certificate signing request (CSR) file through Keychain Access on your Mac.

  1. Open the Keychain Access from the Utilities folder, go to Keychain Access > Certificate Assistant > Request a Certificate From a Certificate Authority, and then click.
    CSR1
  2. The Certificate Information dialog box appears. Enter the email address that you use in your Apple Developer account, and enter a common name for your private key. Don't enter CA email address, choose Saved to disk, and then click the Continue button.
    CSR2
  3. Specify the name of your CSR to save and choose the location to save the file on your local disk. Then your CSR file is created, which contains a public/private key pair.

Step 2: Create your push notification SSL certificate

  1. Sign in to your account at the Apple Developer Member Center and choose Certificates, Identifiers & Profiles. In the Identifiers > App IDs, select the Push Notifications service, and then click the Configure button.
    App IDs
  2. When prompted by a pop-up window, choose which SSL certificate to create either Development or Production.
    Push Certificate
  3. In the Certificates, Identifiers & Profiles pane that appears after the selection, under Upload a Certificate Signing Request, upload the CSR file you created through the Choose File button. Then to complete the process, click the Continue button above. When the certificate is ready, choose Download to save it to your Mac.
    Push Certificate
  4. In order to install the downloaded certificate to the KeyChain Access on your Mac, double-click it. You can find the certificate in the KeyChain Access > login > Certificates.

Step 3: Export a .p12 file and upload to Sendbird Dashboard

Sendbird server needs to use some of your confidential information in your .p12 file to communicate with and send notification requests to APNs on behalf of your server. A .p12 file is a set of certificates that you generated when building a client app for iOS.

You can register your .p12 file to Sendbird server through your dashboard or by using the Chat API's add an APNs push configuration action. The following steps show how to register a .p12 file in the Dashboard.

  1. Open KeyChain Access and go to login > Certificates. Find the push notification SSL certificate you just added, right-click the certificate, and then select Export... from the context menu to get a .p12 file that contains the certificate.
    P12 export1
  2. Type a name for the .p12 file and save it to your Mac. Do not provide an export password when prompted. Then sign in to your dashboard and upload the file under Settings > Application > Notifications.
    Set Push Information
  3. When a dialog opens up, click the Choose file and select your .p12 file to upload the certificate to our server. Once you select a file, a password box appears. If needed, you can also set a password for the file. Set Push Information

Step 4: Register a device token to Sendbird server

Note: A user can have up to 20 APNs device tokens. The oldest token will be deleted before a new token is added for a user who already has 20 device tokens. Only the 20 newest tokens will be maintained for users who already have more than 20.

When requested to send notifications to a specific client app on an iOS device, APNs requires the app instance's globally-unique and app-specific device token which has been issued by itself. Therefore, to send notification requests to APNs on behalf of your server, Sendbird server needs every device tokens of your client app instances. If an app instance is successfully registered to APNs via the registerForRemoteNotifications method, a device token is passed to an app delegate object's application:didRegisterForRemoteNotificationsWithDeviceToken: method which is called by the app. Like the following sample code, you should register this token to Sendbird server by passing it as an argument to a parameter in the registerDevicePushToken:unique:completionHandler: method.

Objective-C
Swift
Light Color Skin
Copy
// AppDelegate.m
- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
    // Register a device token to Sendbird server.
    [SBDMain registerDevicePushToken:deviceToken unique:YES completionHandler:^(SBDPushTokenRegistrationStatus status, SBDError * _Nullable error) {
        if (error == nil) {
            if (status == SBDPushTokenRegistrationStatusPending) {
                // A token registration is pending.
                // If this status is returned, invoke `+ registerDevicePushToken:unique:completionHandler:` with `[SBDMain getPendingPushToken]` after connection.
            }
            else {
                // A device token is successfully registered.
            }
        }
        else {
            // Registration failure.
        }
    }];
}
Light Color Skin
Copy
// AppDelegate.swift
func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    // Register a device token to Sendbird server.
    SBDMain.registerDevicePushToken(deviceToken, unique: true, completionHandler: { (status, error) in
        if error == nil {
            if status == SBDPushTokenRegistrationStatus.pending {
                // A token registration is pending.
                // If this status is returned, invoke `+ registerDevicePushToken:unique:completionHandler:` with `[SBDMain getPendingPushToken]` after connection.
            }
            else {
                // A device token is successfully registered.
            }
        }
        else {
            // Registration failure.
        }
    })
}

Note: If SBDPushTokenRegistrationStatusPending is returned through the completionHandler:, this means that your user is not being connected to Sendbird server when the registerDevicePushToken:unique:completionHandler: is called. In this case, we recommend that you first get a pending device token by using the getPendingPushToken, and then register the token by invoking the registerDevicePushToken:unique:completionHandler: in a callback of the connectWithUserId:completionHandler: or connectWithUserId:accessToken:completionHandler: when your user has been connected to the server afterward.

Objective-C
Swift
Light Color Skin
Copy
[SBDMain connectWithUserId:USER_ID completionHandler:^(SBDUser * _Nullable user, SBDError * _Nullable error) {
    if (error == nil) {
        [SBDMain registerDevicePushToken:[SBDMain getPendingPushToken] unique:YES completionHandler:^(SBDPushTokenRegistrationStatus status, SBDError * _Nullable error) {

        }];
    }
}];
Light Color Skin
Copy
SBDMain.connect(withUserId: USER_ID, completionHandler: { (user, error) in 
    if error == nil {
        SBDMain.registerDevicePushToken(SBDMain.getPendingPushToken()!, unique: true, completionHandler: { (status, error) in

        })
    }
})

Make sure you call the following code in the appropriate place to receive permissions from your users.

Objective-C
Swift
Light Color Skin
Copy
if ([application respondsToSelector:@selector(registerUserNotificationSettings:)]) {
    UIUserNotificationSettings* notificationSettings = [UIUserNotificationSettings settingsForTypes:UIUserNotificationTypeAlert | UIUserNotificationTypeBadge | UIUserNotificationTypeSound categories:nil];
    [[UIApplication sharedApplication] registerUserNotificationSettings:notificationSettings];
    [[UIApplication sharedApplication] registerForRemoteNotifications];
} else {
    [[UIApplication sharedApplication] registerForRemoteNotificationTypes: (UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeSound | UIRemoteNotificationTypeAlert)];
}
Light Color Skin
Copy
let notificationSettings = UIUserNotificationSettings(types: [UIUserNotificationType.alert, UIUserNotificationType.badge, UIUserNotificationType.sound], categories: nil)
    UIApplication.shared.registerUserNotificationSettings(notificationSettings)
    UIApplication.shared.registerForRemoteNotifications()

Step 5: Handle a notification payload

Sendbird server sends notification requests to APNs with the following options:

OptionDescription

alert

{sender's nickname}: {text message}

sound

The default alert sound of iOS

badge

The total number of each user's unread messages. You can turn off this badge count from your dashboard.

The server also sends an additional JSON object with the sendbird key. For notification requests, APNs then delivers notifications to iOS devices. At the client side, you can parse the data payload and handle the result to implement user reactions within the application:didReceiveRemoteNotification:fetchCompletionHandler: method, which covers all notificationes from the application states of inactive, foreground, and background.

Objective-C
Swift
Light Color Skin
Copy
- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult result))completionHandler{

    NSString *alertMsg = [[userInfo objectForKey:@"aps"] objectForKey:@"alert"];
    NSDictionary *payload = [userInfo objectForKey:@"sendbird"];
    
    // Implement your custom way to parse payload
    if (application.applicationState == UIApplicationStateInactive) {
        // Receiving a notification while your app is inactive. 
    } else {
        // Receiving a notification while your app is in either foreground or background. 
    }   

    completionHandler(UIBackgroundFetchResultNewData);
}
Light Color Skin
Copy
func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    let alertMsg = (userInfo["aps"] as! NSDictionary)["alert"] as! NSDictionary
    let payload = userInfo["sendbird"] as! NSDictionary

    // Implement your custom way to parse payload
    if (application.applicationState == .inactive) {
        // Receiving a notification while your app is inactive. 
    } else {
        // Receiving a notification while your app is in either foreground or background. 
    }   
 
    completionHandler(UIBackgroundFetchResult.newData)
}

The following is a complete payload format of the sendbird object, which contains a set of provided key-value items.

Light Color Skin
Copy
{
    "category": "messaging:offline_notification",
    "type": string,                 // Message type: 'User', 'File', or 'Admin'
    "message": string,              // User input message
    "data": string,                 // Custom data field
    "custom_type": string,          // Custom message type
    "message_id": long,             // Message ID
    "created_at": long,             // 13-digit timestamp
    "app_id": string,               // Application's unique ID 
    "unread_message_count": int,    // Total unread count of the user
    "channel": {
        "channel_url": string,      // Group channel URL
        "name": string,             // Group channel name
        "custom_type": string       // Group channel custom_type
    },
    "channel_type": string,         // Channel type: 'messaging', 'group_messaging', or 'chat'
    "sender": {
        "id": string,               // Sender's unique ID
        "name": string,             // Sender's nickname
        "profile_url": string       // Sender's profile image URL 
    },
    "recipient": {
        "id": string,               // Recipient's unique ID
        "name": string              // Recipient's nickname
    },
    "files": [],                    // If a message is a file link, this array represents files.
    "translations": {},             // If a message has translations, this dict has locale:translation.
    "push_alert": string,           // A customized alert notification 
    "push_sound": string,           // The location of a sound file for notifications
    "audience_type": string,        // The type of audiences to receive notifications
    "mentioned_users": {
        "user_id": string,                      // The ID of a mentioned user
        "total_unread_mention_count": int,      // The number of messages which a user has been mentioned but has not read within the channels
        "channel_unread_mention_count": int,    // The number of channels with messages which a user has been mentioned but has not read
        "is_hidden": boolean                    // Whether or not a mentioned user has hidden the channel from the list
    }
}

Step 6: Enable multi-device support in the Dashboard

After the above implementation is completed, choose your push notification option depending on how much support for multi-device push your client app requires. Go to Settings > Application > Notifications > Push notifications for multi-device users in your dashboard.
Multi-device support

To find out which push notifications best suits your client app use cases, refer to the table below:

Send when all devices are offlineSend as long as one device is offline

Single-device user

Displayed when disconnected from the server and thus offline

Displayed when disconnected from the server and thus offline

Multi-device user

Displayed only when all devices are offline

Displayed on all offline devices, regardless of whether one or more are online

Note: For iOS client apps, no additional implementation is required to enable multi-device support. However, for Android client apps, additional implementation is required to enable multi-device support. To learn more, go to the Android's Multi-Device Support page.


Notification preferences

By registering or unregistering the current user's device token to Sendbird server like the following, you can turn push notifications on or off in the user's client app.

Note: The registration and unregistration methods in the code below should be called after a user has established a connection with Sendbird server via the connection methods such as connectionWithUserId:completionHandler: or connectionWithUserId:accessToken:completionHandler:.

Objective-C
Swift
Light Color Skin
Copy
- (void)setPushNotification:(BOOL)enable {
    if (enable) {
        [SBDMain registerDevicePushToken:[SBDMain getPendingPushToken] unique:YES completionHandler:^(SBDPushTokenRegistrationStatus status, SBDError * _Nullable error) {
            if (error != nil) { // Error.
                return;
            }
        }];
    }
    else {
        // If you want to unregister the current device only, invoke this method.
        [SBDMain unregisterPushToken:[SBDMain getPendingPushToken] completionHandler:^(NSDictionary * _Nullable response, SBDError * _Nullable error) {
            if (error != nil) { // Error.
                return;
            }
        }];

        // If you want to unregister the all devices of the user, invoke this method.
        [SBDMain unregisterAllPushTokenWithCompletionHandler:^(NSDictionary * _Nullable response, SBDError * _Nullable error) {
            if (error != nil) { // Error.
                return;
            }
        }];
    }
}
Light Color Skin
Copy
func setPushNotification(enable: Bool) {
    if enable {
        SBDMain.registerDevicePushToken(SBDMain.getPendingPushToken()!, unique: true, completionHandler: { (status, error) in
            guard error == nil else {   // Error.
                return
            }           
        })
    }
    else {
        // If you want to unregister the current device only, invoke this method.
        SBDMain.unregisterPushToken(SBDMain.getPendingPushToken()!, completionHandler: { (response, error) in
            guard error == nil else {   // Error.
                return
            }
        })

        // If you want to unregister the all devices of the user, invoke this method.
        SBDMain.unregisterAllPushToken(completionHandler: { (response, error) in
            guard error == nil else {   // Error.
                return
            }
        })
    }
}

The SBDPushTriggerOption allows users to configure when to receive notifications as well as what type of messages will trigger notifications. This provides the following three options:

OptionDescription

SBDPushTriggerOptionAll

When disconnected from Sendbird server, the current user receives notifications for all new messages including messages the user has been mentioned in.

SBDPushTriggerOptionMentionOnly

When disconnected from Sendbird server, the current user only receives notifications for messages the user has been mentioned in.

SBDPushTriggerOptionMentionOff

The current user doesn't receive any notifications.

Objective-C
Swift
Light Color Skin
Copy
// If you want to trigger notifications only when the current user is mentioned in messages.
[SBDMain setPushTriggerOption:SBDPushTriggerOptionMentionOnly completionHandler:^(SBDError * _Nullable error) {
    if (error != nil) { // Error.
        return; 
    }
}];
Light Color Skin
Copy
// If you want to trigger notifications only when the current user is mentioned in messages.
SBDMain.setPushTriggerOption(.mentionOnly, completionHandler: { (error) in
    if error != nil {   // Error.
        return
    }
})

The SBDGroupChannelPushTriggerOption also allows users to configure the trigger for notifications as well as turn notifications on or off for each channel. This provides the following three options:

OptionDescription

SBDPushTriggerOptionDefault

The current user’s push notification trigger settings are automatically applied to the channel. This is the default setting.

SBDPushTriggerOptionAll

When disconnected from Sendbird server, the current user receives notifications for all new messages in the channel including messages the user has been mentioned in.

SBDPushTriggerOptionMentionOnly

When disconnected from Sendbird server, the current user only receives notifications for messages in the channel the user has been mentioned in.

SBDPushTriggerOptionOff

The current user doesn't receive any notifications in the channel.

Objective-C
Swift
Light Color Skin
Copy
// If you want to automatically apply the user's push notification setting to the channel.
[channel setMyPushTriggerOption:SBDPushTriggerOptionDefault completionHandler:^(SBDError * _Nullable error) {
    if (error != nil) { // Error.
        return;
    }

    // If you want to turn off notifications for this channel, pass `NO` as an argument to a parameter. By default, they are turned on for a channel (YES).
    [channel setPushPreferenceWithPushOn:NO completionHandler:^(SBDError * _Nullable error) {
        if (error != nil) { // Error.
            return;
        }
    }];
}];
Light Color Skin
Copy
// If you want to automatically apply the user's push notification setting to the channel.
channel.setMyPushTriggerOption(.default, completionHandler: { (error) in
    guard error == nil else {   // Error.
        return
    }

    // If you want to turn off notifications for this channel, pass `false` as an argument to a parameter. By default, they are turned on for a channel (true).
    channel.setPushPreferenceWithPushOn(false, completionHandler: { (error) in
        guard error == nil else {   // Error.
            return
        }
    })
})

If you want to routinely turn off push notification on the current user's client app according to a specified schedule, use our Do Not Disturb feature like the following.

Note: Do Not Disturb can also be set for a user with our Chat Platform API's update push preferences action.

Objective-C
Swift
Light Color Skin
Copy
// The current user will not receive notifications during the specified time of every day.
[SBDMain setDoNotDisturbWithEnable:YES startHour:START_HOUR startMin:START_MIN endHour:END_HOUR endMin:END_MIN timezone:TIMEZONE completionHandler:^(SBDError * _Nullable error) {
    if (error != nil) { // Error.
        return;
    }
}];
Light Color Skin
Copy
// The current user will not receive notifications during the specified time of every day.
SBDMain.setDoNotDisturbWithEnable(true, startHour: START_HOUR, startMin: START_MIN, endHour: END_HOUR, endMin: END_MIN, timezone: TIMEZONE, completionHandler: { (error) in
    guard error == nil else {   // Error.
        return
    }    
})

To snooze notifications for specific period of time, use our snooze feature like the following.

Note: snooze can also be set for a user with our Chat Platform API's update push preferences action.

Objective-C
Swift
Light Color Skin
Copy
// The current user will not receive notifications during the specified period of time (from START_TS to END_TS).
[SBDMain setSnoozePeriodEnable:YES startTimestamp:START_TS endTimestamp:END_TS completionHandler:^(SBDError * _Nullable error) {
    if (error != nil) { // Error.
        return;
    }
}];
Light Color Skin
Copy
// The current user will not receive notifications during the specified period of time (from START_TS to END_TS).
SBDMain.setSnoozePeriodEnable(true, startTimestamp: START_TS, endTimestamp: END_TS, completionHandler: { (error) in
    guard error == nil else {   // Error.
        return
    }
})

Push notification content templates

Push notification content templates are pre-formatted forms that can be customized to display your own push notification messages on a user’s device. Sendbird provides two types: default and alternative. Both templates can be customized from your dashboard by going to Settings > Application > Notifications > Push notification content templates.

Content templates

There are two types of push notification content template: Default and Alternative. Default template is a template that applies to users with the initial notification message setting. Alternative template is used when a user selects a different notification content template instead of the default template.

The content in the template is set at the application level while the selection of templates is determined by a user or through Platform API.

Note: When a custom channel type has its own customized push notification content template, it takes precedence over the default or alternative templates.

Both templates can be customized using the variables of {sender_name}, {filename}, {message}, and {channel_name}, which represent the corresponding string values.

Refer to the following table for the usage of content templates:

Text messageFile message

Default template

{sender_name}: {message} (ex. Cindy: Bye!)

{filename} (ex. hello_world.jpg)

Alternative template

New message arrived

New file arrived

To apply a template to push notifications, use the setPushTemplateWithName:completionHandler: method. Specify the type of the template with the name as either SBD_PUSH_TEMPLATE_DEFAULT or SBD_PUSH_TEMPLATE_ALTERNATIVE.

Objective-C
Swift
Light Color Skin
Copy
[SBDMain setPushTemplateWithName:SBD_PUSH_TEMPLATE_ALTERNATIVE completionHandler:^(SBDError * _Nullable error) {
    if (error != nil) { // Error.
        return;
    }

    // Push template successfully set to SBD_PUSH_TEMPLATE_ALTERNATIVE.
}];
Light Color Skin
Copy
SBDMain.setPushTemplateWithName(SBD_PUSH_TEMPLATE_ALTERNATIVE, completionHandler: { (error) in
    guard error == nil else {   // Error.
        return
    }

    // Push template successfully set to SBD_PUSH_TEMPLATE_ALTERNATIVE.
})

You can check the current user's setting with getPushTemplateWithCompletionHandler: like the following:

Objective-C
Swift
Light Color Skin
Copy
[SBDMain getPushTemplateWithCompletionHandler:^(NSString * _Nullable name, SBDError * _Nullable error) {
    if (error != nil) { // Error.
        return;
    }

    if ([name isEqualToString:SBD_PUSH_TEMPLATE_DEFAULT]) {
        // Currently configured to use the default template.
    }
    else if ([name isEqualToString:SBD_PUSH_TEMPLATE_ALTERNATIVE]) {
        // Currently configured to use the alternative template.
    }
}];
Light Color Skin
Copy
SBDMain.getPushTemplate(completionHandler: { (name, error) in
    guard error == nil else {   // Error.
        return
    }

    if name == SBD_PUSH_TEMPLATE_DEFAULT {
        // Currently configured to use the default template.
    }
    else if name == SBD_PUSH_TEMPLATE_ALTERNATIVE {
        // Currently configured to use the alternative template.
    }
})

Push notification translation

Push notification translation allows your users to receive notifications in their preferred languages. Users can set up to four preferred languages. If messages are sent in one of those languages, the notifications won’t be translated. If messages are sent in a language other than the preferred languages, the notifications will be translated into the user's first preferred language. In addition, the messages translated into other preferred languages will be provided in the sendbird property of a notification payload.

Note: A specific user's preferred languages can be set with our Chat API's update a user action.

Using the updateCurrentUserInfoWithPreferredLanguages:completionHandler: method as follows, the current user's preferred languages can be set:

Objective-C
Swift
Light Color Skin
Copy
[SBDMain connectWithUserId:CURRENT_USER_ID completionHandler:^(SBDUser * _Nullable user, SBDError * _Nullable error) {
    if (error != nil) { // Error.
        return;
    }

    NSArray<NSString *> *preferredLanguages = @[@"fr", @"de", @"es", @"kr"];    // French, German, Spanish, and Korean
    
    [SBDMain updateCurrentUserInfoWithPreferredLanguages:preferredLanguages completionHandler:^(SBDError * _Nullable error) {
        if (error != nil) { // Error.
            return;
        }
        
        BOOL isUpdatedSuccessfully = YES;
    
        // The 'user' object below is the reference of the current user.    
        for (NSString *language in user.preferredLanguages) {   // The 'user.preferredLanguages' returns a list of the current user's preferred languages.
            if (![preferredLanguages containsObject:language]) {
                isUpdatedSuccessfully = NO;
                break;
            }   
        }

        if (isUpdatedSuccessfully == YES) {
            // The current user's preferred languages have been updated successfully.
        }
    }];
}];
Light Color Skin
Copy
SBDMain.connect(withUserId: USER_ID, completionHandler: { (user, error) in 
    guard error == nil else { // Error.
        return
    }

    let preferredLanguages = ["fr", "de", "es", "kr"] // French, German, Spanish, and Korean

    SBDMain.updateCurrentUserInfo(withPreferredLanguages: preferredLanguages, completionHandler: { error in
        guard error == nil else { // Error.
            return
        }

        var isUpdatedSuccessfully = true

        // The 'user' object below is the reference of the current user.
        for language in user.preferredLanguages {
            if !preferredLanguages.contains(language) {  // The 'user.preferredLanguages' returns a list of the current user's preferred languages.
                isUpdatedSuccessfully = false
                break
            }
        }

        if isUpdatedSuccessfully == true {
            // The current user's preferred languages have been updated successfully.
        }
    })
})

If successful, the following notification payload will be delivered to the current user's device.

Light Color Skin
Copy
{
    "aps": {
        "alert": "Bonjour comment allez vous",  // A notification is translated into the first language listed in the preferred languages.
        ...
    
    },
    "sendbird": {
        "category": "messaging:offline_notification",
        "type": "User",
        "message": "Hello, how are you?",
        ...
        
        "translations": {   // The translated messages in other preferred languages.
            "fr": "Bonjour comment allez vous",
            "de": "Hallo wie geht es dir",
            "es": "Hola como estas",
            "kr": "안녕하십니까?"
        },
        ...

    }
}