PubNub

https://www.pubnub.com/docs/
Admin
PubNub is a global real-time messaging platform and communication infrastructure that enables...
Tokens:5,403,664
Snippets:32,685
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Start the React app to test setup

Source: https://www.pubnub.com/docs/sdks/redux/react-tutorial

Runs the npm start command to open a web browser and verify the app is working. If the expected screen appears, the setup is successful.

```bash
npm start
```

--------------------------------

### Get All UUID Metadata Sample Code

Source: https://www.pubnub.com/docs/sdks/kotlin/api-reference/objects

Self-contained reference example for the getAllUUIDMetadata method. It includes imports, configuration, setup of sample users, and a basic call to getAllUUIDMetadata. The example is truncated in the source; the remaining code is not shown.

```kotlin
import com.pubnub.api.PubNub
import com.pubnub.api.UserId
import com.pubnub.api.v2.PNConfiguration

/**
 * This example demonstrates how to use the getAllUUIDMetadata method in the PubNub Kotlin SDK.
 *
 * The App Context (Objects) API allows you to store metadata about users (UUIDs) in PubNub's
 * database without setting up your own backend.
 */
fun main() {
    println("PubNub UUID Metadata Example")
    println("============================")

    // 1. Configure PubNub
    val userId = UserId("uuid-metadata-demo-user")
    val config = PNConfiguration.builder(userId, "demo").apply {
        publishKey = "demo"
    }.build()

    // 2. Create PubNub instance
    val pubnub = PubNub.create(config)

    // 3. First, set up some sample user metadata
    setupSampleUsers(pubnub)

    // 4. Demonstrate getting all UUID metadata
    getAllUUIDMetadataBasic(pubnub)

    // 5. Demonstrate getting all UUID metadata with filtering
    getAllUUIDMetadataWithFilter(pubnub)

    // 6. Get metadata for a specific UUID
    getSpecificUUIDMetadata(pubnub)

    // 7. Clean up sample user metadata
    cleanupUserMetadata(pubnub)

    // Clean up
    pubnub.destroy()
}

/**
 * Set up sample user metadata for the demo
 */
private fun setupSampleUsers(pubnub: PubNub) {
    println("\n# Setting up sample user metadata")

    // Create a few users with metadata
    val users = listOf(
        Triple("user-1", "Alice", "Developer"),
        Triple("user-2", "Bob", "Manager"),
        Triple("user-3", "Charlie", "Support")
    )

    users.forEach { (userId, name, role) ->
        println("\nSetting up metadata for $name ($userId)")

        pubnub.setUUIDMetadata(
            uuid = userId,
            name = name,
            includeCustom = true,
            custom = mapOf("role" to role, "active" to true),
            email = "$name@example.com".lowercase()
        ).async { result ->
            result.onSuccess { response ->
                println("SUCCESS: Created/updated user metadata for ${response.data?.id}")
                println("Name: ${response.data?.name}")
                println("Email: ${response.data?.email}")
                println("Custom: ${response.data?.custom}")
            }.onFailure { exception ->
                println("ERROR: Failed to set user metadata")
                println("Error details: ${exception.message}")
            }
        }
    }

    // Wait for a moment to ensure all operations are complete
    println("\nWaiting for metadata operations to complete...")
    Thread.sleep(2000)
}

/**
 * Demonstrates a basic call to getAllUUIDMetadata
 */
private fun getAllUUIDMetadataBasic(pubnub: PubNub) {
    println("\n# Getting All UUID Metadata (Basic)")

    pubnub.getAllUUIDMetadata(
        includeCustom = true, // Include custom fields
        includeCount = true // Include total count in response
    ).async { result ->
        result.onSuccess { response ->
            println("SUCCESS: Retrieved UUID metadata objects")
```

--------------------------------

### Set up the project

Source: https://www.pubnub.com/docs/use-cases/sports-media-entertainment/automated-polling

Creates a new directory, initializes npm, and installs the PubNub SDK.

```bash
mkdir automated-polling-tutorial
cd automated-polling-tutorial
npm init -y
npm install pubnub
```

--------------------------------

### Get typing events with StreamTyping and OnUsersTyping

Source: https://www.pubnub.com/docs/chat/unity-chat-sdk/build/features/channels/typing-indicator

Complete Unity Chat example that gets typing events on the 'support' channel. Joins the channel, enables streaming with StreamTyping(true), subscribes to OnUsersTyping, and starts typing to trigger the event.

