Channel Basics

A channel is a communication pathway for passing data between devices with PubNub.

Channels are hosted on PubNub. You interact with channels using PubNub SDKs (Software Development Kit, SDK) or the REST API (Representational State Transfer, REST).

Pub/sub enables efficient, asynchronous message processing. Your app can deliver real-time updates while components work independently. For example, in chat, messaging, notifications, and analytics can each communicate through channels to keep the design modular and scalable.

We are fast

Devices listening on a channel typically receive messages in about 30 ms, enabling swift global communication.

Channel creation

You don’t create channels in advance. PubNub creates a channel the first time you publish to it.

Channel entity

PubNub SDKs provide local Channel entities to help you work with channels. These objects hide channel-management details and support clean patterns, such as decoupling app components for maintainability.

For more information, refer to Entities.

Channel limits

There’s no limit on the number of channels or users per channel. A device can listen to thousands of channels over a single connection, which supports large-scale communication.

Channel types

Channels represent places where messages are sent and received. Use direct channels for one-to-one private messaging and group channels for many-to-many conversations. Broadcast and unicast channels fit one‑to‑many and many‑to‑one use cases.

Here are some useful channel configurations:

Direct channels for one-to-one in-app messaging between two users. You can make these channels private to keep the messages secure between the users.

1const PubNub = require('pubnub');
2

3// Initialize the PubNub client with your publish and subscribe keys
4const pubnub = new PubNub({
5  publishKey: 'yourPublishKey',
6  subscribeKey: 'yourSubscribeKey',
7  userId: 'user1-unique-id', // Use unique user IDs for authentication
8  authKey: 'user1AuthKey',   // Use an authentication key for security
9  ssl: true                  // Enable SSL for secure communication
10});
11

12// Define the direct channel for one-to-one messaging between two specific users
13const directChannel = 'direct.user1.user2'; // Example channel name
14

15// Subscribe to the direct channel
16const channel = pubnub.channel(directChannel);
17const subscription = channel.subscription();
18

19// Add event listeners for messages and presence
20subscription.onMessage = (messageEvent) => {
21  console.log('Received message:', messageEvent.message);
22};
23

24subscription.onPresence = (presenceEvent) => {
25  console.log('Presence event:', presenceEvent);
26};
27

28// Subscribe to the channel
29subscription.subscribe();
30

31// Function to send a message to the direct channel
32async function sendMessage(message) {
33  return pubnub.publish({
34    channel: directChannel,
35    message: { text: message },
36    meta: { sender: 'user1' },         // Add meta to store sender info
37    storeInHistory: true,              // Store messages in history
38    customMessageType: "text-message", // Label the message type
39  });
40}
41// Example: sending a message
42sendMessage('Hello, user2!')
43  .then((result) => {
44    console.log('Message sent successfully');
45  })
46  .catch((error) => {
47    console.error('Error sending message:', error);
48  }) ;
show all 48 lines

1import PubNub
2

3// Initialize the PubNub client with your publish and subscribe keys
4let config = PubNubConfiguration(
5  publishKey: "yourPublishKey",
6  subscribeKey: "yourSubscribeKey",
7  userId: "user1-unique-id" // Unique ID for the user
8)
9let pubnub = PubNub(configuration: config)
10

11// Define the direct channel for one-to-one messaging
12let directChannel = "direct.user1.user2"
13

14// Subscribe to the direct channel
15let subscription = pubnub.channel(directChannel).subscription()
16

17// Add event listeners for messages
18subscription.onMessage = { message in
19  print("Received message: \(message.payload)")
20}
21

22// Subscribe to the channel
23subscription.subscribe()
24

25// Function to send a message to the direct channel
26func sendMessage(_ text: String) {
27  pubnub.publish(
28    channel: directChannel,
29    message: ["text": text],
30    customMessageType: "text-message"
31  ) { result in
32    switch result {
33    case .success:
34      print("Message sent successfully")
35    case let .failure(error):
36      print("Error sending message: \(error.localizedDescription)")
37    }
38  }
39}
40

41// Send a message to another user
42sendMessage("Hello from user1!")
show all 42 lines

1#import <PubNub/PubNub.h>
2

3@interface AppDelegate () <PNEventsListener>
4@property (nonatomic, strong) PubNub *client;
5@end
6

7@implementation AppDelegate
8

9- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
10

11    PNConfiguration *configuration = [PNConfiguration configurationWithPublishKey:@"yourPublishKey" subscribeKey:@"yourSubscribeKey"];
12

13    configuration.uuid = @"user1-unique-id"; // Unique ID for the user
14

15    self.client = [PubNub clientWithConfiguration:configuration];
16    [self.client addListener:self];
17

18    // Define the direct channel for one-to-one messaging
19    NSString *directChannel = @"direct.user1.user2";
20

21    // Subscribe to the direct channel
22    [self.client subscribeToChannels:@[directChannel] withPresence:NO];
23

24    return YES;
25}
26

27- (void)client:(PubNub *)client didReceiveMessage:(PNMessageResult *)message {
28    NSLog(@"Received message: %@ on channel %@", message.data.message, message.data.channel);
29}
30

