DEV Community: PubNub

Documentation Release Notes - January 2026

PubNub Developer Relations — Fri, 30 Jan 2026 13:54:40 +0000

This article was originally published at https://www.pubnub.com/docs/release-notes/2026/january

January kicked off the year with a focus on developer experience improvements and continued modernization of our SDK documentation.

The biggest addition this month was a comprehensive JavaScript environment setup guide covering Node.js versions, package managers (npm, yarn, pnpm, bun), TypeScript configuration, and modern build tools. We also added Bun support to the JavaScript Chat SDK and improved installation instructions across all Chat SDKs.

On the SDK side, we continued the HereNow pagination work from November 2025, adding limit and offset parameters to Swift, JavaScript, and Kotlin Chat SDKs. We also completed the migration of Swift Chat SDK code snippets to use repository-sourced examples.

General 🛠️

Troubleshooting improvements

Type: Enhancement

We improved the troubleshooting documentation and JavaScript SDK status events based on user feedback.

The troubleshooting page now includes:

Clear HTTP status code tables for success and error codes
Detailed guidance on handling concurrent updates (HTTP 412) with ETag
Links to SDK-specific troubleshooting and status event references

Legacy provisioning API deprecation

Type: Enhancement

We updated the API limits documentation to clarify keyset limits for different account tiers and added deprecation notices for the legacy provisioning API.

Account Tier

Keyset Limit

Free

3 keysets (hard limit)

Starter

Unlimited

Pro

Unlimited

For programmatic keyset management, use the Admin API instead of the deprecated provisioning endpoints.

SDKs 📦

JavaScript environment setup

Type: New feature

We added a comprehensive JavaScript environment setup guide covering everything you need to configure a modern JavaScript environment for PubNub development.

The guide covers:

Node.js versions - PubNub's JavaScript SDK requires Node.js 20 or later for server-side applications
Package managers - Installation instructions for npm, yarn, pnpm, and bun
TypeScript configuration - Recommended tsconfig.json settings for PubNub projects
Build tools - Setup guides for Vite, Next.js, Remix, and Angular
ES Modules vs CommonJS - Guidance on import styles and Node.js ESM support
React Native - Setup for both Expo and React Native CLI

Package manager comparison:

Feature

npm

yarn

pnpm

bun

Bundled with Node.js

Yes

Install speed

Moderate

Fast

Very fast

Disk space efficiency

Moderate

Very efficient

Efficient

Workspaces support

Yes

TypeScript setup example:

1import PubNub from 'pubnub';2
3const pubnub = new PubNub({4    publishKey: 'your-publish-key',5    subscribeKey: 'your-subscribe-key',6    userId: 'your-user-id'7});

Bun support in Chat SDK

Type: New feature

We added Bun package manager installation instructions to the JavaScript Chat SDK documentation.

You can now install the JavaScript Chat SDK using Bun:

bun add @pubnub/chat

The JavaScript Chat SDK now supports all major package managers:

npm
yarn
pnpm
bun

npm install @pubnub/chat

yarn add @pubnub/chat

pnpm add @pubnub/chat

bun add @pubnub/chat

Chat SDK installation updates

Type: Enhancement

We updated installation instructions across all Chat SDK documentation with clearer npm and yarn guidance:

Each SDK landing page now includes consistent, easy-to-follow installation steps with all supported package managers.

HereNow pagination in Chat SDKs

Type: Enhancement

Continuing the HereNow pagination work from November 2025, we added limit and offset parameters to presence features in the Swift, JavaScript, and Kotlin Chat SDKs.

These parameters help you efficiently retrieve presence information for high-occupancy channels:

Parameter

Description

limit

Default:

100

Maximum number of occupants to return per channel.

offset

Default:

0

Zero-based starting index for pagination.

The whoIsPresent() method now supports pagination parameters:

1// Get a list of users present on a channel with pagination2const result = await channel.whoIsPresent({3    limit: 50,4    offset: 05})6
7console.log(`Users present: ${result.occupants.join(", ")}`)

We also expanded the threads documentation in JavaScript and Kotlin Chat SDKs to include additional methods for thread management.

Kotlin and Java connection pool config

Type: Enhancement

We documented connection pool configuration options in the Kotlin SDK and Java SDK API references.

These options help you fine-tune network performance for high-throughput applications.

Swift Chat SDK code snippets

Type: Enhancement

Following the Swift Chat SDK work from December 2025, we completed the migration of Swift Chat SDK documentation to use the EmbeddedCode component.

This update affects 42 documentation files across the Swift Chat SDK, including:

All code snippets are now pulled directly from the Swift Chat SDK GitHub repository, ensuring examples are always tested and up-to-date with the latest SDK version.

Illuminate 💡

Query Builder improvements

Type: Enhancement

Following the Query Builder introduction in December 2025, we enhanced the Query Builder documentation with predefined decisions information.

The updated documentation now includes visual examples for all four predefined query types:

Predefined Query

Purpose

Top N

Reward the top 10 users who are most engaged by message count

Bottom N

Incentivize users who are least engaged

Cross-posting spam

Detect users sending duplicate messages across multiple channels

Chat flooding spam

Detect users posting excessive or repetitive messages in a single channel

Each predefined query now shows the corresponding predefined decision template:

The documentation also includes new screenshots showing how to create decisions from query data fields.

Functions ⚙️

Export logs in Functions overview

Type: Enhancement

We added the export logs documentation to the Functions overview page. This information was previously only available in the Admin Portal Functions page and is now easier to discover when reading the serverless Functions documentation.

The documentation explains how to retain Function logs long-term using Events & Actions via Webhook or S3.

Documentation Release Notes - August 2025

PubNub Developer Relations — Wed, 10 Sep 2025 16:01:55 +0000

This article was originally published at https://www.pubnub.com/docs/release-notes/2025/august

In August, we made our docs more reliable to build with and easier to use day‑to‑day.

We clarified wildcard subscribe behavior and presence limits, reorganized encryption into first‑class SDK pages, and added connection management guidance for Chat SDKs.

Events & Actions gained a cleaner pagination model, a message‑types catalog, and clearer route input guidance. Unreal and PHP SDK docs now pull examples straight from GitHub, and BizOps adds an Auto Moderated messages review surface plus a clear path to choose between managed Auto Moderation and a self‑managed Functions route.

Finally, every docs page now has a machine‑friendly Markdown version (with quick buttons to copy or open) to make search, automation, and AI integrations smoother.

General 🛠️

Push notifications docs refinements

Type: Enhancement

We updated the iOS (APNS) and Android (FCM) docs to show how to exclude the sender from receiving a push for their own message (APNS: excluded_devices, FCM: pn_exceptions).

We also clarified that mobile push registration targets individual channels (not channel groups), and added a new HTTP 400 troubleshooting note with common causes.

SDKs 📦

Wildcard subscribe behavior and Presence constraints

Type: Enhancement

We clarified two areas in SDK and API docs.

First, calling subscribe() opens the connection but you still need event listeners to receive messages. For wildcard subscriptions, message objects include the sender in publisher, the actual channel in channel, and the wildcard match in subscription.

Second, Presence documentation now explicitly notes that wildcards aren’t supported for channel groups—use exact group names.

Encryption documentation reorganization and updates

Type: Enhancement

We moved Encryption to a first‑class API reference page in each SDK and refreshed the content so it’s easier to find and apply (for example, see JavaScript SDK).

The new pages cover configuring the SDK crypto module, the legacy 128‑bit vs. recommended 256‑bit AES‑CBC options, deprecation notes for method‑level cipher key parameters, and up‑to‑date encrypt/decrypt examples (including partial encryption where applicable).

We also added version compatibility warnings so older clients are handled correctly.

Connection management in Kotlin and JavaScript Chat SDKs

Type: Enhancement

We added connection management docs to the Kotlin and JavaScript Chat SDKs. They introduce a connection status listener (ONLINE/OFFLINE/ERROR) and methods to disconnect and reconnect subscriptions, with code samples and a recommended workflow for handling errors and restoring connectivity.

Updated logging and subscribe retry info in Dart SDK docs

Type: Enhancement

We documented logging and subscribe retry in the Dart SDK so you can see what’s happening and recover gracefully.

You can enable structured logs at the instance level or for specific code paths and adjust verbosity at runtime.

For resilience, configure the subscribe retry policy on the networking module—exponential by default, with linear or none available. Non‑subscribe requests don’t retry.

SDK‑sourced examples in PHP and Unreal SDK docs

Type: Enhancement

We kept rolling out repository‑sourced, always‑current examples and standardized rendering across SDKs.

Both PHP and Unreal SDK docs now pull examples directly from our GitHub repos, keeping snippets up to date, tested, and aligned with the SDK repositories.

Events & Actions ⚡

API documentation updates

Type: Enhancement

We updated the Events & Actions API reference with a standardized pagination model (page/size plus paging metadata), a new message types catalog (GET /v2/messages/message-types with filters), and clearer route input guidance using messageTypeName and version instead of messageTypeId.

We also added optional subkey and account_id parameters where relevant and refreshed examples and formatting across the docs.

Availability

The Events & Actions API isn’t publicly available. To request access, contact PubNub Support.

BizOps Workspace 🏢

Review auto‑moderated messages in Channel Monitor

Type: New feature

If you use Auto Moderation, Channel Monitor now has an Auto Moderated Messages section for reviewing content that was automatically blocked as spam, published with masked words, or reported for review.

You can filter by type (Blocked, Reported, Words masked) and mark items as Not spam to provide us with feedback for improving detection.

Auto Moderation: managed vs self‑managed

Type: New feature

Moderating user‑generated content on channels is now straightforward under one umbrella: Auto Moderation.

If you don’t already run a Before Publish or Fire Function on those channels and want a quick path, enable BizOps‑managed Auto Moderation to provision a dedicated moderation Function (of the Before Publish or Fire type) for you. This Function applies your spam detection and word masking policies, and sends outcomes to Channel Monitor for review—no code required.

If you already have a Before Publish or Fire Function running on the channel, follow an alternative path to create the moderation configuration in Auto Moderation and embed it inside your existing Function.

The second, "self‑managed" route (called Generate code for Functions in the Auto Moderation UI) uses the same moderation backend and your Auto Moderation configuration (configId) as the managed one, so results remain consistent and visible in Channel Monitor.

Because you can have only one Before Publish or Fire Function per channel, choose the self‑managed option when a managed Function would conflict.

The Auto Moderation docs walk through prerequisites, setup, where moderation outcomes appear (Channel Monitor), and how to move from managed simplicity to self‑managed control when your app requires it.

Illuminate 💡

Customize embedded Illuminate UI

Type: Enhancement

If you embed Illuminate UI on an external site, you can now theme it to align with your brand. The docs include a complete iframe example and explicit theming options.

You can pass six hexadecimal color parameters in the embed URL: primaryColor, secondaryColor, backgroundColor, surfaceColor, textPrimaryColor, and textSecondaryColor.

<iframe src="https://oem.pubnub.com/embed/dashboards?embed=true&token=<token>&primaryColor=d02129&secondaryColor=007594&backgroundColor=ffffff&surfaceColor=f8f9fa&textPrimaryColor=212529&textSecondaryColor=6c757d" />

Other 🌟

Markdown (.md) versions for every docs page

Type: Improvement

Large language models work best with clean, predictable content. Markdown gives us structured headings, lists, tables, code fences, and admonitions that are easy to split into chunks for embeddings and retrieval. It also reduces page “noise,” keeps anchors stable, and produces deterministic diffs that automation can trust.

Why the shift toward Markdown for machines/AI:

Clean, structured text is easier to chunk for embeddings/RAG and remains stable across builds.
Less noise than HTML (fewer scripts/DOM artifacts) and more predictable anchors/links improve retrieval accuracy.
Deterministic, diff‑friendly outputs improve automated ingestion, QA, and syncing with source repos.
Fewer custom widgets means fewer parsing failures and more usable content for AI tools and site search.

To support this, we now publish a machine‑readable Markdown version of every docs page at the same URL with a .md suffix. For example, you can now access the Markdown content of https://www.pubnub.com/docs/general/basics/set-up-your-account under https://www.pubnub.com/docs/general/basics/set-up-your-account.md.

Access is simple. Two buttons now appear at the top of each page:

Copy Markdown — copies the page’s .md source to your clipboard
Open as Markdown — opens the .md variant of the current page

You can also append .md to any docs URL to load the Markdown version directly.

Documentation Release Notes - July 2025

PubNub Developer Relations — Wed, 30 Jul 2025 13:37:50 +0000

This article was originally published at https://www.pubnub.com/docs/release-notes/2025/july

July was packed with partner empowerment features, enhanced security documentation, and continued SDK improvements that make PubNub easier to integrate and manage.

The biggest highlight this month is our official public Postman collection for all PubNub Core APIs — created directly in response to your feedback and search patterns we've observed in our documentation.