```csharp
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using PubnubApi;
using PubnubChatApi;
using UnityEngine;
// Configuration
PubnubChatConfig chatConfig = new PubnubChatConfig();
        
PNConfiguration pnConfiguration = new PNConfiguration(new UserId("myUniqueUserId"))
{
    SubscribeKey = "demo",
    PublishKey = "demo",
    Secure = true
};

// Initialize Unity Chat
var chatResult = await UnityChat.CreateInstance(chatConfig, pnConfiguration);
if (!chatResult.Error)
{
    chat = chatResult.Result;
}
// reference the channel where you want to listen to typing signals
var channelResult = await chat.GetChannel("support");
if (!channelResult.Error)
{
    var channel = channelResult.Result;
    Debug.Log($"Found channel with name {channel.Name}");

    // join the channel, start listening for typing
    await channel.JoinChannel();
    channel.Connect();
    channel.StreamTyping(true);

    // subscribe to the OnUsersTyping event
    channel.OnUsersTyping += OnUsersTypingHandler;
            
    await Task.Delay(4000);

    // indicate that typing has started
    await channel.StartTyping();
}
else
{
    Debug.Log("Channel not found");
}
        
// event handler for typing events
void OnUsersTypingHandler(List<string> users)
{
    if (users.Count > 0)
    {
        Debug.Log($"Users typing: {string.Join(", ", users)}");
    }
    else
    {
        Debug.Log("No users are currently typing");
    }
}
```

--------------------------------

### Objective-C: PubNub Quickstart with Listener

Source: https://www.pubnub.com/docs/getting-started/quickstart

Sets up a PubNub client, subscribes to a channel, publishes a message, and prints received messages. Requires your publish and subscribe keys. The example uses a listener to handle messages and connection status, and publishes when connected.

```objectivec
#import <Foundation/Foundation.h>
#import <PubNub/PubNub.h>

@interface QuickstartListener : NSObject <PNEventsListener>
@property(nonatomic, strong) PubNub *client;
@end

@implementation QuickstartListener

- (void)client:(PubNub *)client didReceiveMessage:(PNMessageResult *)message {
    NSLog(@"Message received: %@", message.data.message[@"text"]);
}

- (void)client:(PubNub *)client didReceiveStatus:(PNStatus *)status {
    if (status.category == PNConnectedCategory) {
        [self publishMessage];
    }
}

- (void)publishMessage {
    [self.client publish:@{@"text": @"Hello, PubNub!"}
               toChannel:@"quickstart-channel"
          withCompletion:^(PNPublishStatus *status) {
        if (status.isError) {
            NSLog(@"Publish failed: %@", status.errorData.information);
        }
    }];
}

@end

int main(int argc, const char *argv[]) {
    @autoreleasepool {
        PNConfiguration *configuration = [PNConfiguration configurationWithPublishKey:@"YOUR_PUBLISH_KEY"
                                                                        subscribeKey:@"YOUR_SUBSCRIBE_KEY"
                                                                              userID:@"quickstart-user"];

        QuickstartListener *listener = [QuickstartListener new];
        listener.client = [PubNub clientWithConfiguration:configuration];

        [listener.client addListener:listener];
        [listener.client subscribeToChannels:@[@"quickstart-channel"] withPresence:NO];

        [[NSRunLoop currentRunLoop] run];
    }
    return 0;
}
```

--------------------------------

### GetAllUUIDMetadata method chain example

Source: https://www.pubnub.com/docs/sdks/go/api-reference/objects

Shows the method chain for getting all UUID metadata with optional include, sort, limit, count, start, end, and filter parameters.

```go
pn.GetAllUUIDMetadata().
    Include([]pubnub.PNUUIDMetadataIncludeCustom).
    Sort(sort).
    Limit(int).
    Count(bool).
    Start(string).
    End(string).
    Filter(string).
    Execute()
```

--------------------------------

### Go: Get UUID metadata with setup and retrieval

Source: https://www.pubnub.com/docs/data-storage/metadata/manage-user-metadata

Shows a complete Go example that sets user metadata, waits for persistence, then retrieves it. Includes configuration and error handling.

```go
// Replace with your package name (usually "main")
package pubnub_samples_test

import (
	"fmt"
	"time"

	pubnub "github.com/pubnub/go/v10"
)

// Example_getUUIDMetadata demonstrates retrieving user metadata
func Example_getUUIDMetadata() {
	config := pubnub.NewConfigWithUserId(pubnub.UserId("demo-user"))
	config.SubscribeKey = "demo"
	config.PublishKey = "demo"

	pn := pubnub.NewPubNub(config)

	// First, set user metadata
	pn.SetUUIDMetadata().
		UUID("user-456").
		Name("Jane Smith").
		Email("jane@example.com").
		Execute()

	// Small delay to ensure metadata is persisted before retrieval
	time.Sleep(2 * time.Second)

	// Then retrieve the user metadata
	response, status, err := pn.GetUUIDMetadata().
		UUID("user-456"). // User ID to retrieve
		Execute()

	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	if status.StatusCode == 200 {
		fmt.Printf("User: %s\n", response.Data.Name)
		fmt.Printf("Email: %s\n", response.Data.Email)
	}

	// Output:
	// User: Jane Smith
	// Email: jane@example.com
}
```

--------------------------------

### Build a single example target

Source: https://www.pubnub.com/docs/sdks/c/environment-setup

Configure with the full preset and examples enabled, then build a specific example target. Target names follow the pattern example_<feature>_<style>, e.g., example_publish_sync.

```bash
cmake --preset full -DPUBNUB_BUILD_EXAMPLES=ON
cmake --build --preset full --target example_publish_sync
```