31// Function to send a message to the direct channel
32- (void)sendMessage:(NSString *)text {
33    PNPublishRequest *request = [PNPublishRequest requestWithChannel:@"direct.user1.user2"];
34    request.message = @{@"text": text};
35    request.customMessageType = @"text-message";
36    [self.client publishWithRequest:request completion:^(PNPublishStatus *status) {
37        if (!status.isError) {
38            NSLog(@"Message sent successfully");
39        } else {
40            NSLog(@"Error sending message: %@", status.errorData.information);
41        }
42    }];
43}
44

45@end
show all 45 lines

1import com.google.gson.JsonObject
2import com.pubnub.api.PubNub
3import com.pubnub.api.UserId
4import com.pubnub.api.models.consumer.pubsub.PNMessageResult
5import com.pubnub.api.v2.PNConfiguration
6import com.pubnub.api.v2.callbacks.EventListener
7

8

9fun main() {
  val config = PNConfiguration.builder(UserId("user1-unique-id"), "yourSubscribeKey").apply {
      publishKey = "yourPublishKey"
  }
  val pubnub = PubNub.create(config.build())
  val directChannelName = "direct.user1.user2"
15

  // Create Subscription
  val channel = pubnub.channel(directChannelName)
  val subscription = channel.subscription()
19

  // Add Listeners
  subscription.addListener(object : EventListener {
      override fun message(pubnub: PubNub, result: PNMessageResult) {
          println("Received message: ${result.message.asJsonObject}")
      }
  })
  // Subscribe to the channel
  subscription.subscribe()
  // Function to send a message to the direct channel
  fun sendMessage(message: String) {
      val messageObject = JsonObject().apply {
          addProperty("text", message)
          addProperty("sender", "user1")
      }
      channel.publish(messageObject).async { result ->
          result.onFailure { exception ->
              println("Error sending message: ${exception.message}")
          }.onSuccess { value ->
              println("Message sent successfully with timetoken: ${value.timetoken}")
          }
      }
  }
  // Example: sending a message
  sendMessage("Hello, user2!")
44}
show all 44 lines

1using PubnubApi;
2

3class Program
4{
  static void Main(string[] args)
  {
      PNConfiguration pnConfiguration = new PNConfiguration(new UserId("user1-unique-id"))
      {
          SubscribeKey = "yourSubscribeKey",
          PublishKey = "yourPublishKey"
      };
      Pubnub pubnub = new Pubnub(pnConfiguration);
13

      string directChannelName = "direct.user1.user2";
      Subscription subscription = pubnub.Channel(directChannelName).Subscription();
16

      subscription.AddListener(new SubscribeCallbackExt(
          (pn, messageEvent) =>
          {
              if (messageEvent != null)
              {
                  Console.WriteLine($"Received message: {messageEvent.Message}");
              }
          },
          (pn, presenceEvent) =>
          {
              if (presenceEvent != null)
              {
                  Console.WriteLine(
                      $"Presence event: {presenceEvent.Channel} {presenceEvent.Occupancy} {presenceEvent.Event}");
              }
          }
      ));
34

      subscription.Subscribe<object>();
36

      // Function to send a message to the direct channel
      void SendMessage(string message)
      {
          var userMessage = new Dictionary<string, string> { { "text", message }, { "sender", "user1" } };
          pubnub.Publish()
              .Channel(directChannelName)
              .Message(userMessage)
              .Execute(new PNPublishResultExt(
                  (result, status) =>
                  {
                      Console.WriteLine(!status.Error
                          ? $"Message sent, time-token: {result.Timetoken}"
                          : $"Error sending message: {status.ErrorData.Information}");
                  }
              ));
      }
53

      SendMessage("Hello, user2!");
  }
56}
show all 56 lines

1from pubnub.pnconfiguration import PNConfiguration
2from pubnub.pubnub import PubNub
3from pubnub.callbacks import SubscribeCallback
4

5# Configuration setup
6config = PNConfiguration()
7config.subscribe_key = 'yourSubscribeKey'
8config.publish_key = 'yourPublishKey'
9config.user_id = 'user1-unique-id'
10pubnub = PubNub(config)
11

12# Listener Setup
13class MySubscribeCallback(SubscribeCallback):
14    def message(self, pubnub, message):
15        print(f"Received message: {message.message}")
16

17    def presence(self, pubnub, presence):
18        print(f"Presence event: {presence.event}")
19

20    def status(self, pubnub, status):
21        print(f"Status: {status.category}")
22

23pubnub.add_listener(MySubscribeCallback())
24

25# Setup direct channel and subscribe
26direct_channel = pubnub.channel("direct.user1.user2").subscription()
27direct_channel.subscribe()
28

29# Publish message to direct channel
30def send_message(message):
31    pubnub.publish().channel("direct.user1.user2").message({"text": message}).sync()
32

33send_message("Hello, user2!")
show all 33 lines

Group channels serve as a collective category for many-to-many in-app messaging among multiple users, forming a community communication system, such as a chat room for friends or family.

1const PubNub = require('pubnub');
2

3// Initialize the PubNub client with your publish and subscribe keys
4const pubnub = new PubNub({
5  publishKey: 'yourPublishKey',
6  subscribeKey: 'yourSubscribeKey',
7  userId: 'user1-unique-id', // Use unique user IDs for authentication
8  authKey: 'user1AuthKey',   // Use an authentication key for security if necessary
9  ssl: true                  // Enable SSL for secure communication
10});
11