We also delivered comprehensive Partner Portal documentation for customer management and Illuminate UI embedding guides for OEM (Original Equipment Manufacturer) integrations, plus made Auto Moderation documentation publicly available.

On the development experience front, we've added a Run in Postman button throughout our REST API documentation, created a What's New section on our homepage, and continued our SDK-sourced code snippets rollout with Unity support.

General 🛠️

New Partner Portal documentation

Type: New feature

We've added comprehensive documentation for the Partner Portal, a feature that lets PubNub partners manage their end customers directly through the Admin Portal.

Partners can create customer entries, assign specific apps and keysets, and enable controlled access to Illuminate functionality. We've also documented how to embed Illuminate UI directly into partner applications for seamless OEM integrations.

Enhanced channel naming guidelines

Type: Enhancement

We've updated our channel naming documentation with stronger recommendations for using ASCII characters in channel names, along with an enhanced channel name validator that now warns you when using non-ASCII characters like emojis or international characters.

The improvements include better cross-platform compatibility guidance and real-time validation feedback to help prevent channel naming issues across different SDKs and platforms.

Comprehensive Presence documentation overhaul

Type: Enhancement

We've expanded our Presence documentation with a comprehensive new section on Implicit vs. explicit Presence events that explains PubNub's timer-based tracking system, configuration settings (presenceTimeout vs heartbeatInterval), cost vs accuracy trade-offs, and real-world configuration scenarios for different application types.

The new documentation also clarifies that implicit heartbeats can be disabled through the Presence Management GUI in the Admin Portal — addressing your feedback. We also added important billing transparency to the Presence configuration table, noting that the Generate Leave on TCP FIN or RST option can result in additional billable events.

Security documentation updates

Type: Enhancement

We've made helpful additions to our data security documentation that enterprise customers have been asking about. We clarified that all connections use TLS 1.2 for secure communication, and added guidance on how Pro customers can access SOC 2 and other compliance reports directly from the Admin Portal (or contact support if needed).

Platform limits and configuration updates

Type: Enhancement

We've updated several key areas of our platform documentation to make sure you have accurate, current information when planning your PubNub implementations. The channel limits documentation now recommends multiplexing between 10 and 50 channels (updated from "no more than 30"), and clarifies that URI length limits are 32 KiB. We also refreshed message storage documentation with current message count limits and usage patterns.

We also clarified an important detail in our heartbeat configuration documentation — the minimum supported value for heartbeat intervals is 3 seconds due to server constraints.

These updates ensure you have accurate information for planning and configuring your PubNub implementations without hitting unexpected limitations.

BizOps Workspace 🏢

Auto Moderation documentation made publicly available

Type: New feature

We've made our Auto Moderation documentation publicly available so you can understand and plan for automated message moderation in your chat applications.

The Auto Moderation documentation walks you through the two main capabilities:

AI-powered spam detection — automatically block (prevent from being published) or report problematic messages
Word masking functionality — censor predefined forbidden words

Both features work through an intuitive setup wizard that guides you through configurable moderation rules.

Everything runs on Functions v2, which means it's reliable and scales with your application's needs. The feature itself is currently in beta and available upon request by contacting PubNub Support or Sales — read the full documentation to understand how it works before requesting access.

SDKs 📦

Unity SDK with GitHub-sourced code examples

Type: Enhancement

Continuing our SDK-sourced code snippets rollout from June 2025, we've added comprehensive working code examples to our Unity SDK documentation.

All examples are pulled directly from our GitHub repositories, ensuring they're always tested and current with the latest SDK versions. The Unity documentation now includes complete API reference examples across all major features.

JavaScript Subscription Sets automatic subscription behavior

Type: Enhancement

We've documented the automatic subsequent subscriptions behavior for JavaScript SDK Subscription Sets — a JavaScript-only feature where adding subscriptions to an existing active set automatically subscribes to them without additional calls.

The enhanced documentation includes new code examples and better organization to make subscription set modification methods easier to find and use.

Access Manager v3 Gradle configuration

Type: Enhancement

We've added Gradle configuration details for Access Manager v3 in our Kotlin and Java Access Manager documentation to help with Android and JVM-based project integration.

Events & Actions ⚡

New dedicated Events & Actions payloads page

Type: New feature

We've created a comprehensive new Events & Actions Payloads documentation page that centralizes all payload examples with new schema v2.1 fields for Mobile Push Notifications and Membership CRUD operations. We also converted the webhook payload table into expandable JSON blocks and improved existing examples for better accuracy.

Other 🌟

Official public Postman collection for PubNub Core APIs

Type: New feature

We've launched our official public Postman collection for all PubNub Core APIs, developed in direct response to user feedback and documentation search patterns that showed you needed better ways to test and explore our REST endpoints.

The collection is now available through our REST API documentation and directly at PubNub's Postman Workspace. What makes this collection special is that it includes complete API coverage for all PubNub Core services with pre-configured examples for every endpoint. Everything comes with an easy testing environment that has demo keys ready to use, plus API documentation directly in Postman so you don't have to switch back and forth between tools.

This makes PubNub APIs more accessible and provides a standardized way to explore our REST endpoints.

Enhanced documentation homepage

Type: Enhancement

We've added a dedicated What's New section to our docs homepage that highlights the latest PubNub features and resources, making it easier to discover new features and stay current with platform updates.

Run in Postman button integration

Type: Enhancement

We've made testing our REST APIs incredibly easy by adding Run in Postman buttons directly in the Try it out sections of every API endpoint page. Now when you're reading about a specific API method and want to test it immediately, you'll see a button that lets you fork our official Postman collection with just one click.

Everything comes pre-configured with demo keys and environment variables, so you can start testing immediately without any setup friction.

This creates a seamless bridge between reading our documentation and hands-on API exploration. Instead of copying endpoints, finding API keys, and setting up your own requests, you can go from "I wonder how this works" to "Let me try it now" in seconds.

Documentation Release Notes - June 2025

PubNub Developer Relations — Wed, 09 Jul 2025 13:48:54 +0000

This article was originally published at https://www.pubnub.com/docs/release-notes/2025/june

June was all about making our SDKs easier to work with and giving you better examples to learn from.

The big highlight this month? We launched a brand new Sports, Media & Entertainment documentation section complete with an interactive demo showcasing real-time sports experiences. Plus, we've been busy rolling out GitHub-sourced code snippets across Swift, C#, and JavaScript SDKs, so you know the examples will always be up-to-date!

We also continued our mission to improve Getting Started guides for Rust and JavaScript, expanded Chat SDKs with Platform Support docs, and added helpful troubleshooting guides for mobile development and Firebase configuration.

General 🛠️

Enhanced REST API documentation structure

Type: Enhancement

We gave our REST API documentation a makeover with better navigation and more descriptive page names for improved discoverability.

What's new:

Page titles that actually tell you what each API endpoint does
Cleaner navigation that makes sense
Better linking between related endpoints
Much easier to find what you're looking for

Whether you're just getting started or looking for advanced configuration options, finding the right REST API endpoint should be much smoother now.

Improved Subscribe Filtering documentation

Type: Enhancement

We reorganized our Subscribe Filtering documentation to put filtering information where it belongs - in the subscribe docs rather than scattered across different pages.

This restructuring makes it much easier to find filtering guidance when you're working with subscriptions, with all the relevant information now properly organized in one place.

These changes help you find filtering information more intuitively and understand how to implement filtering strategies in your subscribe operations.

Enhanced Chat SDK authentication documentation

Type: Enhancement

We added authentication examples to the Chat SDK configuration documentation, including how to use the authKey parameter with Access Manager.

The updates include:

New authKey configuration parameter documentation
Server-side code example for generating tokens with Access Manager
Clear guidance on initializing Chat SDK with authentication

These additions make it easier to implement Access Manager authentication in your chat applications.

Message actions terminology standardization

Type: Enhancement

We standardized terminology across all documentation to clarify the difference between "reactions" and "actions", updating most references to use "actions" for consistency. We also added clearer channel ID requirements for Pub/Sub API usage.

This comprehensive update touched:

General message documentation to use consistent "actions" terminology
All SDK API reference documentation for message actions
Chat SDK documentation across all platforms
REST API documentation with enhanced channel ID clarification for Pub/Sub API operations

This standardization makes it much clearer when we're referring to the broader concept of message actions versus specific reaction implementations, while also providing better guidance on channel ID requirements for API usage.

Enhanced troubleshooting documentation

Type: Enhancement

We added new troubleshooting guides for key PubNub services:

Firebase Cloud Messaging: Better FCM setup instructions and troubleshooting for push notifications
Admin Portal: New guide for registration and reCAPTCHA issues

These guides tackle common developer pain points with step-by-step solutions for configuration and integration challenges.

SDKs 📦

SDK-sourced code snippets across multiple SDKs

Type: Enhancement

Building on our work from previous months, we rolled out updated code snippets for multiple SDKs. All examples are pulled directly from our GitHub repositories, so they're always fresh and proven to work.

This month's updated SDKs include:

These updated snippets sync automatically with our SDK repositories, so you always get tested, working code examples that match the latest SDK versions.

Continued Getting Started guide improvements

Type: Enhancement

We kept up our systematic approach to Getting Started guides with updates for:

Rust SDK: Complete Getting Started guide following our standardized format
JavaScript SDK: Refined and updated Getting Started experience

Both guides follow our established pattern:

Setup and installation
Creating a PubNub instance with your keys
Subscribing to channels
Publishing messages
Handling received messages

This ensures consistent onboarding across all our SDKs, no matter which programming language you prefer.

Enhanced Chat SDKs

Type: Enhancement

Chat SDK documentation expanded to support Platform Support pages (similar to those available in the Core SDKs) and improved capabilities:

Unreal Chat SDK: Added comprehensive documentation for the event engine, enabling more sophisticated event handling in Unreal Engine applications
Kotlin Chat SDK: Enhanced documentation with additional features and better examples for Android development
Platform support documentation: Updated general platform support information across all Chat SDKs (JavaScript, Kotlin, Swift, Unity, and Unreal)

These improvements make integrating chat functionality into games and applications much easier, with better support for platform-specific features.

SDK-specific troubleshooting documentation

Type: Enhancement

We added troubleshooting guides for specific SDKs to tackle common development challenges:

Kotlin SDK: Added ProGuard configuration troubleshooting for common Android build issues
Unity SDK: Updated mobile build configuration guidance for Android and iOS deployment

These guides provide step-by-step solutions for SDK-specific configuration issues and platform challenges.

Improved Presence configuration documentation

Type: Enhancement

Presence documentation got clearer with better guidance on configuration and event handling:

Custom Presence events: Updated terminology from "custom Presence event" to "state change event" for clarity across all SDK documentation
Default Presence configuration: Better explanations of default Presence settings and how to customize them, including updates to BizOps Workspace Presence Management

These improvements help you understand and implement Presence features more easily, with clearer explanations of when and how Presence events are triggered.

Other 🌟

Sports, Media & Entertainment documentation organization

Type: New feature

We launched a comprehensive new Sports, Media & Entertainment documentation section with industry-specific guidance and real-world examples.

This new documentation includes:

Interactive demo: A live demonstration showcasing real-time sports experiences with synchronized stats, live chat, and fan engagement features
Industry-specific use cases: Tailored examples for sports scoring, media streaming, and entertainment platforms
Best practices: Implementation guidance for common sports and entertainment scenarios
Real-time features: Documentation for live polls, score predictions, commentary synchronization, and fan behavior management

This focused content helps developers in the Sports, Media & Entertainment industry find relevant examples and implementation guides quickly, with content designed specifically for real-time sports updates, media streaming, and entertainment platforms.

Homepage enhancements with "What's New" badge

Type: Enhancement

We added a "What's New" badge system to our homepage and release notes overview page. This makes it much easier to spot recent updates and new features across PubNub documentation.

The badge system highlights:

New features and major updates
Recently updated SDK documentation
Important announcements and changes

Now you can stay current with PubNub's latest developments and won't miss important updates that might affect your applications.

Documentation Release Notes - May 2025

PubNub Developer Relations — Tue, 17 Jun 2025 08:54:28 +0000

This article was originally published at https://www.pubnub.com/docs/release-notes/2025/may

This May, we focused on making our documentation more practical and easier to use across different SDKs and platforms.

We continued our work on Getting Started guides and basic usage examples that we started in previous months. Our Functions documentation got a refresh with better organization between v1 and v2, plus clearer explanations of wildcard patterns. We also added documentation for our new PubNub MCP Server, which lets AI IDEs, like Cursor or Windsurf, work directly with your PubNub apps.

On the SDK side, we improved Objective-C documentation with better examples and updated our Java docs to use code examples straight from our GitHub repos.

General 🛠️

New PubNub MCP Server documentation

Type: New feature

We've added documentation for the PubNub MCP Server, a new tool that lets AI tools interact directly with your PubNub applications through the Model Context Protocol (MCP).

With this integration, AI assistants can:

Publish messages to channels
Subscribe to channels and get real-time updates
Pull message history
Handle user presence
Work with channel groups

The MCP Server bridges AI assistants and PubNub's real-time network, opening up new possibilities for AI-powered apps and automated workflows.

MQTT documentation removed

Type: Adjustment

We've removed MQTT documentation from our docs as this integration is no longer actively supported. This cleanup keeps our documentation focused on actively maintained SDKs and integrations.

Functions ⚙️

Better Functions v2 documentation with wildcard support

Type: Enhancement

We've improved our Functions documentation with better organization between Functions v1 and v2.

Here's what's new:

Wildcard pattern explanations: Clear documentation on using wildcard patterns in channel names and event triggers
Better v1 vs v2 separation: Organized docs to help you understand which version you're using and what features are available
Improved migration guidance: Better information for moving from Functions v1 to v2

These updates make it easier to use Functions v2 features like advanced pattern matching and flexible event handling.

SDKs 📦

Better Objective-C SDK documentation and examples

Type: Enhancement

Continuing our work from previous months on basic usage examples, we've updated the Objective-C SDK documentation with practical, ready-to-use examples throughout the API reference.

What's included:

Complete basic usage examples for all major features
Better code samples for publish/subscribe operations
Improved documentation for Access Manager, channel groups, and presence features
Clearer examples for file handling and message actions

Now Objective-C developers have working examples for all PubNub features, making integration faster and more straightforward.

Java SDK with GitHub-sourced code examples

Type: Enhancement

We've updated our Java SDK documentation to use code examples pulled directly from our GitHub repositories. This ensures all examples are tested and current with the latest SDK versions.

This approach means the code examples in our docs always reflect working, tested implementations, so you won't run into outdated or broken code snippets.

More Getting Started guide improvements

Type: Enhancement

Building on our April work to standardize Getting Started guides, we've continued refining the Swift SDK Getting Started guide and Unity SDK basic usage examples.

These updates ensure consistent onboarding across all our SDKs, following the same clear pattern:

Setup and installation
Creating a PubNub instance with your keys
Subscribing to channels
Publishing messages
Handling received messages

JavaScript Chat SDK method rename

Type: Enhancement

We've updated the JavaScript Chat SDK documentation to reflect the renaming of getUnreadMessagesCounts() to fetchUnreadMessagesCounts() for better consistency.

The new method also returns a more structured response with countsByChannel array and pagination information.

The previous method remains available but is now deprecated.

Other 🌟

Site experience improvements

Type: Enhancement

We've made several improvements to the documentation site:

Mobile menu fixes: Fixed navigation issues on mobile devices for better accessibility
Search improvements: Made the search feature more accurate and relevant
Interface polish: Various small improvements to tooltips and navigation elements

These updates make browsing our documentation smoother across all devices and platforms.

Documentation Release Notes - April 2025

PubNub Developer Relations — Thu, 15 May 2025 14:02:00 +0000

This article was originally published at https://www.pubnub.com/docs/release-notes/2025/april

This April, we've focused on making our documentation more practical and easier to use.

We've updated Getting Started guides for multiple SDKs to provide clearer onboarding paths, added comprehensive documentation for status events across our C-Core, Rust, JavaScript and other SDKs, and improved support for custom events and event listeners.

Plus, we've enhanced our REST API documentation with better SEO-optimized titles and links, making it easier for you to find the information you need.

General 🛠️

Improved REST API documentation titles & links for SEO

Type: Enhancement

We've made significant improvements to our REST API documentation titles and internal links to enhance searchability and make it easier for you to find the information you need.

These updates include:

More descriptive page titles that better reflect the content
Optimized keywords in documentation headings
Improved cross-linking between related API endpoints
Clearer navigation paths throughout the REST API documentation

This work ensures that whether you're searching on our site or through external search engines, you'll find the relevant REST API documentation more quickly and intuitively.

Updated App Context optional fields in REST API docs

Type: Enhancement

We've updated our REST API documentation to clarify which fields are optional when working with App Context. This update provides better guidance on the minimum required parameters for various operations, making it easier to work with our APIs without including unnecessary data.

The documentation now clearly indicates which fields can be omitted in your API requests, helping you create more concise and efficient API calls when working with channels, users, and memberships through the REST API.

Updated MAU limit information

Type: Adjustment

We've updated the documentation regarding Monthly Active User (MAU) limits to provide clearer guidance on the maximum number of users that can authenticate simultaneously on a single device.

This information is critical for developers building applications where multiple users might share the same device, ensuring you can plan your architecture appropriately within our platform's constraints.

SDKs 📦

Improved status event documentation across SDKs

Type: Enhancement

We've added detailed documentation for status events across multiple SDKs to help you better understand and handle various connection states and error conditions. This documentation is now available for:

Each SDK's documentation now includes:

Visual flowcharts showing possible connection states
Detailed descriptions of each status type
When each status was introduced or changed
Code examples showing how to properly handle status events
Error categorization to help with troubleshooting

This enhancement makes it much easier to build reliable applications that gracefully handle network issues, reconnection scenarios, and various error conditions.

Subscribe loop and Event Listeners updates

Type: Enhancement

We've updated our documentation for event handling across multiple SDKs, with a particular focus on the new standardized subscribe loop architecture. This update covers:

Standardized event listeners for message, signal, presence, and file events in JavaScript, Swift, Rust, and C-Core SDKs
Custom event payloads for app-specific events in Chat SDKs (JavaScript, Kotlin, Swift, Unreal)
Improved error handling and event type discrimination in subscription status events

Updated Getting Started guides for multiple SDKs

Type: Enhancement

We've completely revamped the Getting Started guides for multiple SDKs to provide a more consistent, user-friendly experience across our documentation. The updated guides include:

Platform-specific installation instructions
Complete, copy-paste ready code examples
Clear step-by-step progression
Required keyset configuration information

The following SDKs now have enhanced Getting Started guides:

Each guide now follows a consistent pattern:

Setup and installation
Creating a PubNub instance with your keys
Subscribing to channels
Publishing messages
Handling received messages

This standardized approach makes it easier to get started with any PubNub SDK, regardless of your preferred programming language or platform.

Membership type and status in Unreal and Unreal Chat SDKs

Type: Enhancement

We've updated our documentation for the Unreal SDK and Unreal Chat SDK to better support membership type and status fields in user-channel relationships. These updates include:

Added support for Type and Status fields in memberships
Improved documentation on how to use membership types for role-based access
Enhanced examples showing proper membership management
Unreal Chat SDK
Unreal SDK

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

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

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

// Get an existing user
UPubnubUser* User = Chat->GetUser("support_agent_15");

// Find memberships for a specific channel
FString Filter = "channel.id == 'high-priority-incidents'";
FPubnubMembershipsResponseWrapper Memberships = User->GetMemberships(Filter);

#include "Kismet/GameplayStatics.h"
#include "PubnubSubsystem.h"