--------------------------------

### Example Response for Get Message History with Actions

Source: https://www.pubnub.com/docs/sdks/rest-api/get-message-history-with-actions

Shows a successful response (status 200) with messages including metadata, message types, and actions. The 'more' object provides a URL and start timetoken for pagination.

```json
{
  "status": 200,
  "error": false,
  "error_message": "",
  "channels": {
    "demo-channel": [
      {
        "message": "Hi",
        "timetoken": "15610547826970040",
        "uuid": "my-uuid",
        "message_type": 0,
        "meta": {
          "some-meta-key": "some_value"
        },
        "custom_message_type": "custom-user-msg-type",
        "actions": {
          "receipt": {
            "read": [
              {
                "uuid": "user-7",
                "actionTimetoken": "15610547826970044"
              }
            ]
          }
        }
      },
      {
        "message": "Hello",
        "timetoken": "15610547826970000",
        "uuid": "my-uuid",
        "message_type": 0,
        "meta": {
          "some-meta-key": "some_value"
        },
        "custom_message_type": "custom-user-msg-type",
        "actions": {
          "reaction": {
            "smiley_face": [
              {
                "uuid": "user-456",
                "actionTimetoken": "15610547826970050"
              }
            ],
            "raccoon": [
              {
                "uuid": "user-789",
                "actionTimetoken": "15610547826980050"
              },
              {
                "uuid": "user-567",
                "actionTimetoken": "15610547826970000"
              }
            ]
          }
        }
      }
    ]
  },
  "more": {
    "url": "/v3/history-with-actions/s/channel/c?start=15610547826970000&max=98",
    "start": "15610547826970000",
    "max": 98
  }
}
```

--------------------------------

### Python: PubNub Quickstart

Source: https://www.pubnub.com/docs/getting-started/quickstart

Sets up a PubNub client, subscribes to a channel, and publishes a message after connection. Uses threading.Event to wait for connection. Requires your publish and subscribe keys.

```python
import threading

from pubnub.callbacks import SubscribeCallback
from pubnub.enums import PNStatusCategory
from pubnub.exceptions import PubNubException
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub

config = PNConfiguration()
config.publish_key = 'YOUR_PUBLISH_KEY'
config.subscribe_key = 'YOUR_SUBSCRIBE_KEY'
config.user_id = 'quickstart-user'

pubnub = PubNub(config)

connected = threading.Event()

class StatusListener(SubscribeCallback):
    def status(self, pubnub, status):
        if status.category == PNStatusCategory.PNConnectedCategory:
            connected.set()

pubnub.add_listener(StatusListener())

subscription = pubnub.channel('quickstart-channel').subscription()

def on_message(message):
    print('Message received:', message.message['text'])

subscription.on_message = on_message

subscription.subscribe()

connected.wait()

try:
    pubnub.publish() \
        .channel('quickstart-channel') \
        .message({'text': 'Hello, PubNub!'}) \
        .sync()
except PubNubException as error:
    print('Publish failed:', error)
```

--------------------------------

### Get state example

Source: https://www.pubnub.com/docs/sdks/posix-cpp/api-reference/presence

Example of getting a user's state from a channel. On success, the state is printed; on failure, the error code is printed.

```cpp
static void get_state(pubnub::context &pn) {
  enum pubnub_res res;

  try {
    res = pn.state_get("my_channel", "", "my_uuid").await();

    if (PNR_OK == res) {
      std::cout <<  pn.get() << std::endl;
    } else {
      std::cout << "Failed with code " << res << std::endl;
    }
  } catch (std::exception &ex) {
    std::cout << "Exception: " << ex.what() << std::endl;
  }
}
```

--------------------------------

### Run the example binary

Source: https://www.pubnub.com/docs/sdks/c

Run the compiled example binary to test the subscription. The output should show a connected status and a received message on the channel.

```bash
./build/full/examples/subscribe/example_subscribe_callback
```

--------------------------------

### Sample output from running the application

Source: https://www.pubnub.com/docs/sdks/rust

Example output showing successful initialization, subscription, connection, message publishing, and receiving a message on the channel.

```text
PubNub client initialized successfully!
Subscribed to channel: my_channel
Connected to PubNub network
Message published successfully! Timetoken: 16967543908123456
Received message on channel 'my_channel': {"text":"Hello, world!","sender":"Rust Server"}
Global listener: Received message on channel 'my_channel': {"text":"Hello, world!","sender":"Rust Server"}
```

--------------------------------

### Stream presence on a channel with delegate binding

Source: https://www.pubnub.com/docs/chat/unreal-chat-sdk/build/features/users/presence

Complete example that initializes the chat subsystem, gets the 'support' channel, binds the OnPresenceChanged delegate, starts streaming presence, and later stops it. Requires a valid GameInstance and a user ID.