12// Define the group channel for in-app messaging
13const groupChannel = 'group.family'; // Example channel name for a family group
14

15// Subscribe to the group channel
16const channel = pubnub.channel(groupChannel);
17const subscription = channel.subscription();
18

19// Add event listeners for messages and presence
20subscription.onMessage = (messageEvent) => {
21  console.log('Received message:', messageEvent.message);
22};
23

24subscription.onPresence = (presenceEvent) => {
25  console.log('Presence event:', presenceEvent);
26};
27

28// Subscribe to the channel
29subscription.subscribe();
30

31// Function to send a message to the group channel
32async function sendMessage(message) {
33  try {
34    await pubnub.publish({
35      channel: groupChannel,
36      message: { text: message },
37      meta: { sender: 'user1' },     // Add meta to store sender info
38      storeInHistory: true,          // Store messages in history
39      customMessageType: "text-message", // Label the message type
40    });
41    console.log('Message sent successfully');
42  } catch (error) {
43    console.error('Error sending message:', error);
44  }
45}
46

47// Example: sending a message
48sendMessage('Hello, family group!');
49

50// Optional: manage access (only required if making the group private)
51function manageAccess() {
52  pubnub.grant({
53    channels: [groupChannel],
54    authKeys: ['user1AuthKey', 'user2AuthKey', 'user3AuthKey'], // Auth keys for allowed users
55    read: true,
56    write: true,
57    ttl: 60          // Time-to-live for the grant in minutes
58  }, (status) => {
59    if (status.error) {
60      console.error('Error managing access:', status);
61    } else {
62      console.log('Access managed successfully');
63    }
64  });
65}
66

67// Call this function if you want to restrict the channel to certain users
68manageAccess();
show all 68 lines

1import PubNub
2

3// Initialize the PubNub client with your publish and subscribe keys
4let config = PubNubConfiguration(
5  publishKey: "yourPublishKey",
6  subscribeKey: "yourSubscribeKey",
7  userId: "user1-unique-id" // Unique ID for the user
8)
9let pubnub = PubNub(configuration: config)
10

11// Define the group channel for many-to-many messaging
12let groupChannel = "group.family"
13

14// Subscribe to the group channel
15let subscription = pubnub.channel(groupChannel).subscription()
16

17// Add event listeners for messages
18subscription.onMessage = { message in
19  print("Received message: \(message.payload)")
20}
21

22// Subscribe to the channel
23subscription.subscribe()
24

25// Function to send a message to the group channel
26func sendMessage(_ text: String) {
27  pubnub.publish(
28    channel: groupChannel,
29    message: ["text": text],
30    customMessageType: "text-message"
31  ) { result in
32    switch result {
33    case .success:
34      print("Message sent successfully")
35    case let .failure(error):
36      print("Error sending message: \(error.localizedDescription)")
37    }
38  }
39}
40

41// Send a message to the group
42sendMessage("Hello family group!")
show all 42 lines

1#import <PubNub/PubNub.h>
2

3@interface AppDelegate () <PNEventsListener>
4@property (nonatomic, strong) PubNub *client;
5@end
6

7@implementation AppDelegate
8

9- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
10

11    PNConfiguration *configuration = [PNConfiguration configurationWithPublishKey:@"yourPublishKey" subscribeKey:@"yourSubscribeKey"];
12

13    configuration.uuid = @"user1-unique-id"; // Unique ID for the user
14

15    self.client = [PubNub clientWithConfiguration:configuration];
16    [self.client addListener:self];
17

18    // Define the group channel for many-to-many messaging
19    NSString *groupChannel = @"group.family";
20

21    // Subscribe to the group channel
22    [self.client subscribeToChannels:@[groupChannel] withPresence:YES];
23

24    return YES;
25}
26

27- (void)client:(PubNub *)client didReceiveMessage:(PNMessageResult *)message {
28    NSLog(@"Received message: %@ on channel %@", message.data.message, message.data.channel);
29}
30

31// Function to send a message to the group channel
32- (void)sendMessage:(NSString *)text {
33    [self.client publish:@{@"text": text} toChannel:@"group.family"
34               withCompletion:^(PNPublishStatus *status) {
35        if (!status.isError) {
36            NSLog(@"Message sent successfully");
37        } else {
38            NSLog(@"Error sending message: %@", status.errorData.information);
39        }
40    }];
41}
42

43@end
show all 43 lines

1import com.google.gson.JsonObject
2import com.pubnub.api.PubNub
3import com.pubnub.api.UserId
4import com.pubnub.api.models.consumer.pubsub.PNMessageResult
5import com.pubnub.api.v2.PNConfiguration
6import com.pubnub.api.v2.callbacks.EventListener
7

