# Message channels (/en/realtime-media/rtm/build/work-with-channels/message-channel/ios)

> For AI agents: see the complete documentation index at [llms.txt](/llms.txt).

Signaling provides message channels for implementing publish-subscribe (pub/sub) messaging in your app. In a message channel, you subscribe to a channel to receive messages. However, you do not need to join the channel to publish messages. This page shows you how to use Signaling SDK pub/sub messaging to implement various communication model into your app.

    ## Understand the tech [#understand-the-tech-2]

    Pub/sub is the simplest form of messaging. Signaling creates a channel when a user subscribes to it. Your app listens for events which contain messages users publish to a channel.

    Signaling allows thousands of message channels to exist in your app at the same time. However, due to client-side performance and bandwidth limitations, a single client may only subscribe to a limited number of channels concurrently. For details, see [API usage restrictions](../../reference/limitations).

    ### Communication models in message channels [#communication-models-in-message-channels-2]

    Signaling SDK enables you to implement a variety of communication models using message channels. A communication model refers to the data flow relationship between the message sender and receiver within a channel. Using the pub/sub message distribution mechanism, you can seamlessly implement the following communication models:

    * **1-to-1 channel**: This model facilitates communication between two users. It is ideal for creating private chat channels, one-on-one customer service support, and personal interactions.

    * **Group channel**: A group channel facilitates many-to-many communication, making user groups within the channel visible to each other. This model is suitable for workgroups, family discussions, and community interactions. Access control options in Signaling SDK enable you to implement open or invitation-based participation.

    * **Broadcast channel**: A broadcast channel enables one-to-many communication, where a single sender broadcasts messages to multiple recipients. This model is useful for group announcements, surveys, and disseminating information to a large audience.

    * **Unicast channel**: This model allows many users to send messages to a single recipient. This model is beneficial for use-cases such as questionnaire feedback collection, IoT sensor data aggregation, and centralized data collection.

    ## Prerequisites [#prerequisites-2]

    Ensure that you have integrated the Signaling SDK in your project and implemented the framework functionality from the [SDK quickstart](../../quickstart) page.

    ## Implement message channels [#implement-message-channels-2]

    This section shows you how to subscribe, unsubscribe, and send messages to a message channel.

    ### Subscribe to a channel [#subscribe-to-a-channel-2]

    <Tabs defaultValue="swift" groupId="language">
      <TabsList>
        <TabsTrigger value="swift">
          Swift
        </TabsTrigger>

        <TabsTrigger value="objc">
          Objective-C
        </TabsTrigger>
      </TabsList>

      <TabsContent value="swift">
        Use the `subscribe` method to subscribe to a message channel. After you subscribe, you receive `didReceiveMessageEvent` and other event notifications for the channel.

        ```swift
        rtm?.subscribe(channelName: channel, option: nil, completion: { res, error in
            if error != nil {
                print("\\(error?.operation) failed! error reason is \\(error?.reason)")
            } else {
                print("success")
            }
        })
        ```
      </TabsContent>

      <TabsContent value="objc">
        Use the `subscribeWithChannel` method to subscribe to a message channel. After you subscribe, you receive `didReceiveMessageEvent` and other event notifications for the channel.

        ```objc
        [rtm subscribeWithChannel:@"you_channel" option:nil completion:^(AgoraRtmCommonResponse * _Nullable response, AgoraRtmErrorInfo * _Nullable errorInfo) {
            if (errorInfo == nil) {
                NSLog(@"subscribe success!!");
            } else {
                NSLog(@"subscribe failed, errorCode %d, reason %@", errorInfo.errorCode, errorInfo.reason);
            }
        }];
        ```
      </TabsContent>
    </Tabs>

    <Tabs defaultValue="swift" groupId="language">
      <TabsList>
        <TabsTrigger value="swift">
          Swift
        </TabsTrigger>

        <TabsTrigger value="objc">
          Objective-C
        </TabsTrigger>
      </TabsList>

      <TabsContent value="swift">
        To subscribe to multiple channels, call `subscribe` multiple times:

        ```swift
        rtm?.subscribe(channelName: channel1, option: nil, completion: { res, error in
            if error != nil {
                print("\\(error?.operation) failed! error reason is \\(error?.reason)")
            } else {
                print("success")
            }
        })

        rtm?.subscribe(channelName: channel2, option: nil, completion: { res, error in
            if error != nil {
                print("\\(error?.operation) failed! error reason is \\(error?.reason)")
            } else {
                print("success")
            }
        })
        ```
      </TabsContent>

      <TabsContent value="objc">
        To subscribe to multiple channels, call `subscribeWithChannel` multiple times:

        ```objc
        [rtm subscribeWithChannel:@"chats.room1" option:nil completion:^(AgoraRtmCommonResponse * _Nullable response, AgoraRtmErrorInfo * _Nullable errorInfo) {
            if (errorInfo == nil) {
                NSLog(@"subscribe success!!");
            } else {
                NSLog(@"subscribe failed, errorCode %d, reason %@", errorInfo.errorCode, errorInfo.reason);
            }
        }];

        [rtm subscribeWithChannel:@"chats.room2" option:nil completion:^(AgoraRtmCommonResponse * _Nullable response, AgoraRtmErrorInfo * _Nullable errorInfo) {
            if (errorInfo == nil) {
                NSLog(@"subscribe success!!");
            } else {
                NSLog(@"subscribe failed, errorCode %d, reason %@", errorInfo.errorCode, errorInfo.reason);
            }
        }];
        ```
      </TabsContent>
    </Tabs>

    <CalloutContainer type="info">
      <CalloutDescription>
        Signaling allows a single client to subscribe to up to 50 message channels simultaneously. However, to optimize client performance and bandwidth usage, best practice is to limit subscriptions to 30 channels. If you have very large or highly active channels, consider further reducing the number of simultaneous subscriptions.
      </CalloutDescription>
    </CalloutContainer>

    ### Send a message [#send-a-message-2]

    To send messages in a message channel, simply call the `publish` method without subscribing to the channel. This method sends messages to one channel at a time. To send messages to multiple channels, call this method multiple times. Signaling SDK does not limit the number of channels to which you can send messages, or the number of users who can send messages to a channel. However, there are certain restrictions on the frequency at which you can send messages to a channel simultaneously. See [API usage restrictions](../../reference/limitations) for details.

    <CalloutContainer type="info">
      <CalloutTitle>
        Info
      </CalloutTitle>

      <CalloutDescription>
        The `publish` method can only be used with a message channel and a user channel; it does not apply to a stream channel.
      </CalloutDescription>
    </CalloutContainer>

    Refer to the following sample code for sending messages:

    * String message:

    <CodeBlockTabs defaultValue="Swift">
      <CodeBlockTabsList>
        <CodeBlockTabsTrigger value="Swift">
          Swift
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Objective-C">
          Objective-C
        </CodeBlockTabsTrigger>
      </CodeBlockTabsList>

      <CodeBlockTab value="Swift">
        ```swift
        let message = "Hello Agora!"
            let channel = "your_channel"

            rtm.publish(channelName: channel, message: message, option: nil, completion: { res, error in
                if error != nil {
                    print("\\(error?.operation) failed! error reason is \\(error?.reason)")
                } else {
                    print("success")
                }
            })
        ```
      </CodeBlockTab>

      <CodeBlockTab value="Objective-C">
        ```objc
        NSString* message = @"Hello Agora!";
            NSString* channel = @"your_channel";
            AgoraRtmPublishOptions* publish_option = [[AgoraRtmPublishOptions alloc] init];
            publish_option.storeInHistory = YES;
            [rtm publish:channel message:message option:publish_option completion:^(AgoraRtmCommonResponse * _Nullable response, AgoraRtmErrorInfo * _Nullable errorInfo) {
                if (errorInfo == nil) {
                    NSLog(@"publish success!!");
                } else {
                    NSLog(@"publish failed, errorCode %d, reason %@", errorInfo.errorCode, errorInfo.reason);
                }
            }];
        ```
      </CodeBlockTab>
    </CodeBlockTabs>

    * Binary message:

    <CodeBlockTabs defaultValue="Swift">
      <CodeBlockTabsList>
        <CodeBlockTabsTrigger value="Swift">
          Swift
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Objective-C">
          Objective-C
        </CodeBlockTabsTrigger>
      </CodeBlockTabsList>

      <CodeBlockTab value="Swift">
        ```swift
        let byteArray: [UInt8] = [0x48, 0x65, 0x6C, 0x6C, 0x6F] // Represents the string "Hello"
            let myDataFromBytes = Data(byteArray)
            let channel = "your_channel"

            // Publish the binary data to the specified channel
            rtm.publish(channelName: channel, data: myDataFromBytes, option: nil, completion: { res, error in
                if error != nil {
                    print("\\(error?.operation) failed! error reason is \\(error?.reason)")
                } else {
                    print("success")
                }
            })
        ```
      </CodeBlockTab>

      <CodeBlockTab value="Objective-C">
        ```objc
        unsigned char byte_array[5] = {0,1,2,3,4};
            NSData* raw_message = [[NSData alloc] initWithBytes:byte_array length:5];
            NSString* channel = @"your_channel";
            AgoraRtmPublishOptions* publish_option = [[AgoraRtmPublishOptions alloc] init];
            publish_option.storeInHistory = YES;
            [rtm publish:channel data:raw_message option:nil completion:^(AgoraRtmCommonResponse * _Nullable response, AgoraRtmErrorInfo * _Nullable errorInfo) {
                if (errorInfo == nil) {
                    NSLog(@"publish success!!");
                } else {
                    NSLog(@"publish failed, errorCode %d, reason %@", errorInfo.errorCode, errorInfo.reason);
                }
            }];
        ```
      </CodeBlockTab>
    </CodeBlockTabs>

    <CalloutContainer type="info">
      <CalloutDescription>
        Signaling currently supports only string and binary message formats. To send other types of data such as a JSON objects, or data from third-party data construction tools such as protobuf, serialize the data before sending the message. For information on how to effectively construct the payload data structure and recommended serialization methods, refer to [Message payload structuring](../send-and-receive-messages/message-payload-structuring).
      </CalloutDescription>
    </CalloutContainer>

    ### Customize channel subscription [#customize-channel-subscription-2]

    <Tabs defaultValue="swift" groupId="language">
      <TabsList>
        <TabsTrigger value="swift">
          Swift
        </TabsTrigger>

        <TabsTrigger value="objc">
          Objective-C
        </TabsTrigger>
      </TabsList>

      <TabsContent value="swift">
        By default, you receive message events for all channels you subscribe to. If you do not wish to receive messages from specific channels, while still receiving other types of event notifications from these channels, avoid including `message` when setting the `features` parameter. Refer to the following code example:

        ```swift
        let option = AgoraRtmSubscribeOptions();
        option.features = [.presence, .metadata, .lock]
        rtm?.subscribe(channelName: channel, option: option, completion: { res, error in
                if error != nil {
                    print("\\(error?.operation) failed! error reason is \\(error?.reason)")
                } else {
                    print("success")
                }
            })
        ```
      </TabsContent>

      <TabsContent value="objc">
        By default, you receive message events for all channels you subscribe to. If you don't wish to receive messages from specific channels, while still receiving other types of event notifications from these channels, avoid setting the `features` parameter to include `AgoraRtmSubscribeChannelFeatureMessage`. Refer to the following code example:

        ```objc
        AgoraRtmSubscribeOptions* opt = [[AgoraRtmSubscribeOptions alloc] init];
        opt.features = AgoraRtmSubscribeChannelFeaturePresence;

        [rtm subscribeWithChannel:@"you_channel" option:opt completion:^(AgoraRtmCommonResponse * _Nullable response, AgoraRtmErrorInfo * _Nullable errorInfo) {
            if (errorInfo == nil) {
                NSLog(@"subscribe success!!");
            } else {
                NSLog(@"subscribe failed, errorCode %d, reason %@", errorInfo.errorCode, errorInfo.reason);
            }
        }];
        ```
      </TabsContent>
    </Tabs>

    ### Unsubscribe from a channel [#unsubscribe-from-a-channel-2]

    <Tabs defaultValue="swift" groupId="language">
      <TabsList>
        <TabsTrigger value="swift">
          Swift
        </TabsTrigger>

        <TabsTrigger value="objc">
          Objective-C
        </TabsTrigger>
      </TabsList>

      <TabsContent value="swift">
        To stop receiving messages and other event notifications from a channel, call `unsubscribe`.

        ```swift
        RtmClient?.unsubscribe(channel) { res, error in
            if error != nil {
                print("\\(error?.operation) failed! error reason is \\(error?.reason)")
            } else {
                print("success")
            }
        }
        ```
      </TabsContent>

      <TabsContent value="objc">
        To stop receiving messages and other event notifications from a channel, call `unsubscribeWithChannel`.

        ```objc
        [rtm unsubscribeWithChannel:@"chats.room1" completion:^(AgoraRtmCommonResponse * _Nullable response, AgoraRtmErrorInfo * _Nullable errorInfo) {
            if (errorInfo == nil) {
                NSLog(@"unsubscribe success!!");
            } else {
                NSLog(@"unsubscribe failed, errorCode %d, reason %@", errorInfo.errorCode, errorInfo.reason);
            }
        }];
        ```
      </TabsContent>
    </Tabs>

    This method only unsubscribes from one channel at a time. To unsubscribe from multiple channels, call this method for each channel.

    ## Reference [#reference-2]

    This section contains content that completes the information on this page, or points you to documentation that explains other aspects to this product.

    ### Message payload size [#message-payload-size-2]

    Signaling SDK imposes limits on the size of the message payload sent in message channels and stream channels. The limit is 32 KB for message channels and 1 KB for stream channels. The message payload size includes the message payload itself plus the size of the `customType` field. If the message payload package size exceeds the limit, you receive an error message.

    <CodeBlockTabs defaultValue="Swift">
      <CodeBlockTabsList>
        <CodeBlockTabsTrigger value="Swift">
          Swift
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Objective-C">
          Objective-C
        </CodeBlockTabsTrigger>
      </CodeBlockTabsList>

      <CodeBlockTab value="Swift">
        ```objc
        // errorInfo
        {
            errorInfo.errorCode = rrorCode = .channelMessageLengthExceedLimitation
            errorInfo.reason = "Publish too long message."
            errorInfo.operation = "publish"; // or "publishTopicMessage
        }
        ```
      </CodeBlockTab>

      <CodeBlockTab value="Objective-C">
        ```objc
        // errorInfo
        {
            errorInfo.errorCode = AgoraRtmErrorChannelMessageLengthExceedLimitation;
            errorInfo.reason = @"Publish too long message.";
            errorInfo.Operation = @"publish"; // or "publishTopicMessage"
        }
        ```
      </CodeBlockTab>
    </CodeBlockTabs>

    To avoid sending failure due to message payload size exceeding the limit, check the size before sending.

    ### API reference [#api-reference-2]

    <Tabs defaultValue="swift" groupId="language">
      <TabsList>
        <TabsTrigger value="swift">
          Swift
        </TabsTrigger>

        <TabsTrigger value="objc">
          Objective-C
        </TabsTrigger>
      </TabsList>

      <TabsContent value="swift">
        * [`subscribe`](/en/api-reference/api-ref/signaling?platform=ios\&tab=swift#channelsubscribepropsag_platform)
        * [`unsubscribe`](/en/api-reference/api-ref/signaling?platform=ios\&tab=swift#channelunsubscribepropsag_platform)
        * [`publish`](/en/api-reference/api-ref/signaling?platform=ios\&tab=swift#messagepublishpropsag_platform)
      </TabsContent>

      <TabsContent value="objc">
        * [`subscribeWithChannel`](/en/api-reference/api-ref/signaling?platform=ios\&tab=objc#channelsubscribepropsag_platform)
        * [`unsubscribeWithChannel`](/en/api-reference/api-ref/signaling?platform=ios\&tab=objc#channelunsubscribepropsag_platform)
        * [`publish`](/en/api-reference/api-ref/signaling?platform=ios\&tab=objc#messagepublishpropsag_platform)
      </TabsContent>
    </Tabs>