```cpp
#include "Kismet/GameplayStatics.h"
#include "PubnubChatSubsystem.h"

UGameInstance* GameInstance = UGameplayStatics::GetGameInstance(this);
UPubnubChatSubsystem* PubnubChatSubsystem = GameInstance->GetSubsystem<UPubnubChatSubsystem>();

FPubnubChatInitChatResult InitResult = PubnubChatSubsystem->InitChat("demo", "demo", "my_user");
UPubnubChat* Chat = InitResult.Chat;

FPubnubChatChannelResult ChannelResult = Chat->GetChannel("support");
UPubnubChatChannel* Channel = ChannelResult.Channel;

// Bind the delegate to receive presence updates
Channel->OnPresenceChanged.AddDynamic(this, &AMyActor::OnPresenceUpdated);

// Start streaming presence
FPubnubChatOperationResult StreamResult = Channel->StreamPresence();

// ... later, stop streaming
FPubnubChatOperationResult StopResult = Channel->StopStreamingPresence();
```

--------------------------------

### Go: Get channel metadata with setup and output

Source: https://www.pubnub.com/docs/data-storage/metadata/manage-channel-metadata

Shows a complete Go example: configures PubNub, sets channel metadata first, waits 2 seconds, then retrieves it. Prints the channel name and description on success. Includes expected output.

```go
// Replace with your package name (usually "main")
package pubnub_samples_test

import (
	"fmt"
	"time"

	pubnub "github.com/pubnub/go/v10"
)

// Example_getChannelMetadata demonstrates retrieving channel metadata
func Example_getChannelMetadata() {
	config := pubnub.NewConfigWithUserId(pubnub.UserId("demo-user"))
	config.SubscribeKey = "demo"
	config.PublishKey = "demo"

	pn := pubnub.NewPubNub(config)

	// First, set channel metadata
	pn.SetChannelMetadata().
		Channel("sales-channel-456").
		Name("Sales Team").
		Description("Sales team discussions").
		Execute()

	// Small delay to ensure metadata is persisted before retrieval
	time.Sleep(2 * time.Second)

	// Then retrieve the channel metadata
	response, status, err := pn.GetChannelMetadata().
		Channel("sales-channel-456"). // Channel ID to retrieve
		Execute()

	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	if status.StatusCode == 200 {
		fmt.Printf("Channel: %s\n", response.Data.Name)
		fmt.Printf("Description: %s\n", response.Data.Description)
	}

	// Output:
	// Channel: Sales Team
	// Description: Sales team discussions
}
```

--------------------------------

### Run Go quickstart with go run main.go

Source: https://www.pubnub.com/docs/getting-started/quickstart

Run the Go quickstart program. The program prints the received message and keeps running because of the empty select {} block.

```bash
go run main.go
```

--------------------------------

### Subscribe to a channel - full example

Source: https://www.pubnub.com/docs/sdks/posix-cpp/api-reference/publish-and-subscribe

Example showing how to subscribe to a channel using synchronous, lambda, and function-based approaches. Includes message retrieval and error handling.

```cpp
// Sync
void subscribe(pubnub::context &pn) {
  enum pubnub_res res;

  for (;;) {
    res = pn.subscribe("my_channel").await();

    if (PNR_OK == res) {
      std::vector<std::string> msg = pn.get_all();

      for (std::vector<std::string>::iterator it = msg.begin(); it != msg.end(); ++it) {
       std::cout << *it << std::endl;
      }
    } else {
      std::cout << "Request failed" << std::endl;
      break;
    }
  }
}

```

```cpp
// Lambdas
void subscribe(pubnub::context &ipn) {
  ipn.subscribe("my_channel").then([=](pubnub::context &pn, pubnub_res res) {
    auto msg = pn.get_all();

    if (PNR_OK == res) {
      for (auto &&m: msg) {
        std::cout << m << std::endl;
      }

    } else {
      std::cout << "Request failed" << std::endl;
    }
  });
}

```

```cpp
// Functions
void on_subscribe(pubnub::context &pn, pubnub_res res) {
  if (PNR_OK == res) {
    std::vector<std::string> msg = pn.get_all();

    for (std::vector<std::string>::iterator it = msg.begin(); it != msg.end(); ++it) {
      std::cout << *it << std::endl;
    }
  } else {
    std::cout << "Request failed" << std::endl;
  }
}

void subscribe(pubnub::context &pn) {
  pn.subscribe("my_channel").then(on_subscribe);
}

```

--------------------------------

### Get state example

Source: https://www.pubnub.com/docs/sdks/cocoa-objective-c/api-reference/presence

Example of getting user state from channels and channel groups. Handles success and error cases, including retry via [status retry].

```objectivec
self.client.state().audit().uuid(@"PubNub")
    .channels(@[@"channel1", @"channel12"])
    .channelGroups(@[@"group1", @"group2"])
    .performWithCompletion(^(PNClientStateGetResult *result, PNErrorStatus *status) {

        if (!status.isError) {
            // Handle downloaded state information using: result.data.channels
        } else {
            /**
             Handle client state audit error. Check 'category' property
             to find out possible reason because of which request did fail.
             Review 'errorData' property (which has PNErrorData data type) of status
             object to get additional information about issue.

             Request can be resent using: [status retry]
            */
        }
    });
```