8fun main() {
  val config = PNConfiguration.builder(UserId("user1-unique-id"), "yourSubscribeKey").apply {
      publishKey = "yourPublishKey"
  }
  val pubnub = PubNub.create(config.build())
  val groupChannelName = "group.family"
  // Create Subscription
  val channel = pubnub.channel(groupChannelName)
  val subscription = channel.subscription()
  // Add Listeners
  subscription.addListener(object : EventListener {
      override fun message(pubnub: PubNub, result: PNMessageResult) {
          println("Received message: ${result.message.asJsonObject}")
      }
  })
  // Subscribe to the channel
  subscription.subscribe()
  // Function to send a message to the group channel
  fun sendMessage(message: String) {
      val messageObject = JsonObject().apply {
          addProperty("text", message)
          addProperty("sender", "user1")
      }
      channel.publish(messageObject).async { result ->
          result.onFailure { exception ->
              println("Error sending message: ${exception.message}")
          }.onSuccess { value ->
              println("Message sent successfully with timetoken: ${value.timetoken}")
          }
      }
  }
  // Example: sending a message
  sendMessage("Hello, family group!")
41}
show all 41 lines

1using PubnubApi;
2using System;
3using System.Collections.Generic;
4

5class Program
6{
  static void Main(string[] args)
  {
      PNConfiguration pnConfiguration = new PNConfiguration(new UserId("user1-unique-id"));
      pnConfiguration.SubscribeKey = "yourSubscribeKey";
      pnConfiguration.PublishKey = "yourPublishKey";
      Pubnub pubnub = new Pubnub(pnConfiguration);
13

      string groupChannelName = "group.family";
      Subscription subscription = pubnub.Channel(groupChannelName).Subscription();
16

      subscription.AddListener(new SubscribeCallbackExt(
          (pnObj, pubMsg) => {
              if (pubMsg != null)
              {
                  Console.WriteLine("Received message: " + pubMsg.Message);
              }
          },
          (pnObj, presenceEvnt) => {
              if (presenceEvnt != null)
              {
                  Console.WriteLine($"Presence event: {presenceEvnt.Channel} {presenceEvnt.Occupancy} {presenceEvnt.Event}");
              }
          }
      ));
31

      subscription.Subscribe<object>();
33

      // Function to send a message to the group channel
      void SendMessage(string message)
      {
          var msg = new Dictionary<string, string> { { "text", message }, { "sender", "user1" } };
          pubnub.Publish()
                .Channel(groupChannelName)
                .Message(msg)
                .Execute(new PNPublishResultExt(
                    (result, status) => {
                        if (!status.Error)
                        {
                            Console.WriteLine(string.Format("Message sent, timetoken: {0}", result.Timetoken));
                        }
                        else
                        {
                            Console.WriteLine("Error sending message: " + status.ErrorData.Information);
                        }
                    }
                ));
      }
54

      SendMessage("Hello, family group!");
  }
57}
show all 57 lines

1from pubnub.pnconfiguration import PNConfiguration
2from pubnub.pubnub import PubNub
3from pubnub.callbacks import SubscribeCallback
4

5# Configuration setup
6config = PNConfiguration()
7config.subscribe_key = 'yourSubscribeKey'
8config.publish_key = 'yourPublishKey'
9config.user_id = 'user1-unique-id'
10pubnub = PubNub(config)
11

12# Listener Setup
13class MySubscribeCallback(SubscribeCallback):
14    def message(self, pubnub, message):
15        print(f"Received message: {message.message}")
16

17    def presence(self, pubnub, presence):
18        print(f"Presence event: {presence.event}")
19

20    def status(self, pubnub, status):
21        print(f"Status: {status.category}")
22

23pubnub.add_listener(MySubscribeCallback())
24

25# Setup group channel and subscribe
26group_channel = pubnub.channel("group.family").subscription()
27group_channel.subscribe()
28

29# Publish message to group channel
30def send_message(message):
31    pubnub.publish().channel("group.family").message({"text": message}).sync()
32

33send_message("Hello, family group!")
show all 33 lines

Broadcast channels for announcements, polls, and other situations in which you want to broadcast messages in a one-to-many arrangement.

1const PubNub = require('pubnub');
2

3// Initialize the PubNub client with your publish and subscribe keys
4const pubnub = new PubNub({
5  publishKey: 'yourPublishKey',
6  subscribeKey: 'yourSubscribeKey',
7  userId: 'broadcaster-unique-id', // Use a unique ID for the broadcaster
8  ssl: true                        // Enable SSL for secure communication
9});
10

11// Define the broadcast channel for one-to-many communication
12const broadcastChannel = 'broadcast.announcements'; // Example channel for announcements
13

14// Subscribe to the broadcast channel
15const channel = pubnub.channel(broadcastChannel);
16const subscription = channel.subscription();
17

18// Add an event listener for messages
19subscription.onMessage = (messageEvent) => {
20  console.log('Received broadcast message:', messageEvent.message);
21};
22

23// Subscribe to the channel
24subscription.subscribe();
25

26// Function to send a broadcast message to the broadcast channel
27async function sendBroadcastMessage(message) {
28  try {
29    await pubnub.publish({
30      channel: broadcastChannel,
31      message: { text: message },
32      storeInHistory: false,            // Typically, broadcasts do not need to be stored
33      customMessageType: "broadcast",   // Label the message as a broadcast
34    });
35    console.log('Broadcast message sent successfully');
36  } catch (error) {
37    console.error('Error sending broadcast message:', error);
38  }
39}
40