void AMyActor::GetMemberships()
{
    UGameInstance* GameInstance = UGameplayStatics::GetGameInstance(this);
    UPubnubSubsystem* PubnubSubsystem = GameInstance->GetSubsystem<UPubnubSubsystem>();

    FString UserID = "agent-123";

    // UserID needs to be set for any Pubnub Operations
    PubnubSubsystem->SetUserID(UserID);

    // Bind response delegate
    FOnGetMembershipsResponse OnGetMembershipResponse;

The Type field supports categorizing memberships (such as "moderator", "admin", "guest"), while the Status field helps track membership states (like "active", "pending", "blocked"). These fields make it easier to implement role-based permissions and track user engagement in your Unreal applications.

Other 🌟

Table tooltips improvement

Type: Enhancement

We've improved the tooltip functionality in our documentation tables to provide clearer, more contextual information when hovering over table elements.

The improved tooltips now:

Appear with a blurred, centered background that ensures full visibility
Remain completely visible regardless of their position in the table
No longer get cut off at table edges or when near page boundaries
Provide clearer visual distinction between the tooltip and the underlying content

You'll find these enhanced tooltips throughout our API reference tables, making it easier to understand the available options at a glance.

Documentation Release Notes - March 2025

PubNub Developer Relations — Wed, 09 Apr 2025 09:52:24 +0000

This article was originally published at https://www.pubnub.com/docs/release-notes/2025/march

This March, we've focused on enhancing both functionality and usability across our documentation.

Security gets a boost with our new secret key rotation feature, while developers will appreciate the async/await patterns in our Swift Chat SDK and improved table layouts for API references.

We've also documented adding practical tools like customizable table settings in BizOps Workspace and more granular control over action execution in Illuminate.

Take a look at what's new!

General 🛠️

Optimized filtering for large data volumes

Type: Enhancement

This month, we improved our documentation to help you work with large volumes of data more efficiently. If your application has thousands of channels or users, you'll now find helpful performance tips throughout our docs.

We added guidance on optimal filtering methods in the BizOps Workspace, recommending the use of exact ID equality filters instead of pattern matching when searching through applications with many channels or users.

You can find these recommendations in the Channel Management, User Management, and general Filtering documentation sections.

New Admin Portal navigation

Type: Enhancement

We've recently refreshed our Admin Portal's left navigation and updated all the documentation resources to match it.

The Apps section has also been renamed to Apps & Keysets, bringing keyset management right where you need it instead of in a separate section.

All screenshots throughout our docs now reflect these changes, so what you see in the docs matches exactly what you'll find in the Portal.

Secret key rotation

Type: New feature

We've added a new security feature for our paid plans: secret key rotation. This enhancement lets you manage up to five secret keys with automatic expiration dates, strengthening your security when using services like Access Manager.

You'll find this feature in the Admin Portal under your keyset settings, where you can easily set expiration dates for your secret keys using our new date picker.

SDKs 📦

Improved metadata for Objective-C SDK

Type: New feature

We've updated our Objective-C SDK docs with new features that give you better control over your data:

Added type and status fields for users, channels, and memberships so you can better organize and track their states.
Implemented ifMatchesEtag support to prevent update conflicts when multiple systems try to change the same data.

NSArray<NSDictionary *> *channels = @[
  @{ 
    @"channel": @"channel1", 
    @"status": @"active",
    @"type": @"public", 
    @"custom": @{ @"role": @"moderator" } 
  }
];

PNSetMembershipsRequest *request = [PNSetMembershipsRequest requestWithUUID:@"uuid"
                                                                   channels:channels];
[self.client setMembershipsWithRequest:request 
                          completion:^(PNSetMembershipsStatus *status) {
    // Handle completion
}];

Custom origin arrays in JavaScript SDK

Type: Enhancement

We've updated our JavaScript SDK documentation to show that you can use an array of strings for the origin configuration parameter, giving you more flexibility in how you connect to PubNub.

Previously, the origin parameter only accepted a single string value, but now you can provide multiple origin domains as an array:

pubnub.PubNub({
  // Other config options...
  origin: ['ps1.example.com', 'ps2.example.com']
});

This enhancement is useful for implementing your own failover strategy or connecting to multiple custom domains.

New C# logging system

Type: Enhancement

We've updated our C# SDK docs with a completely revamped logging system. The key improvements include:

New logging interface: Replaced the deprecated PubnubLog and LogVerbosity with a new LogLevel parameter and IPubnubLogger interface.
Multiple severity levels: Added granular log levels (Trace, Debug, Info, Warn, Error) replacing the previous simple verbosity options.
Custom logger support: Added a new SetLogger method allowing developers to implement and attach their own logger implementations.
Better error handling examples: Updated all code examples to use try/catch blocks and proper async/await patterns.
Request execution guide: Added a new partial template explaining best practices for executing API requests with proper error handling.

The docs also include a complete sample implementation of a console logger and shows how to properly configure and remove loggers.

This update makes debugging and troubleshooting C# applications much more powerful and flexible.

ETag support in Dart SDK

Type: New feature

We've added ETag support to our Dart SDK, making your apps safer when multiple users might update the same data at once.

When you set metadata for users or channels, you can now include an ifMatchesEtag parameter. This works like a safety check - it ensures your updates only happen if no one else has changed the data since you last retrieved it.

For example, if two people try to edit a user profile at the same time, ETags help prevent one person's changes from accidentally overwriting the other's.

The Dart SDK docs now include this parameter in both the UUID and channel metadata methods, showing how to use it in your Dart apps.

// First, retrieve user metadata which includes the ETag
final result = await pubnub.objects.getUUIDMetadata(
  uuid: 'user-123',
  includeCustomFields: true
);

// Store the ETag from the response
final etag = result.metadata?.eTag;

// Update user metadata with ETag to prevent conflicts
if (etag != null) {
  try {
    await pubnub.objects.setUUIDMetadata(
      uuid: 'user-123',
      name: 'Updated Username',

Invites now supported in public chats

Type: Enhancement

We've updated our Chat SDK documentation to remove the limitation that previously stated invites weren't supported in public channels. This change affects all our Chat SDK platforms including JavaScript, Kotlin, Swift, Unity, and Unreal.

Previously, our docs warned that invitation features were disabled in public chats, and attempting to use them would trigger an error message. We've now removed these warnings as implementation has changed, meaning you can now invite users to public channels just like you would with private or group conversations.

This update in Chat SDKs gives you more flexibility in how you manage user access to your public chat spaces, allowing for a more consistent invitation experience across all channel types in your chat applications.

Comprehensive Access Manager docs for Chat SDKs

Type: Enhancement

We've added detailed security documentation for our Chat SDKs to help you correctly set up permissions in your chat apps.

The update provides a clear mapping between Chat SDK methods and the specific Access Manager permissions they require.

The updated Security and permissions page now includes comprehensive tables showing exactly which permissions are needed for every method across all Chat SDK objects - Chat, Channel, User, Membership, Message, ThreadChannel, ThreadMessage, and MessageDraft.

For example, you can now easily see that to use the SendText() method, your users need Write permission on the channel, or that creating a direct conversation requires multiple permissions including Get, Update, Join, and Write on specific resources.

PHP SDK transport layer improvement

Type: Enhancement

The PHP SDK has been updated with a major change to how it handles HTTP requests. We've added a detailed migration guide to help you update your code from version 7.x to 8.x.

The key changes include:

Replacing the outdated custom transport layer with a standardized PSR-18 compliant implementation.
Using Guzzle HTTP client as the default, which provides better performance and compatibility.
Changing the method to customize HTTP handling from setTransport() to setClient().

If you're using the default transport layer, you won't need to make any changes to your code. However, if you've implemented a custom transport, you'll need to update it to follow PSR-18 standards.

Swift Chat SDK now supports async/await

Type: Enhancement

We've updated our Swift Chat SDK documentation to use Swift's newer async/await feature, making your code much simpler to write and read:

No more nested callbacks or complex error handling chains.
Use try/catch instead of managing result types.
Code that reads more naturally from top to bottom.
Aligns with how most Swift developers write code today.

Task {
  if let channel = try await chat.getChannel(channelId: "support") {
    let timetoken = try await channel.sendText(
      text: "Hello World",
      shouldStore: true
    )
    print("Message sent at \(timetoken)")
  }
}

This update affects all our Swift code examples throughout the docs. While you can still use the older completion handler style if you prefer, we believe you'll find this new approach much easier to work with.

Retired SDKs

Type: Deprecation

We've updated our documentation to mark four SDKs as no longer officially supported: Lua, Redux, Cocoa Swift, and Cocoa Objective-C.

Instead of removing them completely, we're inviting you to take them forward.

Each SDK page now includes a clear warning banner explaining that PubNub no longer maintains these SDKs, but also provides a direct link to their related GitHub repositories where you can contribute improvements and fixes. We've also updated our main SDKs list page and navigation to reflect these changes.

While we're focusing our resources on our most widely-used SDKs, we understand that you may still be using these technologies and want to provide a path for community-driven support.

Improved Basic Usage examples

Type: Improvement

We've updated the first Basic Usage example in each documentation page across multiple SDKs to make them truly copy-paste ready. These changes have been made to:

These updated first examples now include everything you need: all necessary imports, variable declarations, proper error handling, and complete context.

While other examples in the documentation may still focus just on the PubNub-specific code, these first examples serve as complete templates you can use to understand how to properly set up and use the SDK in your projects. This makes it easier to get started and provides a reference point for implementing the other examples shown later in the documentation.

More to come!

Redesigned Getting Started guide for Kotlin SDK

Type: Improvement

We've completely redesigned the Getting Started guide for our Kotlin SDK to make it more user-friendly and practical. This update is part of our broader effort to improve all SDK documentation with comprehensive, copy-paste ready code examples.

The new guide features:

Platform-specific guidance
Complete working examples
Clear step-by-step structure with a logical progression from setup to publishing and subscribing to messages
Added tooltips for key terms and better organized sections

We've also simplified the overall structure to remove repetition and focus on what developers actually need. The guide now follows a practical flow: get your keys, install the SDK, initialize PubNub, subscribe to messages, and publish messages - with complete code examples at each step.

This new template will serve as a model for updating other SDK Getting Started guides, ensuring a consistent, easy-to-follow experience across our entire SDK docs.

Insights 📊

Channel patterns in PubNub Insights API

Type: New feature

We've added API documentation for the channel patterns feature in PubNub Insights.

Premium customers can now programmatically filter and retrieve analytics data for specific channel patterns using the Insights API, making it easier to analyze targeted subsets of channels in their applications.

BizOps Workspace 🏢

Customizable table settings in Channel and User Management

Type: New feature

Channel Management and User Management sections under BizOps Workspace have been enhanced by adding table settings to each view.

This option lets you adjust the way tables display information.

Table settings include:

Columns tab: Toggle visibility for ID, Name, Status, Type, and Updated.
Row height tab for selecting relaxed, regular, and condensed row view.
Column management: Pinning (pin icon) and reordering (up/down arrows).

File upload in Channel Monitor

Type: New feature

We added documentation for a new file upload feature in the Channel Monitor tool within BizOps Workspace.

This enhancement allows moderators to:

View files uploaded by chat members in messages.
Upload their own files to messages.
Work with files regardless of which SDK (Core or Chat) the app is built with.

Illuminate 💡

Action execution interval

Type: Enhancement

We added a new feature to Illuminate Decisions that lets you control how often actions run.

Instead of triggering actions every single time conditions are met, you can now set limits. You can choose to run actions always, just once within a time period, or once per unique condition value.

If you need to start fresh, you can reset these limits with a button click without turning off the whole decision.

Other 🌟

Improved table layout

Type: Enhancement

We redesigned how tables display in our documentation to improve readability, especially for API references.

Instead of showing all columns side-by-side requiring horizontal scrolling, we now present essential information prominently while moving supporting details into a compact format below the parameter name.

Required parameters are clearly marked with red asterisks, and the responsive design automatically adjusts to different screen sizes for better viewing on all devices.

New tab navigation

Type: Enhancement

Last but not least, we redesigned our documentation tabs with a more intuitive and visually appealing interface following user feedback that the previous design wasn't clearly recognizable as interactive tabs.

The new tab components feature clear visual indicators for active tabs with a modern blue highlight and subtle hover effects for better interactivity. Tabs now include a clean divider line that clearly separates the tab navigation from content.

Documentation Release Notes - February 2025

PubNub Developer Relations — Mon, 17 Mar 2025 10:19:24 +0000

This article was originally published at https://www.pubnub.com/docs/release-notes/2025/february

As the year is getting underway, we've been busy not only enhancing the existing docs based on your feedback but also adding a bunch of new updates following new product releases.

Here’s a sneak peek:

Admin Portal – We've introduced secret management and launched a public demo, so you can explore PubNub features without needing an account.
SDKs – Added membership type support for Python and PHP SDKs along with eTag support across more SDKs for greater data consistency.
Events & Actions – You can now use vault secrets in webhook headers, boosting your app's security.
BizOps Workspace – The UI got a facelift with clearly marked read-only internal objects for better navigation.
Illuminate – We’ve expanded your ability to view action history, removing previous limits for easier tracking.
Miscellaneous – We addressed several feedback tickets, enriching our docs with new examples and clarifications.

Scroll down to dive into all the updates and see what’s new and improved.

General 🛠️

Secret management in the Admin Portal

Type: New feature

The Apps & Keysets section in the Admin Portal now has a new Manage secrets section that allows users with the Keyset Admin, Account Owner, and Account Admin roles to create, update, and delete secrets.

You can use these secrets in Functions to authenticate and secure connection with third-party services.

Public Admin Portal demo

Type: New feature

Want to browse through the Admin Portal without creating an account? Want to see PubNub features instead of just reading about them in the docs?

We released Public Demo that gives you insights into sample objects for all PubNub features available in the Admin Portal (apps, keysets, Functions, Business Objects, Users, Dashboards, and many more).

All PubNub objects are read only and demonstrate a Transport & Logistics use case.

SDKs 📦

Membership type (follow-up)

Type: New feature

To follow up on last month's updates in the Ruby SDK, we added support for the membership type in the Python, PHP, and Dart SDKs to let you categorize memberships more easily.

Python
PHP
Dart

pubnub.get_memberships() \
    .include(MembershipIncludes(custom=True, channel=True, channel_custom=True)) \
    .uuid("Some UUID").sync()

$includes = new PNMembershipIncludes();
$includes->channel()->channelId()->channelCustom()->channelType()->channelStatus()->custom()->status()->type();

$addMembership = $this->pubnub->setMemberships()
    ->userId($this->user)
    ->memberships([
        new PNChannelMembership($this->channel1, ['BestDish' => 'Pizza'], 'Admin', 'Active'),
        new PNChannelMembership($this->channel2, ['BestDish' => 'Lasagna'], 'Guest', 'Away'),
    ])
    ->include($includes)
    ->sync();

var channelMetadataInput = ChannelMetadataInput(
    name: 'Channel Name',
    description: 'Description',
    custom: {'BestDish': 'Pizza'},
    status: 'Active',
    type: 'Public'
);

result = await pubnub.objects.setChannelMetadata(
  'channelId',
  channelMetadataInput,
  includeStatus: true,
  includeType: true
);

Etag support in multiple SDKs

Type: New feature

Several Core SDKs (C-Sharp, Java, JavaScript, Kotlin, Swift, Unity, Python, and PHP) now support the entity tag in App Context API that you can use to ensure updates only happen if the object hasn't been modified since it was read.

Use the eTag you received from an applicable get metadata method to check against the server entity tag. If the eTags don't match, an HTTP 412 error is thrown.

Handle custom metadata

Type: Enhancement

We updated App Context API docs for all Core SDKs with a note that the custom parameter does not support partial updates of user or channel custom metadata.

Any new custom metadata will completely overwrite existing data on PubNub servers. To handle such updates, follow these steps:

Retrieve the existing metadata using the relevant get object method (like get_channel_metadata()).
Store the current custom data locally.
Add any new fields to this stored data.
Use the relevant set method (like set_channel_metadata()) to overwrite the existing custom metadata with the updated custom object.

This process keeps your existing data intact while adding new information.

Each SDK now also has an example of how to handle "partial updates" by pulling the current state, altering it, and pushing back to the server (check example for JavaScript SDK).

Events & Actions ⚡

Secrets in webhook headers

Type: Enhancement

We now let you use your vault secrets (same as used in Functions) to pass as custom headers in the Webhook action types.

You can assign one or multiple secret keys from your keysets to these custom headers if your webhook requires authorization or you want to enhance your app's security.

BizOps Workspace 🏢

Read-only objects

Type: Enhancement

Following feedback, we improved UI for User Management and Channel Management sections in BizOps Workspace by clearly marking and restricting internal objects, such as users or channels with the PUBNUB_INTERNAL or REVIEWED prefixes.

Such objects are now marked with an "eye" icon and can be viewed only.

Illuminate 💡

Increased action history

Type: Enhancement

Until recently, Illuminate let you see only 50 recent actions that run for Decisions and see why some of them failed.

We removed this fixed limit and you can now retrieve the remaining actions from history through the Load more button.

Other 🌟

A grab bag of changes

Type: Improvement

Fortunately, we had some time this month to focus on several feedback tickets and improve the existing docs with new examples, clarification, and more.

Here's the list of changes:

Documented the missing removeAllPushChannelsForDevice method in PHP SDK (link)
Improved info on signals vs messages (link)
Clarified info across SDKs on when objects events are triggered (link)
Clarified send file and publish file methods across SDKs (link)
Showed the use of the sort field in App Context API for the Swift SDK (link)
Clarified how the same User ID behaves on multiple devices (link)
Updated info on presence deltas & interval webhooks (link)
Added examples of different types of channels (link)
Updated info on the pn_ttl flag for APNS push notifications (link)
Documented how to add metadata to push notifications (APNS & FCM)
Revisited auth key info in Access Manager (link)

Track Doctor & Patient Presence for Efficient Online Consultations

PubNub Developer Relations — Fri, 14 Mar 2025 09:11:24 +0000

It is now commonplace for healthcare providers to offer online consultations (also known as telemedicine), which has made accessing healthcare services easier and more convenient for patients whilst making more efficient use of doctors' time. With patient satisfaction at the forefront of the healthcare industry, many providers are looking for ways to improve the patient experience, be transparent about online doctor availability, and allow potential patients to make informed decisions.

Being able to track doctors' and patients' online presence in real time can improve everyone's overall experience. This blog will explore how to track users and discuss exactly how this can improve your workflow.

Consider the idealized, ‘standard’ experience for an online, appointment-based consultation:

The patient schedules the appointment at a specific date and time.
The doctor's calendar is updated with the scheduled appointment.
Both the patient and the doctor join the virtual consultation room at the same time.
The consultation ends exactly on time, with all the patient’s issues resolved.

Clearly, this never happens! The patient might join late, or miss their appointment, wasting the doctor’s time. Equally, the doctor might be running late with their previous appointment, leaving the patient waiting. There is no way for either party to know that the other is late, or absent, leading to frustration and inefficiencies.

Imagine if you knew when a patient joined a chat, how many patients were waiting to chat with a specific doctor, or whether or not the doctor was in an existing consultation. Then you could keep the patient up to date with how many people are queued in front of them, or send them an automated message that ‘the doctor is running a few minutes late’.

You can also start to build more complex use cases, where multiple specialist doctors can flexibly provide on-demand consultations to multiple patients and track the patient journey from triage to consultation.

How to Track Whether a Patient or Doctor is Available?

PubNub will represent both doctors and patients as users and the Presence feature lets you track whether or not a user is currently subscribed to a channel. Think of a channel as a shared space that users can join, so you might have a channel to represent the ‘lobby’ where patients are waiting to see a doctor and a separate channel to represent the 1:1 ‘consultation’ with that doctor. When a user joins or leaves a channel, a notification is sent to all registered clients, so you always know who else is present and listening on the channel (there are, of course, ways to restrict who can see your presence, or who can access specific channels, which I’ll touch on later).

A user’s presence can also have state information associated with it, allowing you to provide some context. For example, just because a user is present does not mean they are ‘available’ as they might be ‘busy’ or ‘do not disturb’ - so you can capture the user’s actual availability using a combination of Presence and Presence State. Note that Presence state cannot be used for data that needs to persist after the appointment, so use App Context for non-transitory data, or store it outside of PubNub.

This is a lot easier to understand with a demo!

The embedded application below will show you how many users are currently viewing this page. If you open the demo in a new tab (or open this blog in a new tab), you will see the number of online users increase, and closing tabs will have the opposite effect. You can also set your presence state - hardcoded in the demo as available or busy, but PubNub does not restrict what value the user’s ‘state’ can be. Have a play with the demo - notice that the values will update in real-time:

Viewing on a mobile device? Click here to see the demo

This page contains embedded content that is not supported by this site , please view it at https://pubnubdevelopers.github.io/mini-samples/presence-state/

How Does the Demo Work?

The application uses the PubNub Core JavaScript SDK, and the full source code of the demo is available on Github.

Ignoring the connective tissue of the app, the key portions that relate to PubNub Presence are as follows:

//  Subscribe to a channel and receive presence events
const lobbyChannel = pubnub.channel(CHANNEL_NAME);
const lobbySubscription = lobbyChannel.subscription({
  receivePresenceEvents: true,
});

//  Callback which will be invoked when a presence event happens
lobbySubscription.onPresence = (presenceEvent) => {
  switch (presenceEvent.action) {
    case "join":
    case "state-change":
      //  Called whenever a user joins a channel or their state changes
      break;
    case "leave":
      //  Called whenever a user leaves a channel
      break;
    case "interval":
      //  This allows you to track the presence for very large channels, but you are unlikely to need this for healthcare use cases
      break;
    default:
      break;
  }
};

//  Subscribe to the channel to receive presence events and notify others we have joined
await lobbySubscription.subscribe();

When you set yourself as available or busy, the setState API is used:

pubnub.setState({
  channels: [CHANNEL_NAME],
    state: {
      onlineStatus: newState,
    },
})

When the application first loads, it will also use the hereNow API to determine which users are already connected to the channel.

If you would like to understand PubNub's Presence feature in more detail, our docs are a great place to start. To avoid straying off-topic, the rest of this blog will look at how you can use PubNub Presence to enhance online healthcare consultations.

Demo Data Security

The demo is designed to show the high-level principles of PubNub Presence, and is not designed to show security best practices. Especially with patient healthcare data, you would likely implement much of the business logic on your server, and ensure users only have visibility to the data they need using access control.

Virtual Patient Consultations

Let’s consider two architectures for virtual consultations:

The first is an appointment-based system where prospective patients will set up scheduled appointments with doctors ahead of time, and meet with the doctor for a set period of time.

The second allows for on-demand, or instant, consultations, where patients needing treatment can join a virtual queue, get assessed and prioritized, and then move on to specialist treatment with a doctor who is assigned based on their skillset and availability.

Appointment-Based Remote Consultations

The most common type of virtual appointment is scheduled in advance and involves the patient and doctor joining a virtual ‘meeting room’ at the specified time.

When scheduling the appointment, the patient will have pre-registered with the healthcare provider and provided some details about their condition before selecting an appointment time. This is not included in the above diagram.

Step 1: At the pre-appointed time, the patient will join a lobby specific to that doctor. So, if there are two doctors, there will be two lobbies, lobby.doctor1 and lobby.doctor2. A join event is generated when the patient arrives, allowing the doctor to see how many patients are waiting at any time.

The doctor can maintain their presence state either manually or automatically, allowing patients to see whether their doctor is currently ‘busy’, ‘unavailable’, or that the consultation will start soon.

Data security is paramount, and channels should be restricted using PubNub’s Access Manager, to ensure data is only available to those who need it. For example, the lobby.doctor1 should not be visible to any doctor other than doctor1. How to achieve this will be shown later in this blog.

PubNub allows you to send secure messages between the doctor and patient, so even before the consultation begins, messages could be exchanged on the lobby.<doctor>.<patientId> channel, which is specific and private for each patient. You might even have a workflow, triggered by a patient joining a lobby, where some heuristic process determines that the doctor is running late and can send automated messages to the patient keeping them updated on expected wait times.

Step 2: When the doctor starts the consultation, the patient leaves the lobby.<doctor> channel and joins the consultation.<doctor>.<patient> channel. Leaving lobby.<doctor> will generate a leave event and automatically update all interested parties that the queue length has reduced; the doctor will also set their presence state to indicate they are in a consultation which will notify anyone who has registered for updates.

The consultation channel, consultation.<doctor>.<patient>, is unique and private to that doctor & patient; data exchanged over this channel can be backed up or retained as needed.

On-Demand (Instant) Remote Consultations

Although not as common as scheduled appointments, some healthcare organizations offer on-demand virtual consultations, where a patient can log in and wait to see an available doctor or specialist.

The following diagram captures the workflow of a patient requesting an on-demand consultation. It presupposes that the patient has registered with the provider and provided details about their symptoms. Data that needs to be persistent, such as medical information and a record of the consultation itself, is not shown on this diagram, which focuses on the transitory data associated with the patients’ and doctors’ presence.

Since there is no single workflow for on-demand virtual healthcare, I have shown a representative case study

Step 1: A patent enters the workflow after requesting a virtual consultation. The patient is first placed into an initial triage queue, lobby.triage, where they provide additional information about their symptoms. This triage might be automated, or handled by a human, but the outcome will be a categorization of the patient along with some assessment of the urgency of their case.

Joining lobby.triage will generate a join event, giving you real-time visibility into how many people are currently being triaged, and eventually determining the time between a patient entering triage and that same patient entering a consultation.

Step 2: After triage, the patient is assigned to a specialist queue, which generates a leave event for the lobby.triage channel and a join event for the lobby.<specialist> channel. At this point, interested parties can see how many patients are waiting to be seen by a doctor, and how much demand there is for each specialist in real-time. Patients can be updated on how many people are in front of them in their queue, and doctors can use this information to prioritize who they will speak with next, for example, patients in the ‘urgent’ queue will take priority over those in the ‘general’ queue.

After triage, the queue categorizations will vary from healthcare provider to healthcare provider, and can even vary based on which doctors are available and their skillsets. I have chosen to categorize pediatric, general, and urgent in the above diagram as this is most typical, but you could also break general down further into cardiology, orthopedics, etc., for example.

Step 3: The patient will join the consultation with the doctor, generating a leave event for the channel they were waiting in and allowing the system to calculate the time between triage and seeing a doctor. The doctors also generate a join event as they start the consultation, giving a real-time overview of how many doctors are in active consultations and how many are waiting to see patients.

Keeping Patient Data Secure

It is critically important to keep all healthcare patient data secure, not just for legal and regulatory compliance but also to protect the privacy of patients and healthcare professionals. Electronic Health Records (EHR) can be highly sensitive and personal, including medical histories, diagnoses, treatments, and more.

PubNub enables you to easily build HIPAA compliant real-time solutions, but what does HIPAA compliance mean? HIPAA stands for the Health Insurance Portability and Accountability Act, which aims to protect patients’ protected health information (PHI). If any of the 18 protected identifiers appear in a message, that message is considered to contain PHI and can only be exchanged with end-to-end encryption, using a solution that supports access controls and auditing.

What about outside of the USA? At PubNub, we often discuss HIPAA Compliance because it resonates strongly with our customer base and is understood by customers worldwide. Globally, PubNub is compliant with a number of industry regulations such as ISO 27001, SOC2, and GDPR, so you can have confidence developing a healthcare solution with PubNub regardless of your worldwide footprint.

Access Control Example

Recall previously, when speaking about Appointment-Based Remote Consultations, I said the following:

Data security is paramount, and channels should be restricted using PubNub’s Access Manager, to ensure data is only available to those who need it. For example, the lobby.doctor1 should not be visible to any doctor other than doctor1.

You would implement this as follows:

Prerequisite: Access Manager is enabled on your PubNub keyset

Step 1: When the doctor application initializes, the doctor logs in and authenticates themself using your existing auth flow. As part of authentication, your application should also make a grant request to PubNub. This is steps 1 and 2 in the oft-reused diagram taken from our documentation on auth flow

The grant request on your server would look something like this in Node (though we do support other languages). See the grantToken documentation for more detail on what each field means:

pubnub.grantToken({
  ttl: 15,
//  The doctor’s ID who is requesting access
  authorized_uuid: "doctor1",   
  resources: {
    channels: {
//  Able to set and read presence information for this (and only this) 
//  doctor’s lobby
      "lobby.doctor1-pnpres": {
        read: true, 
        write: true
      },
//  Able to exchange private lobby messages between doctor1 and 
//  patient1, and nobody else.  Shown as optional on the diagram.
      "lobby.doctor1.patient1": {
        read: true, 
        write: true
      },
//  Able to exchange private consultation messages between 
//  doctor1 and patient1 
      "consultation.doctor1.patient1": {
        read: true,
        write: true
      },
    },
  }
},
function (status, token) {
  //  todo send this back to the client
  console.log(token)
});

Step 2: The token returned in the previous call should be returned to the client, who should, in turn, call setToken on their client SDK. This is covered by steps 3, 4, and 5 in the above diagram. Again, although the links and examples are given in JavaScript, PubNub has SDKs to support all popular client languages.

Step 3: Whenever the existing rule’s TTL expires, or new access rules are needed, repeat steps 1 and 2. For example, if a new patient joins the waiting room, you might want to set a new rule to allow the doctor to chat with this new patient

Tracking Patient Metrics

This blog has focused heavily on taking action in real time to improve the patient experience and keep all parties updated as patients move through the system.

I will not go into detail about the following use cases, but if you are tracking user presence anyway, be aware that it would be trivial to implement some additional features:

Admin Dashboards:

An administrator user who has access to all channel presence events could be given an overview of the current solution state, including how many patients are waiting for each doctor, how each doctor is performing, and historical trends. This could allow the administrator to make resourcing decisions (if a doctor suddenly becomes unavailable) or perhaps move patients between doctors if queues get too long, improving patient care and the overall patient experience.

Analytics:

PubNub Events & Actions (E&A) allows you to send the real-time data generated by your system to third parties for storage or analytics. For example, you can send data to Amazon SQS, Amazon Kinesis, Amazon S3, or Apache Kafka.

E&A can ingest Presence events, meaning you can easily set up a rule to export all join, leave, and state-change events for later analysis or storage in a third-party system. This provides historical analytics and trend data without having to write any code.

Get Started

If you haven’t already, check out our digital health landing page, which discusses implementing a healthcare solution with PubNub more generally and highlights some customer testimonials.

If you would like to take the first step towards adding to those customer testimonials or just learn more, you can get in touch with us or start development with a free account.

Finally... although patient health remains the primary focus for medical practices as they transition from face-to-face, in-person care to telehealth consultations, no primary care provider can ignore the impact of social media and online reputation for their organization. Especially where medical services are subject to competition or services are provided to a younger demographic, you must also consider online patient engagement, including search engine ranking, SEO, and your presence on social media platforms. Optimizing your appointment scheduling will lead to an improved patient relationship and better patient reviews and provide you with a positive and strong online presence.

How can PubNub help you?

This article was originally published on PubNub.com

Our platform helps developers build, deliver, and manage real-time interactivity for web apps, mobile apps, and IoT devices.

PubNub is the world's largest event-driven network, offering less than 30ms latency with global delivery, unlimited concurrency, and 99.999% reliability

Experience PubNub

Check out Live Tour to understand the essential concepts behind every PubNub-powered app in less than 5 minutes

Get Setup

Get Started

The PubNub docs will get you up and running, regardless of your use case or SDK

Gamifying Your Application With Real-time Interactivity

PubNub Developer Relations — Tue, 25 Feb 2025 15:00:44 +0000

Gamification is more than just a buzzword—it’s a proven strategy that works. Whether you're building a mobile app or website, everyone and their grandma uses this gamification magic, and your competitors are in on the secret, too. So, what does gamification do, and how do I apply it to your application?

First, gamification can be applied anywhere, even in the real world. Whether hosting an event live, a sports streaming feature, or creating an interactive app, live engagement tools like fan chat, live reaction, trivia, and loyalty points will incentivize users to return for an engaging experience.

So Why Does Gamification Work?

According to the Oxford Online Dictionary:

“Gamification is the practice of making activities more like games to make them more interesting or enjoyable.”

In other terms, gamification uses the concepts of video games and applies them to non-game contexts to render experiences more engaging and rewarding to create more interactive content.

Gamification techniques are everywhere, even in the physical world, to increase user interactions and retention. Examples of gamified apps: If you're a Starbucks customer and you earn "stars" toward a free meal or drink, you're playing a game designed to get you to purchase more. Another great example is Duolingo, where points, streaks, and badges are awarded for daily language learning—turning the learning experience or learning process into an addictive one by making you feel a sense of accomplishment.

The Power of Real-time Interactivity

Developing these real-time experiences isn't merely a matter of including a real-time leaderboard or some kind of interactive quest in your application—it's about real-time engagement that forms user incentives and brings them back to your app.

These gamified features only work if they are done in real-time. Slowed-down interactions destroy momentum, increasing the churn rate and ruining your user experience. Worry not—PubNub is here for your app development!

Building a Real-time Gamified Experience

Now that you understand the importance of adding gamified elements to your app, let’s explore how to build these features. Whether you want to implement live chat, reactions, polls, or a rewards program, you will need a system that can effectively handle real-time updates.

So, let’s add gamification elements to our app using our PubNub SDKs.

Setting Up The Communication Layer

We will need a real-time messaging layer to handle instant updates. This ensures that all interactions, such as poll votes, chat messages, or reward notifications, reach all users immediately.

This is the most critical stage—it provides the foundation for a smooth and immersive gamified experience. With no real-time updates, the interactions are no longer exciting, and people lose interest.

JavaScript (Web)

Install Dependencies

npm install pubnub

Initialize the Messaging Client

import PubNub from 'pubnub';


const pubnub = new PubNub({
  publishKey: 'your-publish-key',
  subscribeKey: 'your-subscribe-key',
  userId: 'user-unique-id',
});

Kotlin (Android)

If you are creating an application in Kotlin, choose which dependency installation makes sense for your project.

Use Gradle (Android Studio Projects)

implementation 'com.pubnub:pubnub-kotlin:10.4.1'

Initialize the Messaging Client

import com.pubnub.api.v2.PNConfiguration
import com.pubnub.api.PubNub
import com.pubnub.api.UserId
val config = PNConfiguration.builder(UserId("myUserId"), "demo").apply {
    publishKey = "your-publish-key"
    subscribeKey = "your-subscribe-key"
}.build()
val pubnub = PubNub(config)

Swift (IOS)

If you are creating an application in Swift, choose which dependency installation makes sense for your project.

Use Swift Package Manager In your Package.swift file, add the following dependency:

import com.pubnub.api.v2.PNConfiguration
import com.pubnub.api.PubNub
import com.pubnub.api.UserId
val config = PNConfiguration.builder(UserId("myUserId"), "demo").apply {
    publishKey = "your-publish-key"
    subscribeKey = "your-subscribe-key"
}.build()
val pubnub = PubNub(config)

Use CocoaPods Ensure you have the latest CocoaPods installed:

gem install cocoapods
gem update cocoapods

Add PubNub to your Podfile:

pod 'PubNubSwift', '~> 8.3.1'

Use Carthage Add the following to your Cartfile:

github "pubnub/swift" ~> 8.3.1

Initialize Messaging Client (Swift) Import & configure PubNub in AppDelegate (Check implementation below for multiple scenes, IOS 13+)

import UIKit
import PubNub
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
  var pubnub: PubNub!
  var window: UIWindow?

  func application(
    _ application: UIApplication,
    willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil
  ) -> Bool {

    let config = PubNubConfiguration(
      publishKey: "your-publish-key",
      subscribeKey: "your-subscribe-key",
      userId: "userId"
    )
    pubnub = PubNub(configuration: config)

    return true
  }
}

Initialize Messaging Client For Multiple Scenes (IOS 13+) Modify SceneDelegate.swift to pass PubNub to the view controllers:

import UIKit
import PubNub
@available(iOS 13.0, *)
class SceneDelegate: UIResponder, UIWindowSceneDelegate {
  var window: UIWindow?
  var pubnub: PubNub?
  func scene(
    _ scene: UIScene,
    willConnectTo session: UISceneSession,
    options connectionOptions: UIScene.ConnectionOptions
  ) {
    let config = PubNubConfiguration(
      publishKey: "your-publish-key",
      subscribeKey: "your-subscribe-key",
      userId: "userId"
    )

    pubnub = PubNub(configuration: config)
  }
}

Bringing Gamification to Life

Where gamification is involved, you have a lot of freedom, and with PubNub, we get to let these ideas run wild. The game elements you choose to include in your application don’t necessarily have to feel like games. For instance, gamification can be as simple as an onboarding procedure that walks you through a progress indicator and a reward, such as access to more features in your application.

In this blog, we will walk you through one example of gamification: creating a live leaderboard that lets users track their high scores. The use case will be in a live event application where users answer trivia questions about their favourite sports team. The leaderboard will rank who got the most questions right, and users will receive live updates about their independent scores and rewards for participating in the trivia.

How it will work: Users will earn points by answering questions during a game or live event. Scores update instantly, ensuring everyone sees changes as they happen The leaderboard dynamically ranks players, motivating them to stay engaged

Let’s break it down step-by-step.

Step 1: Broadcasting Score Updates in Real Time

The first thing in creating a live leaderboard is to ensure that every time a player gains points, his or her score gets updated and streamed in real-time to other users on your application.

We achieve this by publishing messages to the “leaderboard” channel, which we will subscribe to using a PubNub Function later in the blog.

How It Works: Each time a user earns points, we publish an updated score request The message published will contain the user’s ID and their new score

async function updateScore(userId, newScore) {
  try {
    const response = await pubnub.publish({
      message: { username: userId, score: newScore },
      channel: "leaderboard",
      storeInHistory: true,
    });
    console.log("Score published:", response);
  } catch (error) {
    console.error("Error publishing score:", error);
  }
}


// Example: A player earns 50 points
updateScore("player123", 50);

Every score update is broadcast to every User / PubNub Function who is subscribed to the “leaderboard” channel.

Step 2: Subscribing to Leaderboard Updates

To ensure real-time rankings, all users should dynamically listen for new scores, and the UI should reflect that. To do this, we’ll create a subscriptionset that will allow us to handle multiple event types that PubNub supports efficiently.

Below, I will include all the different event types that PubNub supports. For this demo, we will utilize the OnMessage to deliver the leaderboard ranks as a “Message.” For another example of gamification, you might use PubNub Signals (for smaller messages), utilizing the OnSignal event listener for live reactions.

JavaScript (Web)

Let leaderboard = [];

const subscriptionSet = pubnub.subscriptionSet({
    channels: ["leaderboard_scores"]
});

subscriptionSet.subscribe();

subscriptionSet.onMessage = (event) => {
    try {
        leaderboard = event.message.username.map((user, index) => ({
            userId: user,
            steps: parseFloat(event.message.score[index]) || 0
        }));
    } catch (e) {
        console.error("Error processing leaderboard update:", e);
    }
    updateLeaderboard();
}

Check out other listeners that might be helpful for your application below.

subscriptionSet.onPresence = (presenceEvent) => {
  console.log("Presence event: ", presenceEvent);
};
subscriptionSet.onSignal = (signalEvent) => {
  console.log("Signal event: ", signalEvent);
};
subscriptionSet.onObjects = (objectsEvent) => {
  console.log("Objects event: ", objectsEvent);
};
subscriptionSet.onMessageAction = (messageActionEvent) => {
  console.log("Message Reaction event: ", messageActionEvent);
};
subscriptionSet.onFile = (fileEvent) => {
  console.log("File event: ", fileEvent);
};

Step 3: Storing Scores with PubNub Functions

A leaderboard in real-time is wonderful, but what happens when users reload or close the application? We need a way of persisting scores. Instead of using App Context, we can cache scores using PubNub Functions via KV Store to dynamically update player scores.

We will use PubNub Functions with the KV Store to keep the leaderboard data persistent. This will allow us to dynamically store, retrieve and update a user's score without relying on an external database.

Create a PubNub Function

Navigate to the PubNub Admin Portal
Go to Functions → Select “Create Package”
Name the Function and select the event type “Before Publish on Fire”
Name the channel you would want the function to watch for events (messages) on. In this case, we will use the channel “leaderboard”
Copy and paste the code shown below in the Functions editor
Click “Deploy” Function and specify the keyset you would like to deploy your function under

Add KV Store for Persistent Storage

Use db.get(“leaderboard”) to retrieve stored scores
Use db.set(“leaderboard”, updated data) to persist new scores

export default async (request) => {
    const db = require("kvstore");
    const pubnub = require("pubnub");

    const { username, score } = request.message;

    // Fetch existing leaderboard or initialize an empty one
    // db.removeItem("leaderboard");
    let leaderboard = await db.get("leaderboard") || { username: [], score: [] };

    // Ensure leaderboard structure is correct
    if (!Array.isArray(leaderboard.username) || !Array.isArray(leaderboard.score)) {
        leaderboard = { username: [], score: [] };
    }

    // If username is null or undefined, just publish the existing leaderboard
    if (!username) {
        await pubnub.publish({
            channel: "leaderboard_scores",
            message: leaderboard
        });
        return request.ok();
    }

    const newScore = parseFloat(score);

    // Insert new score in sorted order
    for (let i = 0; i <= leaderboard.score.length; i++) {
        if (i === leaderboard.score.length || newScore > parseFloat(leaderboard.score[i])) {
            leaderboard.score.splice(i, 0, score);
            leaderboard.username.splice(i, 0, username);
            break;
        }
    }

    // Trim leaderboard to top 10 entries
    leaderboard.score = leaderboard.score.slice(0, 10);
    leaderboard.username = leaderboard.username.slice(0, 10);

    await db.set("leaderboard", leaderboard);

    await pubnub.publish({
        channel: "leaderboard_scores",
        message: leaderboard
    });

    return request.ok();
};

Step 4: Displayer the Live Leaderboard

Now that we’ve successfully set up real-time score broadcasting, subscription handling, and persistent storage with PubNub Functions, the final step is to fetch the initial leaderboard.

To achieve this, we can publish a message to the PubNub Function, which will publish a message back on “leaderboard_scores”. Above, we have created a “subscriptionset” subscribing to channel “leaderboard_scores” to receive the leaderboard data.

async function fetchInitialLeaderboard() {
    try {
        await pubnub.publish({
            channel: "leaderboard",
            message: {
                score: [0]
            }
        });
    } catch (error) {
        console.error("Error fetching initial leaderboard:", error);
    }
}

Enhancing Gamification with AppContext

We have built a real-time leaderboard with PubNub Functions utilizing the KV store for persistent storage. What if we wanted to take gamification even further? This is where AppContext come into play.

Using AppContext for Persistent Player Storage

While the KV Store is ideal for storing and updating data like leaderboard ranks, App Context is designed to store player metadata across sessions.

For example, instead of only showing the highest leaderboard scores, you could personalize your application to display a player’s all-time ranking, achievements, and progress toward the next reward level. Personalization through player profiles creates a good customer experience as users are motivated and engaged even if they are not ranked on the leaderboard. In other words, think of AppContext as storing and retrieving player profiles instead of the highest scores of all players, as that is what we used the KV store for.

So what does this look like?

First, we need to enable App Context on our keyset like such:

We can now make a new function to save your score to a profile that can be retrieved later, utilizing App Context.

// Function to upload user's score to App Context
async function uploadUserScore(userId, score) {
    try {
        await pubnub.objects.setUUIDMetadata({
            uuid: userId, // Set the user's UUID as their name
            data: {
                name: userId,
                custom: {score}
            }
        });
        console.log(`Successfully updated steps for ${userId}: ${score}`);
    } catch (error) {
        console.error("Error uploading user score to App Context:", error);
    }
}

To retrieve the initial score, we can use the function “getUUIDMetadata ” specifying a uuid for the user for which we want to retrieve a score for. When we navigate to BizOps Workspace, the management console for AppContext, we should now see the score or, in this case, steps uploaded.

Repurposing PubNub Demos for Gamification

PubNub offers many demos that are very quickly supported in the context of gamifying your sports media & entertainment app. Whether you are working on fan engagement, financial awards, or interactive leaderboards, these demos provide a solution to integrate real-time gamification features.

Demo

Use Case for Gamification

Live Events Chat

Fan chat for sports, concerts, or esports events, complete with live reactions and polls.

Push Notifications

Instant updates on leaderboard changes, reward system.

Chat SDK Mobile

In-game chat with team-based interactions, challenges, and real-time engagement to boost social interaction.

FinTech Chat

Gamify financial apps with loyalty rewards, spending challenges, and cashback leaderboards.

Ready to Gamify Your App?

Gamification isn’t just a trend—it’s a powerful tool that works. By incorporating game design, game mechanics, and game-like elements, you can create interactive experiences that captivate user engagement, creating user motivation for them to keep coming back. Whether you are building a live event, sports, or interactive website, leveraging real-time interactivity ensures users stay engaged, charged, and immersed in the experience. Combining active rewards, challenges, and competition turns passive interaction into an interactive experience that builds a stronger connection between your application and your users.

By leveraging PubNub’s real-time capabilities, whether with our SDKs, PubNub Functions, and AppContext, you can add features such as live leaderboards, rewards, real-time chat, or interactive challenges without worrying about infrastructure or scale.

Get Started Today

How can PubNub help you?

This article was originally published on PubNub.com

Our platform helps developers build, deliver, and manage real-time interactivity for web apps, mobile apps, and IoT devices.

The foundation of our platform is the industry's largest and most scalable real-time edge messaging network. With over 15 points-of-presence worldwide supporting 800 million monthly active users, and 99.999% reliability, you'll never have to worry about outages, concurrency limits, or any latency issues caused by traffic spikes.

Experience PubNub

Check out Live Tour to understand the essential concepts behind every PubNub-powered app in less than 5 minutes

Get Setup

Get Started

The PubNub docs will get you up and running, regardless of your use case or SDK

Deliver Personalized Content to Your Stream Audience

PubNub Developer Relations — Mon, 17 Feb 2025 09:19:23 +0000

In today's highly competitive streaming landscape, where consumer attention spans are shorter than ever, and content is abundant, capturing and retaining audience interest is a monumental challenge. For businesses offering live sports or media streams, being able to cut through the noise and connect with consumers on a deeply personal level has become essential.

Content personalization brings together multiple technologies to deliver rewards, experiences, and promotions that are tailored to the individual user. Traditional personalized experiences focused on predictable user patterns, for example, if they like a particular sports team, you could notify them that a stream containing their team is starting soon. Customer expectations are evolving, and the next step is being able to personalize content in real-time based on user behavior or what is happening on stream, for example, fans are more likely to buy merchandise if their team is winning a game, so adapt your monetization strategy as the game evolves and help the customer feel more engaged with the stream and their team.

Personalization works both ways. For consumers, it translates into a more relevant and enjoyable experience, reducing pain points, driving customer loyalty, and increasing viewer retention.

How can you make audiences feel more involved in your livestream? How can you deliver personalized content such as real-time game stats or quizzes tailored to what is happening on stream? PubNub is here to help optimize your solution for your target audience.

Delivering a Personalized Real-Time Experience to Your Audience

You can't run before you can walk, so although it might seem obvious, I like to break the process down into 3 steps:

Step 1: Gather data about your users and audience. Being open about what data you are collecting and why you are collecting it will build trust between you and your customers. The more data you can gather, the greater your understanding of your audience will be, eventually enabling you to deliver more relevant content.

Step 2: Build a profile for each user. This step is all about giving context and meaning to the data you have already gathered. A user's viewing data can determine their favorite team, whether they typically watch on their phone, and which country or region they're from. As a viewer interacts with your stream, you can discover their preferred language, their friends, and how passionate they are about the current live event.

Step 3: Take personalized actions in real-time. This has traditionally been the “hard bit”, but PubNub is changing that. Let's say we are dealing with a sports stream, and one team scores - this is impossible to predict ahead of time but is a great moment to send some personalized engagement: perhaps send a poll targeting a specific demographic of people, or send them a promotion for targeted merchandise to celebrate their team's predicted victory. You could even analyze the sentiment of chat messages within a stream, aggregate them using AI, and take action based on the emotion of the audience - even something as minor as showing a motivating animation to a disheartened user will help them feel engaged.

Step 1: Gather Data on User Behavior

Every action your users take is data useful in understanding your audience. This is not a new concept, and you are already familiar with big data and predictive analytics solutions that can help you analyse your customer behavior “after the fact,” determine better what you should do “next time,” and create email marketing campaigns.

As we start to think about content delivery and how to take real-time personalized actions for each user, it is useful to think of user behavior in two different ways:

Actions a user takes that help us learn more about that user and predict what they will do next time. This is the traditional “you might be interested in these live streams” approach that services, such as Netflix or Spotify, offer, and the more data users let you collect, the more personalized you can make content or product recommendations.
Actions a user is taking right now: For example, are they online or offline? Which chat groups are they participating in? Are they happy or sad? Are they reacting to your stream? All of this customer data is critical to understand the type of personalized engagement that will resonate with them: It is the difference between sending an offline user a mobile notification that their favorite team is playing soon, and incentivizing an online user to participate in your live stream chat.

Using PubNub, let's say you want to detect when a user goes online or offline, we refer to this as User Presence and it lets you know where your users are, and which streams they are currently watching in just a few lines of code. The most common platforms your users will be engaging with your streams are the web, either on mobile or desktop and native mobile apps for Android or iOS. With 50+ SDKs, PubNub has your platform covered, but let's look at the code you would use to detect when a user goes online or offline for those 3 platforms mentioned

Users will subscribe to a channel which represents the stream chat they are currently a member of, let's say the channel name is football-stream

JavaScript: Subscribing to a channel with presence

//  High capacity chats should also consider the 'interval' event, 
//  to determine presence changes since the last interval
const channel = pubnub.channel('football-stream')
const subscription = channel.subscription({receivePresenceEvents: true})
subscription.onPresence = (presenceEvent) => {
  if (presenceEvent.action == 'join')
  {
    //  User has come online (football-stream channel)
  }
  else if (presenceEvent.action == 'leave' || 
    presenceEvent.action == 'timeout')
  {
    //  User has gone offline (football-stream channel)
  }
}

Kotlin (Android): Subscribing to a channel with presence

//  High capacity chats should also consider the 'interval' event, 
//  to determine presence changes since the last interval
val subscription = pubnub.channel('football-stream').subscription(SubscriptionOptions.receivePresenceEvents())
subscription.subscribe()
subscription.addListener(object: EventListener {
  override fun presence(pubnub: PubNub, presence: PNPresenceEventResult) {
    If (presence.action == 'join')
    {
      //  User has come online (football-stream channel)
    }
    else if (presence.action == 'leave' || 
      presence.action == 'timeout')
    {
      //  User has gone offline (football-stream channel)
    }
  } 
})

Swift (iOS): Subscribing to a channel with presence

//  High capacity chats should also consider the 'interval' event,
//  to determine presence changes since the last interval
let subscription = pubnub.channel('football-stream').subscription(options: ReceivePresenceEvents())
subscription.subscribe()
subscription.onPresence = { presenceChange in
  for action in presenceChange.actions {
    switch action {
    case let .join(uuids):
      //  uuids array have come online (football-stream channel)
    case let .leave(uuids):
      //  uuids array have gone offline (football-stream channel)
    case let .timeout(uuids):
      //  uuids array have gone offline (football-stream channel)
    }
  }
}

Step 2: Build a Profile for Each User

With data gathering in place, the next step is to build a profile for each user based on data-driven insights, which will, of course, update and improve the more that user interacts with your application and streams.

Where should you store your user profiles? As mentioned in the first step, there are two types of data you want to keep track of: “traditional analytics” and “real-time actionable events”. You probably already have a platform in place for analytics and the great news is you can continue using your current platform AND still take advantage of real-time events generated by your users and captured through PubNub. PubNub's Events & Actions platform allows you to select and filter events as they pass through the PubNub network, with matching events being forwarded to either Amazon Kinesis, Apache Kafka, or a custom webhook allowing support for any platform. We also support bidirectional communication with Kafka using our PubNub Kafka Bridge.

But what about profile data that is needed to make real-time decisions immediately? For example, a user's current mood, or their current level of engagement with your stream? PubNub AppContext should be used to store information about your users and stream content, this might be:

The fan profile - their favourite team, whether they are currently typing a message, or their current mood. Fans, or stream participants are referred to as Users within PubNub AppContext.
The streams - which teams are playing, who is winning, or which artist is performing and which stage are they on. Streams are referred to as Channels within PubNub AppContext.
The relationship between fans and streams—who is watching which stream, or which group of viewers has been watching the longest? PubNub AppContext captures these relationships as Memberships.

As an example of what you could do, let's take the following scenario to analyze user sentiment:

A user is chatting and interacting with other users whilst watching one of your live streams.
The user's messages are analysed in real-time to determine their sentiment - is this fan excited or disheartened at their team's performance?
The AppContext for this user is updated with their current 'mood'

This interaction would be trivial to implement using PubNub as follows:

Analyzing user sentiment (1): A user is chatting and interacting with other users in your live stream

PubNub was designed to send and receive messages at scale, we are the world's largest event-driven network with less than 30ms global latency and an industry-leading 99.999% uptime. To help you build your chat solution, we have SDKs covering all popular languages, including dedicated Chat SDKs for JavaScript, Kotlin (Android), and Swift (iOS) making it trivial to incorporate chat alongside your streaming application.

Using our Chat SDKs, you can quickly build a solution that features:

Send and receive messages at scale, so participants can communicate regardless of how many people are watching the stream.
Live reactions, so fans can react immediately to what is happening on-stream as well as react to others' messages.
Moderation, allowing a safe and inclusive environment.

Everything that passes through our network is secure and compliant, we support message encryption, and we are certified for SOC2, GDPR, CCPA, and ISO27001

Analyzing user sentiment (2): The user's messages are analyzed in real-time to determine their sentiment

PubNub exposes serverless Functions, allowing you to add custom logic as messages pass through our network. These Functions also support pre-built custom integrations with third-party services and APIs, including artificial intelligence or machine learning algorithms.

So, for example, if you wanted to analyze a user's message sentiment in real time, your solution would look as follows:

User sends a chat message
PubNub function detects that a message was sent and runs code asynchronously (we refer to this as an 'after publish' function, because it runs after the message is published to recipients)
A REST API call is made to an external service to analyse the message's sentiment, we support machine learning solutions (e.g. HuggingFace), AI-powered automation (e.g. OpenAI), or dedicated content analysis solutions (e.g. Tisane Labs).
The result of the REST API call can be stored as part of the user's profile.

The workflow would look something like this as a diagram. Of course, this is just an example of architecture, and Functions are very flexible.

To learn more about how PubNub Functions can be used for sentiment analysis, including example code, please check out my recent blog, “Two reasons why PubNub Functions are Awesome”, where I covered this in more detail.

Analyzing user sentiment (3): The AppContext for this user is updated with their current 'mood'

To extend the previous example, once the user's message sentiment has been determined you can store this in AppContext. The Function execution environment exposes a PubNub module that can save data to and retrieve data from AppContext.

//  PubNub Function code
const pubnub = require('pubnub');

return pubnub.objects.getUUIDMetadata({
  uuid: request.message.publisher,  //  ID of the user who sent the message
  include: {
    customFields: true,
  },
})
.then((resp) => {
  if (sentiment == 'positive')
    resp.custom.mood++ 
  else
    resp.custom.mood–-

  //  Store the updated mood back in AppContext
  return pubnub.objects.setUUIDMetadata({
    uuid: request.message.publisher,
    data: resp,
  })
   .then((resp) => {
       return event.ok('Set UUID metadata successfully.');
   })      
  .catch((error) => {
       return event.abort('Failed to set UUID metadata.');
   });
})
.catch((err) => {
  return event.abort('Failed to fetch UUID metadata');
});

Step 3: Take Personalized Actions in Real-Time

At this stage, you have a process in place to gather data about your stream viewers and are using that data to create and update their user profiles in real time. Let's look at some of the actions you can take to deliver highly personalized content, such as promotions or rewards that give tailored experiences based on fans’ behavior and preferences.

If a user is offline, you could send them a mobile notification when a stream featuring their favorite sports team or music artist is about to start. Online fans would not receive this message.
You can enrich the streaming chat of live sports by adding polls or live commentary. Since sports are inherently unpredictable, you want to trigger a relevant poll only at the right moment during play.
You could alert the user immediately when their favorite team scores or a player is substituted.
As real money gaming odds update, you could notify interested users when odds are particularly good for teams they regularly bet on - since every second counts when talking about gaming odds, PubNub's <30ms latency is critical.

PubNub Illuminate is a powerful tool that lets you respond to events within the stream in real-time, and take actions based on both those events & the user's current profile.

To extend the previous example, where we determined the user's current mood, let's assume the following:

The user, named Troy, is watching a live-streamed basketball game between the “Wildcats” and the “Knights”.
Troy supports the Wildcats, and as he watches the game, he sends messages using the stream chat. Based on the content of these messages, his 'mood' is assigned a numeric value as described in the previous step.
Troy's mood will be tracked in PubNub AppContext as part of his User metadata
The current game score will be tracked in PubNub AppContext as part of the Channel metadata

The scenario is as follows: You want to run a promotion targeted at Wildcats fans. Specifically, if the team is dominating its rivals, you want to offer any high-spirited users who are in a good mood an opportunity to celebrate by buying some themed merchandise.

Using PubNub Illuminate, you could set up a “Business Object” as follows:

“Business Objects” define what you want to track, specifically I have defined the user's mood, their favorite team and the current team scores. Notice that the user's mood and favorite team are mapped to $.user.custom.mood and $.user.custom.favorite_team, so are pulled from User AppContext. Similarly, the Wildcats team score is pulled from Channel AppContext, $.channel.custom.wildcatsScore

The Business Object will monitor these data fields, calculate any metrics, determine whether any decisions need to be evaluated, and present the data on any defined Dashboards.

The metric will calculate the average mood of Wildcat fans as they send chat messages.

Notice the filter to only evaluate this metric for Wildcats fans, remember the favorite team is stored in PubNub AppContext and forms part of our user profile. If new users join the stream, and declare themselves Wildcats fans (or you infer it from their behavior and update their profile automatically), then they will automatically be included in this metric. Filters can also allow a degree of A/B testing, breaking down viewers into audience segments to test customer engagement.

The metric will be evaluated whenever a user sends a message, so it is the mood of actively participating chat users, weighted towards those users sending more messages.

The dashboard will display that average user mood, updating in real-time, so you can visualize your audience's mood as the live stream progresses.

The red bars on the graph indicate whenever a 'Decision' was made, so let’s look at that:

Remember, the goal is to send spirited users who are in a good mood a merchandise promotion if their team is outperforming their rivals.

The decision defines the scenario we want to capture, in this case, we detect whether the user is a Wildcat fan and the Wildcats have scored over 90 points, whilst their rivals are languishing below 60. The user's mood must also be greater than '10' - remember this is an arbitrary value we have assigned based on the sentiment of the user's messages they are sending in the stream chat.

If all the conditions in the decision evaluate to true, then the “Send Happy User Promotion” action is performed.

For testing, I am sending a PubNub Message back to the user on the same channel used for chat, game01 in this case.

Testing using the PubNub debug console (part of the admin portal), and having previously defined the user's mood and team score using AppContext, the action can be successfully triggered:

In production, instead of sending a test message, you would expose a custom webhook in your server application, which would be called by PubNub Illuminate whenever a user needs to be sent a promotion. As you can see from the test message, the user ID, their mood score and their favorite team have been included which should be enough detail to email the user a promotion link, but Illuminate is very flexible and any data fields you define in your “Business Object” can also be included in the webhook.

Create a Digital Marketing Strategy

How can personalized marketing improve customer satisfaction? By using a combination of dynamic content, customer preferences, and personalization strategies, you can develop social media campaigns, email campaigns, and landing pages/homepages tailored to a specific audience. This is the power of personalization; by taking a user’s individual preferences and past purchases into account with real-time actions, you can enhance their customer experience. Understand potential customers better by looking at the specific needs of your current customers and considering their customer journey: what is their purchase history? Or browsing history on your site? Let user data collection inform your content marketing: What delivers the most engaging experience for your customer? Which calls to action give the best click-through rates and drive higher engagement? Rather than wait until after the event concludes, you can now get valuable insights into the user experience in real time and adjust your content strategy accordingly.

In Conclusion

By personalizing your streaming content for individual customers and making the experience interactive for your viewers, you can increase viewer retention and conversion rates, boost brand loyalty, and increase market share. By making user interactions real-time, you can take advantage of opportunities for monetization that you could not have foreseen prior to the sports event or media stream starting.

Learn more about PubNub can help with your live sports, streaming & fan engagement solution; get in touch, or sign up for a free PubNub account to explore how you can tailor content for your audience in real-time.

How can PubNub help you?

This article was originally published on PubNub.com

Our platform helps developers build, deliver, and manage real-time interactivity for web apps, mobile apps, and IoT devices.

Experience PubNub

Check out Live Tour to understand the essential concepts behind every PubNub-powered app in less than 5 minutes

Get Setup

Get Started

The PubNub docs will get you up and running, regardless of your use case or SDK

Documentation Release Notes - January 2025

PubNub Developer Relations — Tue, 04 Feb 2025 17:47:48 +0000

This article was originally published at https://www.pubnub.com/docs/release-notes/2025/january

We're kicking off the year with quite a few interesting documentation changes.

We've revamped the keyset configuration experience for easier access, introduced message drafts in gaming chat SDKs, and added event-based decisions in Illuminate.

Plus, we've got new features in the client-side mute list, message reactions in the PHP SDK, and more intuitive advanced presence settings in the BizOps Workspace.

Let's dive into the details!

General 🛠️

New keyset configuration experience

Type: Enhancement

This month, we completely revamped the keyset creation process on the Admin Portal.

Creating an app and a set of keysets is one of the initial steps if you want to start exploring PubNub. These keysets enable secure and controlled access to PubNub's real-time messaging capabilities, ensuring that only authorized users can publish or subscribe to channels in your app.

Until now, when you created keysets, you often didn't even know what configuration they had until you stumbled upon an obstacle in your app and could not use features like Presence or App Context. Only then did you explore the keyset's configuration and look for proper setup options.

Until now, keysets were created with a default configuration that turned off most options. We decided to expose keyset configuration more and let you make a deliberate decision about which configuration option to enable at the very initial step of keyset creation.

After creating a keyset, you can still return to the Admin Portal and change your mind about enabled features.

We hope this change will let you spend less time on configuration and makes it easier for you to get started quickly with PubNub.

Keyset number limit

Type: Adjustment

This month we also worked on updating our policy regarding keyset access to free accounts.

For optimization reasons, we decided to limit the number of keysets you can have at once on a free account to a maximum of 3.

If your account exceeds this limit, you must delete existing keysets to create new ones.

This change is effective as of February 3.

Whitelisting IPs

Type: Improvement

Following your feedback, we updated the docs to include information on how you can allow traffic to specific domains (and subdomains) associated with PubNub (e.g., *.pubnub.com, *.pndsn.com) if your firewall blocks them.

You can typically whitelist domains by configuring your firewall or network settings to allow traffic to and from those domain names.

However, suppose your firewall system or network configuration does not support domain-based rules and requires IP addresses instead. In that case, you can contact PubNub support to get the complete list of PubNub Network IP addresses for whitelisting.

This option is available only for customers on paid plans.

Logging

Type: Improvement

Following another round of feedback, we summarized information on how PubNub lets you monitor real-time activities and diagnose issues effectively in your apps by configuring logging for your apps.

Most PubNub SDKs provide configuration options to enable and control the level of logging output.

Read the Logging document for details.

Custom domains

Type: Improvement

There is a number of reasons for which you might want to have your own domain name for your PubNub-based apps, including unique branding, compliance and control, or improved traffic management.

PubNub lets paid customers set up custom application domain names to access PubNub’s real-time messaging infrastructure instead of the default PubNub endpoint ps.pndsn.com.

For details on the process, refer to this instruction.

SDKs 📦

Message drafts in gaming chat SDKs

Type: New feature

This month brought another round of support for message drafts in Chat SDKs by adding this functionality to our gaming SDKs: Unreal Chat SDK and Unity Chat SDK.

Unreal
Unity

// Assuming you have a valid UPubnubChannel* pointer named Channel

// Define a configuration for the message draft if needed (using default configuration here)
FPubnubMessageDraftConfig DraftConfig; // This might include settings like initial content or behaviors

// Create a message draft from the channel with the specified configuration
UPubnubMessageDraft* MyMessageDraft = Channel->CreateMessageDraft(DraftConfig);

// Now MyMessageDraft can be used to build and send messages
MyMessageDraft->InsertText(0, "Hello there! Please review and confirm.");
MyMessageDraft->Send();

var messageDraft = channel.CreateMessageDraft();

This way, we can proudly announce that we now support message drafts in all Chat SDKs. 🎉

Client-side mute

Type: New feature

We added the client-side mute list to the Chat object in the Kotlin and JavaScript Chat SDKs. This new feature lets users mute other users on all channels and, as a result, stop seeing all messages and events originating from the muted users.

The new feature also lets you unmute muted users and retrieve a list of all users you muted on a given channel.

You also get the new configuration option (syncMutedUsers parameter) to automatically synchronize the mute list across sessions and devices using a specific App Context User object.

Kotlin
JavaScript

import com.pubnub.chat.Chat
import com.pubnub.chat.config.ChatConfiguration

val chat = Chat.init(
    ChatConfiguration(
        publishKey = "demo",
        subscribeKey = "demo",
        userId = "myUniqueUserId"
    )
)

val userToMute = "user_1905"

chat.mutedUsersManager.muteUser(userToMute).await()

import { Chat } from "@pubnub/chat"

const chat = Chat.init({
    publishKey: "demo",
    subscribeKey: "demo",
    userId: "myUniqueUserId"
})

let userToMute = "user_1905"

await chat.mutedUsersManager.muteUser(userToMute)

Message reactions in PHP SDK

Type: New feature

Not to lag behind other SDKs, the PHP SDK finally supports the Message Reactions API, letting you add, remove, and get the list of reactions in a given channel.

$messageAction = new PNMessageAction([
    "type" => "reaction",
    "value" => "drooling_face",
    "messageTimetoken" => $messageTimetoken // the timetoken of the message you want to add the reaction to
]);

$result = $pubnub->addMessageAction()
    ->channel("pizza_talks")
    ->messageAction($messageAction)
    ->sync();

Migration guide for JavaScript SDK

Type: Enhancement

Since some of our clients were having difficulty using our JavaScript SDK after migrating from v7 to v8, we decided to create a migration guide to list changes you need to perform in your app code for the SDK to work as expected.

These include removing the @types/pubnub package dependency, as the types are now included within the SDK, and updating your import statements for PubNub types to align with the new endpoint groupings in version 8.0.0, such as AppContext.GetMembershipsParameters, ensuring your code references are updated to reflect these structured namespaces.

Custom message type (follow-up)

Type: New feature

As a follow up, we added support for the custom message type parameter in the Ruby SDK in the following APIs: Publish, Subscribe, and Message Persistence.

pubnub.publish(
    channel: 'my_channel',
    message: { text: 'Hi!' },
    custom_message_type: 'text-message'
) do |envelope|
    puts envelope.status
end

Membership type (follow-up)

Type: New feature

To follow up on last month's updates in a few SDKs, we added support for the membership type in the Ruby SDK to let you categorize memberships more easily.

Changelogs in Chat SDKs

Type: Enhancement

Addressing documentation debt, the JavaScript Chat SDK, Kotlin Chat SDK, and Swift Chat SDK now include changelogs so you can track in detail what a new SDK version adds, removes, or updates.

Utility methods in Kotlin Chat SDK

Type: Enhancement

Kotlin Chat SDK now has a document listing utility methods for converting PubNub timetokens to and from dates, UNIX timestamps, and Instant objects. This enables you to display or manipulate date and time information in a human-readable format or align it with other systems.

BizOps Workspace 🏢

Advanced presence settings

Type: Enhancement

This month, we got down to the Presence Management section in BizOps Workspace.

We changed the UI by exposing the more advanced presence settings, which let you decide whether to track Subscribe Heartbeats or Presence Heartbeats on a given channel or channel pattern.

While Subscribe Heartbeats define how long the server considers the client alive for presence to ensure that the client does not lose its subscription to a channel due to inactivity, Presence Heartbeats specify how often the client will send heartbeat signals to the server, offering more granular control over client activity tracking than Subscribe Heartbeats.

While Presence Management lets you decide which of them you want to track (one of them is required for any presence rule to be enabled on a channel), you enable/configure both during your SDK initialization (through presenceTimeout and heartbeatInterval settings).

Illuminate 💡

Event-based Decisions

Type: New feature

Until now, you were only able to create Decisions in Illuminate based on aggregations (metrics), This means that a specified calculation, like max, average or sum of events, had to be reached to trigger an action in a Decision.

We now added an event trigger to actions, letting you trigger actions each time a given event is detected.

For example, a metric-based decision would activate dynamic pricing when the average number of orders is greater than 30, while in an event-based decision, coins can be given as soon as a participant joins an online show.

UI improvements in Decisions

Type: Enhancement

While working on event-based Decisions, we also tweaked the UI for Decisions, adding more clarification on why you must choose a Business Object to start with and let you more intuitively select publish and subscribe keys for an action (automated choice instead of manually pasting the values).