--------------------------------

### Unity: PubNub Quickstart

Source: https://www.pubnub.com/docs/getting-started/quickstart

Unity C# script using PubNub to subscribe to a channel and publish a message on connection. Requires PubNub Unity SDK and your publish/subscribe keys. Handles status and message events, and cleans up listeners on destroy.

```csharp
using System.Collections.Generic;
using PubnubApi;
using PubnubApi.Unity;
using UnityEngine;

public class PubNubQuickstart : PNManagerBehaviour
{
    private Subscription subscription;

    private void Awake()
    {
        listener.onStatus += OnStatus;
        listener.onMessage += OnMessage;

        Initialize("quickstart-user");

        subscription = pubnub.Channel("quickstart-channel").Subscription();
        subscription.Subscribe<object>();
    }

    private void OnStatus(Pubnub pn, PNStatus status)
    {
        if (status.Category == PNStatusCategory.PNConnectedCategory)
        {
            PublishMessage();
        }
    }

    private void OnMessage(Pubnub pn, PNMessageResult<object> result)
    {
        Dictionary<string, object> payload =
            pubnub.JsonPluggableLibrary.DeserializeToDictionaryOfObject(result.Message.ToString());
        Debug.Log($"Message received: {payload["text"]}");
    }

    private async void PublishMessage()
    {
        PNResult<PNPublishResult> result = await pubnub.Publish()
            .Channel("quickstart-channel")
            .Message(new Dictionary<string, object> { { "text", "Hello, PubNub!" } })
            .ExecuteAsync();

        if (result.Status.Error)
        {
            Debug.LogError($"Publish failed: {result.Status.ErrorData.Information}");
        }
    }

    protected override void OnDestroy()
    {
        listener.onStatus -= OnStatus;
        listener.onMessage -= OnMessage;

        base.OnDestroy();
    }
}
```

--------------------------------

### Get user state - Example Response

Source: https://www.pubnub.com/docs/sdks/rest-api/get-user-state

Example response for a successful get user state request. Shows the presence service, status 200, and a payload containing the user's state.

```json
{
  "service": "presence",
  "status": 200,
  "error": false,
  "message": "OK",
  "payload": "{text:hey}"
}
```

--------------------------------

### Unity: Subscribe to a channel with PubNubQuickstart

Source: https://www.pubnub.com/docs/getting-started/quickstart

Add this to PubNubQuickstart.cs. Creates a subscription to 'quickstart-channel', attaches status and message handlers, and publishes a message when connected. OnDestroy detaches handlers.

```csharp
public class PubNubQuickstart : PNManagerBehaviour
{
    private Subscription subscription;

    private void Awake()
    {
        listener.onStatus += OnStatus;
        listener.onMessage += OnMessage;

        Initialize("quickstart-user");

        subscription = pubnub.Channel("quickstart-channel").Subscription();
        subscription.Subscribe<object>();
    }

    private void OnStatus(Pubnub pn, PNStatus status)
    {
        if (status.Category == PNStatusCategory.PNConnectedCategory)
        {
            PublishMessage();
        }
    }

    private void OnMessage(Pubnub pn, PNMessageResult<object> result)
    {
        Dictionary<string, object> payload =
            pubnub.JsonPluggableLibrary.DeserializeToDictionaryOfObject(result.Message.ToString());
        Debug.Log($"Message received: {payload["text"]}");
    }

    protected override void OnDestroy()
    {
        listener.onStatus -= OnStatus;
        listener.onMessage -= OnMessage;

        base.OnDestroy();
    }
}
```

--------------------------------

### Java: PubNub Quickstart

Source: https://www.pubnub.com/docs/getting-started/quickstart

Sets up a PubNub client, subscribes to a channel, and publishes a message when connected. Uses Java v2 API with builder pattern. Requires your subscribe key and publish key.

```java
import com.google.gson.JsonObject;
import com.pubnub.api.PubNubException;
import com.pubnub.api.UserId;
import com.pubnub.api.enums.PNStatusCategory;
import com.pubnub.api.java.PubNub;
import com.pubnub.api.java.v2.PNConfiguration;
import com.pubnub.api.java.v2.callbacks.StatusListener;
import com.pubnub.api.java.v2.entities.Channel;
import com.pubnub.api.java.v2.subscriptions.Subscription;
import com.pubnub.api.models.consumer.PNStatus;

public class App {
    public static void main(String[] args) throws PubNubException, InterruptedException {
        PNConfiguration config = PNConfiguration.builder(new UserId("quickstart-user"), "YOUR_SUBSCRIBE_KEY")
                .publishKey("YOUR_PUBLISH_KEY")
                .build();

        PubNub pubnub = PubNub.create(config);

        Channel channel = pubnub.channel("quickstart-channel");
        Subscription subscription = channel.subscription();

        subscription.setOnMessage(event ->
                System.out.println("Message received: "
                        + event.getMessage().getAsJsonObject().get("text").getAsString()));

        pubnub.addListener(new StatusListener() {
            @Override
            public void status(PubNub pubnub, PNStatus status) {
                if (status.getCategory() == PNStatusCategory.PNConnectedCategory) {
                    publishMessage(channel);
                }
            }
        });

        subscription.subscribe();

        Thread.currentThread().join();
    }

    static void publishMessage(Channel channel) {
        JsonObject message = new JsonObject();
        message.addProperty("text", "Hello, PubNub!");

        channel.publish(message).async(result ->
                result.onFailure(exception ->
                        System.out.println("Publish failed: " + exception.getMessage())));
    }
}
```