41// Example: sending a broadcast message
42sendBroadcastMessage('Attention all users, system maintenance at midnight!');
43

44// Function to configure broadcast settings
45function configureBroadcastChannel() {
46  // You might implement additional logic here to ensure only certain clients can publish to the channel
47  // This could involve permissions management if implemented server-side
48}
49

50// Optionally call this function to manage and configure channel access and settings
51configureBroadcastChannel();
show all 51 lines

1import PubNub
2

3// Initialize the PubNub client with your publish and subscribe keys
4let config = PubNubConfiguration(
5  publishKey: "yourPublishKey",
6  subscribeKey: "yourSubscribeKey",
7  userId: "broadcaster-unique-id" // Unique ID for the broadcaster
8)
9let pubnub = PubNub(configuration: config)
10

11// Define the broadcast channel for one-to-many communication
12let broadcastChannel = "broadcast.announcements"
13

14// Subscribe to the broadcast channel
15let subscription = pubnub.channel(broadcastChannel).subscription()
16

17// Add event listeners for messages
18subscription.onMessage = { message in
19  print("Received broadcast message: \(message.message)")
20}
21

22// Subscribe to the channel
23subscription.subscribe()
24

25// Function to send a broadcast message
26func sendBroadcastMessage(_ text: String) {
27  pubnub.publish(
28    channel: broadcastChannel,
29    message: ["text": text],
30    customMessageType: "broadcast"
31  ) { result in
32    switch result {
33    case .success:
34      print("Broadcast message sent successfully")
35    case let .failure(error):
36      print("Error sending broadcast message: \(error.localizedDescription)")
37    }
38  }
39}
40

41// Send a broadcast message
42sendBroadcastMessage("System maintenance at midnight!")
show all 42 lines

1#import <PubNub/PubNub.h>
2

3@interface AppDelegate () <PNEventsListener>
4@property (nonatomic, strong) PubNub *client;
5@end
6

7@implementation AppDelegate
8

9- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
10

11    PNConfiguration *configuration = [PNConfiguration configurationWithPublishKey:@"yourPublishKey" subscribeKey:@"yourSubscribeKey"];
12

13    configuration.uuid = @"broadcaster-unique-id"; // Unique ID for the broadcaster
14

15    self.client = [PubNub clientWithConfiguration:configuration];
16    [self.client addListener:self];
17

18    // Define the broadcast channel for one-to-many communication
19    NSString *broadcastChannel = @"broadcast.announcements";
20

21    // Subscribe to the broadcast channel
22    [self.client subscribeToChannels:@[broadcastChannel] withPresence:NO];
23

24    return YES;
25}
26

27- (void)client:(PubNub *)client didReceiveMessage:(PNMessageResult *)message {
28    NSLog(@"Received broadcast message: %@ on channel %@", message.data.message, message.data.channel);
29}
30

31// Function to send a broadcast message
32- (void)sendBroadcastMessage:(NSString *)text {
33    [self.client publish:@{@"text": text} toChannel:@"broadcast.announcements"
34               withCompletion:^(PNPublishStatus *status) {
35        if (!status.isError) {
36            NSLog(@"Broadcast message sent successfully");
37        } else {
38            NSLog(@"Error sending broadcast message: %@", status.errorData.information);
39        }
40    }];
41}
42

43@end
show all 43 lines

1import com.google.gson.JsonObject
2import com.pubnub.api.PubNub
3import com.pubnub.api.UserId
4import com.pubnub.api.models.consumer.pubsub.PNMessageResult
5import com.pubnub.api.v2.PNConfiguration
6import com.pubnub.api.v2.callbacks.EventListener
7

8fun main() {
  val config = PNConfiguration.builder(UserId("broadcaster-unique-id"), "yourSubscribeKey").apply {
      publishKey = "yourPublishKey"
  }
  val pubnub = PubNub.create(config.build())
  val broadcastChannelName = "broadcast.announcements"
  // Create Subscription
  val channel = pubnub.channel(broadcastChannelName)
  val subscription = channel.subscription()
  // Add Listener for messages (subscribers)
  subscription.addListener(object : EventListener {
      override fun message(pubnub: PubNub, result: PNMessageResult) {
          println("Received broadcast message: ${result.message.asJsonObject}")
      }
  })
  // Subscribe to the channel
  subscription.subscribe()
  // Function to send a broadcast message
  fun sendBroadcastMessage(message: String) {
      val messageObject = JsonObject().apply {
          addProperty("text", message)
      }
      channel.publish(messageObject, shouldStore = false).async { result ->
          result.onFailure { exception ->
              println("Error sending broadcast message: ${exception.message}")
          }.onSuccess { value ->
              println("Broadcast message sent successfully with timetoken: ${value.timetoken}")
          }
      }
  }
  // Example: sending a broadcast message
  sendBroadcastMessage("Attention all users, system maintenance at midnight!")
40}
show all 40 lines

1using PubnubApi;
2using System;
3using System.Collections.Generic;
4