--------------------------------

### Get PubNub timetoken sample code

Source: https://www.pubnub.com/docs/sdks/asyncio/api-reference/misc

Self-contained example that gets the current PubNub timetoken. It includes necessary imports, configuration, and error handling. The example uses asyncio and prints the result.

```python
import asyncio
import os
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub_asyncio import PubNubAsyncio
from pubnub.exceptions import PubNubException

async def get_pubnub_time(pubnub: PubNubAsyncio):
    try:
        # Get PubNub Timetoken
        envelope = await pubnub.time().future()
        print(f"Current time: {envelope.result}")

    except PubNubException as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)

    # Configuration for PubNub instance
    pn_config = PNConfiguration()
    pn_config.subscribe_key = os.getenv('SUBSCRIBE_KEY', 'demo')
    pn_config.user_id = "my_custom_user_id"

    pubnub = PubNubAsyncio(pn_config)

    try:
        loop.run_until_complete(get_pubnub_time(pubnub))
    finally:
        loop.run_until_complete(pubnub.stop())
        loop.close()
```

--------------------------------

### Get decision response example

Source: https://www.pubnub.com/docs/admin-api/get-decision

Example response body for the Get decision endpoint. Shows the structure of a decision object, including nested business objects, queries, metrics, and other related entities.

```json
{
  "createdAt": "2024-01-01T00:00:00.000Z",
  "updatedAt": "2024-01-01T00:00:00.000Z",
  "createdBy": "string",
  "updatedBy": "string",
  "id": "string",
  "name": "string",
  "description": "string",
  "accountId": "string",
  "businessObjectId": "string",
  "sourceType": "BUSINESSOBJECT",
  "sourceId": "string",
  "hitType": "SINGLE",
  "enabled": false,
  "activeFrom": "2024-01-01T00:00:00.000Z",
  "activeUntil": "2024-01-01T00:00:00.000Z",
  "executeOnce": false,
  "executionFrequency": 0,
  "inputFields": [
    {
      "id": "string",
      "sourceType": {},
      "sourceId": "string",
      "name": "string"
    }
  ],
  "outputFields": [
    {
      "id": "string",
      "name": "string",
      "variable": "string"
    }
  ],
  "rules": [
    {
      "id": "string",
      "inputValues": [
        {}
      ],
      "outputValues": [
        {}
      ],
      "actionValues": [
        {}
      ]
    }
  ],
  "actions": [
    {
      "id": "string",
      "actionType": "WEBHOOK_EXECUTION",
      "description": "string",
      "name": "string",
      "template": {},
      "note": "string"
    }
  ],
  "businessObject": {
    "createdAt": "2024-01-01T00:00:00.000Z",
    "updatedAt": "2024-01-01T00:00:00.000Z",
    "createdBy": "string",
    "updatedBy": "string",
    "id": "string",
    "name": "string",
    "isActive": false,
    "description": "string",
    "fields": [
      {
        "id": "string",
        "name": "string",
        "jsonPath": "string",
        "jsonFieldType": "TEXT",
        "isKeyset": false,
        "source": "JSONPATH",
        "derivation": {}
      }
    ],
    "accountId": "string",
    "subkeys": [
      "string"
    ],
    "metrics": [
      {
        "id": "string",
        "name": "string",
        "measureId": "string",
        "businessObjectId": "string",
        "evaluationWindow": 0,
        "function": "string",
        "dimensionIds": [],
        "dimensions": [],
        "filters": []
      }
    ],
    "decisions": [],
    "dashboards": [
      {
        "createdAt": "2024-01-01T00:00:00.000Z",
        "updatedAt": "2024-01-01T00:00:00.000Z",
        "createdBy": "string",
        "updatedBy": "string",
        "id": "string",
        "name": "string",
        "accountId": "string",
        "dateRange": "30 minutes",
        "startDate": "2024-01-01T00:00:00.000Z",
        "endDate": "2024-01-01T00:00:00.000Z",
        "charts": [],
        "customer": {}
      }
    ],
    "queries": [
      {
        "createdAt": "2024-01-01T00:00:00.000Z",
        "updatedAt": "2024-01-01T00:00:00.000Z",
        "createdBy": "string",
        "updatedBy": "string",
        "decisions": [],
        "customer": {},
        "businessObjects": [],
        "id": "string",
        "name": "string",
        "description": "string",
        "definition": {},
        "template": "string",
        "accountId": "string"
      }
    ],
    "customers": [
      {
        "id": "string",
        "name": "string"
      }
    ]
  },
  "metric": {
    "id": "string",
    "name": "string",
    "measureId": "string",
    "businessObjectId": "string",
    "evaluationWindow": 0,
    "function": "string",
    "dimensionIds": [
      "string"
    ],
    "dimensions": [
      {
        "id": "string",
        "name": "string",
        "jsonPath": "string",
        "jsonFieldType": "TEXT",
        "isKeyset": false,
        "source": "JSONPATH",
        "derivation": {}
      }
    ],
    "filters": [
      {
        "id": "string",
        "sourceType": "MEASURE",
        "sourceId": "string",
        "operation": "NUMERIC_GREATER_THAN",
        "arguments": []
      }
    ],
    "businessObject": {
      "createdAt": "2024-01-01T00:00:00.000Z",
      "updatedAt": "2024-01-01T00:00:00.000Z",
      "createdBy": "string",
      "updatedBy": "string",
      "id": "string",
      "name": "string",
      "isActive": false,
      "description": "string",
      "fields": [
        {}
      ],
      "accountId": "string",
      "subkeys": [
        "string"
      ],
      "metrics": [],
      "decisions": [],
      "dashboards": [
        {}
      ],
      "queries": [
        {}
      ],
      "customers": [
        {}
      ]
    }
  },
  "query": {
    "createdAt": "2024-01-01T00:00:00.000Z",
    "updatedAt": "2024-01-01T00:00:00.000Z",
    "createdBy": "string",
    "updatedBy": "string",
    "decisions": [],
    "customer": {
      "id": "string",
      "name": "string"
    },
    "businessObjects": [],
    "id": "string",
    "name": "string",
    "description": "string",
    "definition": {},
    "template": "string",
    "accountId": "string"
  }
}
```

--------------------------------

### Go: PubNub quickstart with subscribe and publish

Source: https://www.pubnub.com/docs/getting-started/quickstart

Sets up a PubNub client in Go, subscribes to a channel, listens for incoming messages, and publishes a test message. Requires your publish and subscribe keys. The listener publishes a message upon successful connection, and the publish result is checked for errors.

```go
package main

import (
	"fmt"
	"log"

	pubnub "github.com/pubnub/go/v9"
)

func main() {
	config := pubnub.NewConfigWithUserId(pubnub.UserId("quickstart-user"))
	config.PublishKey = "YOUR_PUBLISH_KEY"
	config.SubscribeKey = "YOUR_SUBSCRIBE_KEY"

	pn := pubnub.NewPubNub(config)

	listener := pubnub.NewListener()

	go func() {
		for {
			select {
			case status := <-listener.Status:
				if status.Category == pubnub.PNConnectedCategory {
					publishMessage(pn)
				}
			case message := <-listener.Message:
				payload := message.Message.(map[string]interface{})
				fmt.Println("Message received:", payload["text"])
			}
		}
	}()

	pn.AddListener(listener)

	pn.Subscribe().
		Channels([]string{"quickstart-channel"}).
		Execute()

	select {}
}

func publishMessage(pn *pubnub.PubNub) {
	_, _, err := pn.Publish().
		Channel("quickstart-channel").
		Message(map[string]interface{}{"text": "Hello, PubNub!"}).
		Execute()
	if err != nil {
		log.Println("Publish failed:", err)
	}
}
```

--------------------------------

### JavaScript: PubNub Quickstart

Source: https://www.pubnub.com/docs/getting-started/quickstart

Sets up a PubNub client, subscribes to a channel, and publishes a message when connected. Requires your publish and subscribe keys. Logs received messages and errors.

```javascript
const PubNub = require('pubnub');

const pubnub = new PubNub({
  publishKey: 'YOUR_PUBLISH_KEY',
  subscribeKey: 'YOUR_SUBSCRIBE_KEY',
  userId: 'quickstart-user',
});

const channel = pubnub.channel('quickstart-channel');
const subscription = channel.subscription();

subscription.onMessage = (event) => {
  console.log('Message received:', event.message.text);
};

pubnub.addListener({
  status: (event) => {
    if (event.category === 'PNConnectedCategory') {
      publishMessage();
    }
  },
});

subscription.subscribe();

async function publishMessage() {
  try {
    await pubnub.publish({
      channel: 'quickstart-channel',
      message: { text: 'Hello, PubNub!' },
    });
  } catch (error) {
    console.error('Publish failed:', error);
  }
}
```

--------------------------------

### Install dependencies with npm

Source: https://www.pubnub.com/docs/sdks/react/getting-started-react-native

Installs the required npm dependencies for the React Native example project.

```bash
npm install
```

--------------------------------

### Get state example

Source: https://www.pubnub.com/docs/sdks/asyncio/api-reference/presence

Example of retrieving presence state for channels and a UUID using get_state().

```python
envelope = await pubnub.get_state() \
    .channels(['ch1', 'ch2', 'ch3']) \
    .uuid('such_uuid') \
    .future()
```