5class Program
6{
  static void Main(string[] args)
  {
      PNConfiguration pnConfiguration = new PNConfiguration(new UserId("broadcaster-unique-id"));
      pnConfiguration.SubscribeKey = "yourSubscribeKey";
      pnConfiguration.PublishKey = "yourPublishKey";
      Pubnub pubnub = new Pubnub(pnConfiguration);
13

      string broadcastChannelName = "broadcast.announcements";
      Subscription subscription = pubnub.Channel(broadcastChannelName).Subscription();
16

      subscription.AddListener(new SubscribeCallbackExt(
          (pnObj, pubMsg) => {
              if (pubMsg != null)
              {
                  Console.WriteLine("Received broadcast message: " + pubMsg.Message);
              }
          },
          (pnObj, presenceEvnt) => {
              if (presenceEvnt != null)
              {
                  Console.WriteLine($"Presence event: {presenceEvnt.Channel} {presenceEvnt.Occupancy} {presenceEvnt.Event}");
              }
          }
      ));
31

      subscription.Subscribe<object>();
33

      // Function to send a broadcast message
      void SendBroadcastMessage(string message)
      {
          var msg = new Dictionary<string, string> { { "text", message } };
          pubnub.Publish()
                .Channel(broadcastChannelName)
                .Message(msg)
                .ShouldStore(false) // Typically, broadcasts do not need to be stored
                .Execute(new PNPublishResultExt(
                    (result, status) => {
                        if (!status.Error)
                        {
                            Console.WriteLine(string.Format("Broadcast message sent, timetoken: {0}", result.Timetoken));
                        }
                        else
                        {
                            Console.WriteLine("Error sending broadcast message: " + status.ErrorData.Information);
                        }
                    }
                ));
      }
55

      SendBroadcastMessage("Attention all users, system maintenance at midnight!");
  }
58}
show all 58 lines

1from pubnub.pnconfiguration import PNConfiguration
2from pubnub.pubnub import PubNub
3from pubnub.callbacks import SubscribeCallback
4

5# Configuration setup
6config = PNConfiguration()
7config.subscribe_key = 'yourSubscribeKey'
8config.publish_key = 'yourPublishKey'
9config.user_id = 'broadcaster-unique-id'
10pubnub = PubNub(config)
11

12# Listener Setup
13class BroadcastSubscribeCallback(SubscribeCallback):
14    def message(self, pubnub, message):
15        print(f"Received broadcast message: {message.message}")
16

17    def presence(self, pubnub, presence):
18        print(f"Presence event: {presence.event}")
19

20    def status(self, pubnub, status):
21        print(f"Status: {status.category}")
22

23pubnub.add_listener(BroadcastSubscribeCallback())
24

25# Setup broadcast channel and subscribe
26broadcast_channel = pubnub.channel("broadcast.announcements").subscription()
27broadcast_channel.subscribe()
28

29# Publish message to broadcast channel
30def send_broadcast_message(message):
31    pubnub.publish().channel("broadcast.announcements").message({"text": message}).should_store(False).sync()
32

33send_broadcast_message("Attention all users, system maintenance at midnight!")
show all 33 lines

Unicast channels for poll responses, sensor inputs, location data, and other situations in which you want to aggregate messages in a many-to-one arrangement.

1const PubNub = require('pubnub');
2

3// Initialize the PubNub client with your publish and subscribe keys
4const pubnub = new PubNub({
5  publishKey: 'yourPublishKey',
6  subscribeKey: 'yourSubscribeKey',
7  userId: 'listener-unique-id', // Unique ID for the device/server listening for inputs
8  ssl: true                      // Enable SSL for secure communication
9});
10

11// Define the unicast channel for aggregating messages
12const unicastChannel = 'unicast.dataCollector'; // Example channel for aggregating data
13

14// Subscribe to the unicast channel
15const channel = pubnub.channel(unicastChannel);
16const subscription = channel.subscription();
17

18// Add an event listener for messages
19subscription.onMessage = (messageEvent) => {
20  console.log('Received message:', messageEvent.message);
21  // Process the incoming data
22  processIncomingData(messageEvent.message);
23};
24

25// Subscribe to the channel
26subscription.subscribe();
27

28// The function for processing incoming data
29function processIncomingData(data) {
30  // Implement your data processing logic here
31  console.log('Processing data:', data);
32}
33

34// Function for sending data to the unicast channel from different devices
35async function sendData(deviceId, data) {
36  try {
37    await pubnub.publish({
38      channel: unicastChannel,
39      message: { deviceId: deviceId, data: data },
40      storeInHistory: true,  // Optional: store data for historical analysis
41      customMessageType: "sensor-data", // Label the message type
42    });
43    console.log('Data sent successfully from device:', deviceId);
44  } catch (error) {
45    console.error('Error sending data from device:', deviceId, error);
46  }
47}
48

49// Example: devices sending data to the unicast channel
50sendData('device1', { temperature: 22.5, humidity: 45 });
51sendData('device2', { location: { lat: 37.7749, lon: -122.4194 } });
52

53// Optionally, function for configuring access if needed
54function configureUnicastChannel() {
55  // You can manage which users or devices are allowed to publish to the channel
56  // This can involve permissions management if implemented server-side
57}
58

59// Optionally call this function to set up access and permissions
60configureUnicastChannel();
show all 60 lines

1import PubNub
2

3// Initialize the PubNub client with your publish and subscribe keys
4let config = PubNubConfiguration(
5  publishKey: "yourPublishKey",
6  subscribeKey: "yourSubscribeKey",
7  userId: "listener-unique-id" // Unique ID for the listener
8)
9let pubnub = PubNub(configuration: config)
10

11// Define the unicast channel for aggregating messages
12let unicastChannel = "unicast.dataCollector"
13

14// Subscribe to the unicast channel
15let subscription = pubnub.channel(unicastChannel).subscription()
16

17// Add event listeners for messages
18subscription.onMessage = { message in
19  print("Received data message: \(message.message)")
20}
21

22// Subscribe to the channel
23subscription.subscribe()
24

25// Function to send data from a device
26func sendData(deviceId: String, data: [String: Any]) {
27  pubnub.publish(
28    channel: unicastChannel,
29    message: ["deviceId": deviceId, "data": data],
30    customMessageType: "sensor-data"
31  ) { result in
32    switch result {
33    case .success:
34      print("Data sent from device \(deviceId) successfully")
35    case let .failure(error):
36      print("Error sending data from device \(deviceId): \(error.localizedDescription)")
37    }
38  }
39}
40

41// Send data from multiple devices
42sendData(deviceId: "device1", data: ["temperature": 22.5, "humidity": 45])
43sendData(deviceId: "device2", data: ["location": ["lat": 37.7749, "lon": -122.4194]])
show all 43 lines

1#import <PubNub/PubNub.h>
2

3@interface AppDelegate () <PNEventsListener>
4@property (nonatomic, strong) PubNub *client;
5@end
6

7@implementation AppDelegate
8

9- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
10

11    PNConfiguration *configuration = [PNConfiguration configurationWithPublishKey:@"yourPublishKey" subscribeKey:@"yourSubscribeKey"];
12

13    configuration.uuid = @"listener-unique-id"; // Unique ID for the listener
14

15    self.client = [PubNub clientWithConfiguration:configuration];
16    [self.client addListener:self];
17

18    // Define the unicast channel for aggregating messages
19    NSString *unicastChannel = @"unicast.dataCollector";
20

21    // Subscribe to the unicast channel
22    [self.client subscribeToChannels:@[unicastChannel] withPresence:NO];
23

24    return YES;
25}
26

27- (void)client:(PubNub *)client didReceiveMessage:(PNMessageResult *)message {
28    NSLog(@"Received data message: %@ on channel %@", message.data.message, message.data.channel);
29}
30

31// Function to send data from a device
32- (void)sendDataFromDevice:(NSString *)deviceId data:(NSDictionary *)data {
33    [self.client publish:@{@"deviceId": deviceId, @"data": data} toChannel:@"unicast.dataCollector"
34               withCompletion:^(PNPublishStatus *status) {
35        if (!status.isError) {
36            NSLog(@"Data sent from device %@ successfully", deviceId);
37        } else {
38            NSLog(@"Error sending data from device %@: %@", deviceId, status.errorData.information);
39        }
40    }];
41}
42

43@end
show all 43 lines

1import com.google.gson.JsonObject
2import com.pubnub.api.PubNub
3import com.pubnub.api.UserId
4import com.pubnub.api.models.consumer.pubsub.PNMessageResult
5import com.pubnub.api.v2.PNConfiguration
6import com.pubnub.api.v2.callbacks.EventListener
7

8fun main() {
  val config = PNConfiguration.builder(UserId("listener-unique-id"), "yourSubscribeKey").apply {
      publishKey = "yourPublishKey"
  }
  val pubnub = PubNub.create(config.build())
  val unicastChannelName = "unicast.dataCollector"
  // Create Subscription
  val channel = pubnub.channel(unicastChannelName)
  val subscription = channel.subscription()
  // Add Listener for messages
  subscription.addListener(object : EventListener {
      override fun message(pubnub: PubNub, result: PNMessageResult) {
          println("Received data: ${result.message.asJsonObject}")
          processIncomingData(result.message.asJsonObject)
      }
  })
  // Subscribe to the channel
  subscription.subscribe()
  // Process incoming data
27

  // Function to send data from a device
  fun sendData(deviceId: String, data: JsonObject) {
      channel.publish(data).async { result ->
          result.onFailure { exception ->
              println("Error sending data from device $deviceId: ${exception.message}")
          }.onSuccess { value ->
              println("Data sent successfully from device $deviceId with timetoken: ${value.timetoken}")
          }
      }
  }
  // Example: devices sending data
  val data1 = JsonObject().apply {
      addProperty("temperature", 22.5)
      addProperty("humidity", 45)
  }
  sendData("device1", data1)
44

  // simulate pause between two device sending data
  Thread.sleep(100)    
47

  val data2 = JsonObject().apply {
      addProperty("lat", 37.7749)
      addProperty("lon", -122.4194)
  }
  sendData("device2", data2)
53}
54

55fun processIncomingData(data: JsonObject) {
  println("Processing data: $data")
  // Your data processing logic here
58}
show all 58 lines

1using PubnubApi;
2using System;
3using System.Collections.Generic;
4