--------------------------------

### Run PHP quickstart

Source: https://www.pubnub.com/docs/getting-started/quickstart

Run the PHP quickstart with `php index.php`. Expected output: `Message received: Hello, PubNub!`. The program keeps running because `execute()` runs the subscribe loop indefinitely. Press Ctrl+C to stop.

```bash
php index.php
```

--------------------------------

### Build PubNub C SDK example with CMake presets

Source: https://www.pubnub.com/docs/sdks/c

Configure and build the SDK's bundled `example_subscribe_callback` example using the `full` preset. These commands come straight from the SDK's own build configuration.

```bash
cmake --preset full
cmake --build --preset full --target example_subscribe_callback
```

--------------------------------

### Get Message History - Example Response

Source: https://www.pubnub.com/docs/sdks/rest-api/get-message-history

Example response from the Get Message History API. Shows the structure of the returned channels object with message, timetoken, uuid, message_type, meta, and custom_message_type fields.

```json
{
  "status": 200,
  "error": false,
  "error_message": "",
  "channels": {
    "demo-channel": [
      {
        "message": "Hello world",
        "timetoken": "15610547826970040",
        "uuid": "my-uuid",
        "message_type": 0,
        "meta": {
          "some-meta-key": "some_value"
        },
        "custom_message_type": "custom-user-msg-type"
      }
    ]
  }
}
```

--------------------------------

### Example Response - Get Channel Metadata Success

Source: https://www.pubnub.com/docs/sdks/rest-api/get-channel-metadata

Example of a successful response for the Get Channel Metadata endpoint. The response includes the channel's id, name, description, updated timestamp, and eTag.

```json
{
  "status": 200,
  "data": {
    "id": "myChannel3",
    "name": "My channel",
    "description": "A channel that is mine.",
    "updated": "2019-02-20T23:11:20.893Z",
    "eTag": "RTc1NUQwNUItREMyNy00Q0YxLUJCNDItMEZDMTZDMzVCN0VGCg=="
  }
}
```

--------------------------------

### C#: PubNub quickstart with subscribe and publish

Source: https://www.pubnub.com/docs/getting-started/quickstart

Sets up a PubNub client in C#, subscribes to a channel, listens for incoming messages, and publishes a test message. Requires your publish and subscribe keys. The listener publishes a message upon successful connection, and the publish result is checked for errors.

```csharp
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using PubnubApi;

PNConfiguration config = new PNConfiguration(new UserId("quickstart-user"))
{
    PublishKey = "YOUR_PUBLISH_KEY",
    SubscribeKey = "YOUR_SUBSCRIBE_KEY"
};

Pubnub pubnub = new Pubnub(config);

Subscription subscription = pubnub.Channel("quickstart-channel").Subscription();

subscription.onMessage += (Pubnub pn, PNMessageResult<object> message) =>
{
    Dictionary<string, object> payload =
        pubnub.JsonPluggableLibrary.DeserializeToDictionaryOfObject(message.Message.ToString());
    Console.WriteLine($"Message received: {payload["text"]}");
};

pubnub.AddListener(new SubscribeCallbackExt(
    delegate (Pubnub pn, PNStatus status)
    {
        if (status.Category == PNStatusCategory.PNConnectedCategory)
        {
            _ = PublishMessage();
        }
    }));

subscription.Subscribe<object>();

await Task.Delay(-1);

async Task PublishMessage()
{
    PNResult<PNPublishResult> result = await pubnub.Publish()
        .Channel("quickstart-channel")
        .Message(new Dictionary<string, object> { { "text", "Hello, PubNub!" } })
        .ExecuteAsync();

    if (result.Status.Error)
    {
        Console.WriteLine($"Publish failed: {result.Status.ErrorData.Information}");
    }
}
```

--------------------------------

### history() - Promise-based example

Source: https://www.pubnub.com/docs/sdks/javascript/api-reference/storage-and-playback

Example of using history() with promise-based syntax, including start and end timetokens.

```APIDOC
## history() - Sample code with promises

### Description
Demonstrates using history() with promise-based syntax to fetch messages from a channel with various parameters.

### Method
history()

### Parameters
- **channel** (string) - Required - The channel to fetch history from.
- **reverse** (boolean) - Optional - Set to true to traverse the timeline in reverse, starting with the oldest message first.
- **count** (number) - Optional - Number of messages to fetch (e.g., 100).
- **stringifiedTimeToken** (boolean) - Optional - Set to true to return timetokens as strings (default is false).
- **start** (string) - Optional - Start timetoken to fetch messages from.
- **end** (string) - Optional - End timetoken to fetch messages until.

### Request Example
```javascript
pubnub.history({
    channel: 'history_channel',
    reverse: true,
    count: 100,
    stringifiedTimeToken: true,
    start: '123123123123',
    end: '123123123133',
}).then((response) => {
    console.log(response);
}).catch((error) => {
    console.log(error);
});
```

### Response
Returns a Promise that resolves to the response object containing the retrieved messages.
```
Tokens:
Raw