5class Program
6{
  static void Main(string[] args)
  {
      PNConfiguration pnConfiguration = new PNConfiguration(new UserId("listener-unique-id"));
      pnConfiguration.SubscribeKey = "yourSubscribeKey";
      pnConfiguration.PublishKey = "yourPublishKey";
      Pubnub pubnub = new Pubnub(pnConfiguration);
13

      string unicastChannelName = "unicast.dataCollector";
      Subscription subscription = pubnub.Channel(unicastChannelName).Subscription();
16

      subscription.AddListener(new SubscribeCallbackExt(
          (pnObj, pubMsg) => {
              if (pubMsg != null)
              {
                  Console.WriteLine("Received data: " + pubMsg.Message);
                  ProcessIncomingData(pubMsg.Message);
              }
          },
          (pnObj, presenceEvnt) => {
              if (presenceEvnt != null)
              {
                  Console.WriteLine($"Presence event: {presenceEvnt.Channel} {presenceEvnt.Occupancy} {presenceEvnt.Event}");
              }
          }
      ));
32

      subscription.Subscribe<object>();
34

      // Method to process incoming data
      void ProcessIncomingData(object data)
      {
          Console.WriteLine("Processing data: " + data);
          // Implement your data processing logic here
      }
41

      // Function to send data from devices
      void SendData(string deviceId, Dictionary<string, object> data)
      {
          pubnub.Publish()
                .Channel(unicastChannelName)
                .Message(new Dictionary<string, object> { { "deviceId", deviceId }, { "data", data } })
                .Execute(new PNPublishResultExt(
                    (result, status) => {
                        if (!status.Error)
                        {
                            Console.WriteLine(string.Format("Data sent from device {0}, timetoken: {1}", deviceId, result.Timetoken));
                        }
                        else
                        {
                            Console.WriteLine(string.Format("Error sending data from device {0}: {1}", deviceId, status.ErrorData.Information));
                        }
                    }
                ));
      }
61

      // Example: devices sending data
      SendData("device1", new Dictionary<string, object> { { "temperature", 22.5 }, { "humidity", 45 } });
      SendData("device2", new Dictionary<string, object> { { "lat", 37.7749 }, { "lon", -122.4194 } });
  }
66}
show all 66 lines

1from pubnub.pnconfiguration import PNConfiguration
2from pubnub.pubnub import PubNub
3from pubnub.callbacks import SubscribeCallback
4

5# Configuration setup
6config = PNConfiguration()
7config.subscribe_key = 'yourSubscribeKey'
8config.publish_key = 'yourPublishKey'
9config.user_id = 'listener-unique-id'
10pubnub = PubNub(config)
11

12# Listener Setup
13class UnicastSubscribeCallback(SubscribeCallback):
14    def message(self, pubnub, message):
15        print(f"Received data: {message.message}")
16        process_incoming_data(message.message)
17

18    def presence(self, pubnub, presence):
19        print(f"Presence event: {presence.event}")
20

21    def status(self, pubnub, status):
22        print(f"Status: {status.category}")
23

24pubnub.add_listener(UnicastSubscribeCallback())
25

26# Setup unicast channel and subscribe
27unicast_channel = pubnub.channel("unicast.dataCollector").subscription()
28unicast_channel.subscribe()
29

30# Function to process incoming data
31def process_incoming_data(data):
32    print(f"Processing data: {data}")
33

34# Publish sensor data to unicast channel
35def send_data(device_id, data):
36    pubnub.publish().channel("unicast.dataCollector").message({"deviceId": device_id, "data": data}).sync()
37

38# Example: devices sending data
39send_data("device1", {"temperature": 22.5, "humidity": 45})
40send_data("device2", {"lat": 37.7749, "lon": -122.4194})
show all 40 lines

Channel groups allow you to bundle thousands of channels into a group that can be identified by name. When you subscribe to a channel group, you receive data from all the channels the channel group contains.

Channel names

A channel name can be any alphanumeric string up to 92 UTF‑8 characters. Channel names are unique per PubNub key set. You can reuse the same name in a different key set, even within the same account. A key set is the namespace for your channels.

Invalid characters

, : * / \ and Unicode Null, whitespace, and non‑printable ASCII characters.

Valid characters

_ - = @ . ! $ # % & ^ ;

A period (.) is valid. It is also a special character for wildcard features. Use it strategically to enable wildcard channel subscribe and Function wildcard channel binding.

Channel name validator

Check if your channel name is valid using the channel name validator.

Channel name

Naming conventions

When it comes to naming your channels, we recommend that you provide a prefix that identifies the purpose of the channel or the types of messages that will be sent over those types of channels.

Following that prefix with a . character further enhances the usefulness of the channel name concerning the wildcard features with several PubNub features, like wildcard subscribe, wildcard channel function binding, and advanced Presence configuration.

For further details on channel naming recommendations, refer to Channel Naming Conventions.

Securing channels

Secure channels by controlling access with PubNub’s Access Manager.

While you are learning PubNub, you can keep Access Manager disabled so any client can send and receive on any channel. For production, enable access control to protect your channels.

For app‑wide protection, see Access Control in the Security section.

We are fast

Channel creation​

Channel entity​

Channel limits​

Channel types​

Channel names​

Invalid characters​

Valid characters​

Channel name validator​

Naming conventions​

Securing channels​