---
source_url: https://www.pubnub.com/docs/sdks/rust/api-reference/publish-and-subscribe
title: Publish/Subscribe API for Rust SDK
updated_at: 2026-06-26T11:06:57.033Z
sdk_name: PubNub Rust SDK
sdk_version: 0.8.0
---

> Documentation Index
> For a curated overview of PubNub documentation, see: https://www.pubnub.com/docs/llms.txt
> For the full list of all documentation pages, see: https://www.pubnub.com/docs/llms-full.txt


# Publish/Subscribe API for Rust SDK

PubNub Rust SDK, use the latest version: 0.8.0

Install:

```bash
cargo add pubnub@0.8.0
```

PubNub delivers messages worldwide in less than 30 ms. Send a message to one recipient or broadcast to thousands of subscribers.

For higher-level conceptual details on publishing and subscribing, refer to [Connection Management](https://www.pubnub.com/docs/general/setup/connection-management) and to [Publish Messages](https://www.pubnub.com/docs/general/messages/publish).

## Publish

##### Available in features

Add any of the following features to `Cargo.toml` to use this API:

```yaml
[dependencies]
# default
pubnub = "0.8.0" 
# full
pubnub = { version = "0.8.0", features = ["full"] }
# no default features, just Publish 
pubnub = { version = "0.8.0", default-features = false, features = ["publish"] }
```

For a list of all features, refer to [Available features](https://www.pubnub.com/docs/sdks/rust#available-features).

The `publish_message()` function sends a message to all channel subscribers. PubNub replicates the message and delivers it to all subscribed clients on that channel. To publish a message you must first specify a valid `publish_key` at initialization.

##### Publish anytime

It's not required to be subscribed to a channel in order to publish to that channel.

##### Message data

The message can contain any JavaScript Object Notation (JSON)-serializable data (objects, arrays, integers, strings). Avoid special classes or functions. Strings can include any UTF‑8 characters.

:::warning Don't JSON serialize
It is important to note that you should not JSON serialize when sending signals/messages via PUBNUB. Why? Because the serialization is done for you automatically. Instead, just pass the full object as the message payload. PubNub takes care of everything for you.
:::

##### Message size

The maximum message size is 32 KiB, including the channel name and the escaped characters. Aim for under 1,800 bytes for optimal performance.

##### Message too large error

If the message size exceeds 32 KiB, you receive an appropriate error response.

For further details, check the [support article](https://support.pubnub.com/hc/en-us/articles/360051495932-Calculating-Message-Payload-Size-Before-Publish).

:::tip Need larger messages?
Our platform is optimized for payloads up to 32 KiB. PubNub supports larger messages, but increasing the limit requires a verification of compatibility with your use case.
Talk to [our team](https://www.pubnub.com/company/contact-sales/) to discuss increasing the message size limit for your use case.
:::

##### Message publish rate

You can publish as fast as bandwidth allows. There is a soft throughput limit because messages may drop if subscribers can't keep up.

For example, if 200 messages are published simultaneously before a subscriber has had a chance to receive any messages, the subscriber may not receive the first 100 messages because the message queue has a limit of only 100 messages stored in memory.

##### Publishing to multiple channels

It is not possible to publish a message to multiple channels simultaneously. The message must be published to one channel at a time.

##### Publishing messages reliably

There are some best practices to ensure messages are delivered when publishing to a channel:

* Publish to any given channel in a serial manner (not concurrently).
* Check that the return code is success (for example, `[1,"Sent","136074940..."]`)
* Publish the next message only after receiving a success return code.
* If a failure code is returned (`[0,"blah","<timetoken>"]`), retry the publish.
* Avoid exceeding the in-memory queue's capacity of 100 messages. An overflow situation (aka missed messages) can occur if slow subscribers fail to keep up with the publish pace in a given period of time.
* Throttle publish bursts in accordance with your app's latency needs, for example, Publish no faster than 5 messages per second to any one channel.

### Method(s)

To Publish a message you can use the following method(s) in the Rust SDK:

```rust
pubnub
    .publish_message(T: Serialize)
    .channel(Into<String>)
    .store(Option<bool>)
    .meta(Option<HashMap<String, String>>)
    .replicate(bool)
    .ttl(Option<u32>)
    .use_post(bool)
    .execute()
```

| Parameter | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| publish_message | T: | Yes |  | The message payload. Any type that implements the Serialize trait is allowed. |
| channel | Into<String> | Yes |  | The channel ID to send the message to. |
| store | Option<bool> | Optional | `Account default` | Whether to store the messages in Message Persistence or not. |
| meta | Option<HashMap<String, | Optional |  | A hash map of additional information about the message you can use for Filters. |
| replicate | bool | Optional |  | Whether to replicate the messages across points of presence or not. Refer to [Replicated Transactions](https://www.pubnub.com/pricing/transaction-classification/) for more information. |
| ttl | Option<u32> | Optional |  | A per message time to live in Message Persistence. 1. If `store = true`, and `ttl = 0`, the message is stored with no expiry time. 2. If `store = true` and `ttl = X` (`X` is an Integer value), the message is stored with an expiry time of `X` hours unless you have message retention set to `Unlimited` on your keyset configuration in the Admin Portal. 3. If `store = false`, the `ttl` parameter is ignored. 4. If `ttl` isn't specified, then expiration of the message defaults back to the expiry value for the key. |
| use_post | bool | Optional | `false` | Whether to use HTTP POST to publish the message. |
| execute |  | Yes | `false` | Executes the request based on the provided data. This function returns a [Future](https://doc.rust-lang.org/std/future/trait.Future.html) and you must `.await` the value. |

### Sample code

Publish a message to a channel:

```rust
    // publish simple string
    let result = client
        .publish_message("hello world!")
        .channel("my_channel")
        .r#type("text-message")
        .execute()
        .await?;
```

### Other examples

```rust
    // publish with other async task
    let handle = tokio::spawn(
        client
            .publish_message("hello async world!")
            .channel("my_channel")
            .r#type("text-message")
            .execute(),
    );

    // publish a struct
    let result = client
        .publish_message(Message {
            url: "https://this/is/an/example".into(),
            description: "Check out this awesome playlist I made!".into(),
        })
        .channel("my_channel")
        .r#type("url-with-description")
        .execute()
        .await?;

    println!("publish struct result: {:?}", result);

    // publish with all config options
    let result = client
        .publish_message("hello with params!")
        .channel("my_channel")
        .store(true)
        .meta([("meta1".into(), "meta2".into())].into())
        .replicate(true)
        .use_post(true)
        .ttl(10)
        .space_id("my_space")
        .r#type("text-message")
        .execute()
        .await?;
```

### Returns

The `publish()` operation returns a `PublishResult` which contains the timetoken, or a `PubNub Error` which contains the error indicator and the description of the error.

```rust
// success example
PublishResult { timetoken: "16808621084073203" }

// failure example
Error: PublishError("Status code: 400, body: OtherResponse { status: 400, error: true, service: \"Access Manager\", message: \"Invalid Subscribe Key\" }")
```

## Subscribe

##### Available in features

Add any of the following features to `Cargo.toml` to use this API:

```yaml
[dependencies]
# default
pubnub = "0.8.0" 
# full
pubnub = { version = "0.8.0", features = ["full"] }
# Subscribe 
pubnub = { version = "0.8.0", features = ["subscribe"] }
```

For a list of all features, refer to [Available features](https://www.pubnub.com/docs/sdks/rust#available-features).

The subscribe function creates an open TCP socket to PubNub and begins listening for messages and events on a specified entity or set of entities. To subscribe successfully, you must configure the appropriate `subscribe_key` at [initialization](https://www.pubnub.com/docs/sdks/rust/api-reference/configuration).

:::tip Conceptual overview
For more general information about subscriptions, refer to [Subscriptions](https://www.pubnub.com/docs/general/channels/subscribe).
:::

Entities are [first-class citizens](https://en.wikipedia.org/wiki/First-class_citizen) that provide access to their encapsulated APIs. You can subscribe using the PubNub client object or directly on a specific entity:

* [Channel](#create-channels)
* [ChannelGroup](#create-channel-groups)
* [UserMetadata](#create-user-metadata)
* [ChannelMetadata](#create-channel-metadata)

A newly subscribed client receives messages after the `subscribe()` call completes. You can configure [with_retry_policy()](https://www.pubnub.com/docs/sdks/rust/api-reference/configuration#initialization) to automatically attempt to reconnect and retrieve any available messages if a client gets disconnected.

### Subscription scope

Subscription objects provide an interface to attach listeners for various real-time update types. Your app receives messages and events via those event listeners. Two types of subscriptions are available:

* [Subscription](#create-a-subscription), created from an entity with a scope of only that entity (for example, a particular channel)
* [SubscriptionSet](#create-a-subscription-set), created from the PubNub client with a global scope (for example, all subscriptions created on a single `pubnub` object ). A subscription set can have one or more subscriptions.

The event listener is a single point through which your app receives all the messages, signals, and events in the entities you subscribed to. For information on adding event listeners, refer to [Event listeners](#event-listeners).

### Create a subscription

An entity-level `Subscription` allows you to receive messages and events for only that entity for which it was created. Using multiple entity-level `Subscription`s is useful for handling various message/event types differently in each channel.

```rust
// entity-based, local-scoped
let channel = client.channel("channelName");
channel.subscription(options: Option<Vec<SubscriptionOptions>>)
```

| Parameter | Description |
| --- | --- |
| `options` *Type: `Option<Vec<SubscriptionOptions>>` | `Subscription` [behavior configuration](#subscriptionoptions). Pass `None` for no options. |

### Create a subscription set

A client-level `SubscriptionSet` allows you to receive messages and events for all entities in the set. A single `SubscriptionSet` is useful for similarly handling various message/event types in each channel.

```rust
// client-based, general-scoped
pubnub.subscription(parameters: (SubscriptionParams {
    channels: Option<&[String]>,
    channel_groups: Option<&[String]>,
    options: Option<Vec<SubscriptionOptions>>
}))
```

| Parameter | Description |
| --- | --- |
| `parameters` *Type: `SubscriptionParams<String>` | Additional `Subscription` configuration. |
| `> channels` *Type: `Option<&[String]>` | `Subscription` behavior configuration. Pass `None` for no options. |
| `> channel_groups` *Type: `Option<&[String]>` | `Subscription` behavior configuration. Pass `None` for no options. |
| `> options` *Type: `Option<Vec<SubscriptionOptions>>` | `Subscription` [behavior configuration](#subscriptionoptions). Pass `None` for no options. |

:::tip Add/remove sets
You can add and remove subscription sets to create new sets. Refer to the [Other examples](#other-examples-1) section for more information.
:::

#### SubscriptionOptions

`SubscriptionOptions` is an enum. Available variants include:

| Option | Description |
| --- | --- |
| `ReceivePresenceEvents` | Whether presence updates for `userId`s should be delivered through the listener streams. For information on how to receive presence events and what those events are, refer to [Presence Events](https://www.pubnub.com/docs/general/presence/presence-events#subscribe-to-presence-channel). |

### Method(s)

`Subscription` and `SubscriptionSet` use the same methods to subscribe:

* [Subcribe](#subscribe-1)
* [Subscribe with timetoken](#subscribe-with-timetoken)

#### Subscribe

To subscribe, you can use the following method in the Rust SDK:

```rust
subscription.subscribe()
```

##### Sample code

```rust
    let subscription = pubnub.subscription(SubscriptionParams {
        channels: Some(&["my_channel", "other_channel"]),
        channel_groups: None,
        options: Some(vec![SubscriptionOptions::ReceivePresenceEvents]),
    });
    subscription.subscribe();
```

##### Other examples

###### Create a subscription set from 2 individual subscriptions

```rust
// create a subscription from a channel entity
let channel = client.channel("channelName");
let subscription1 = channel.subscription(options: Option<Vec<SubscriptionOptions>>);

// create a subscription from a channel group entity
let channel_group = client.channel_group("channelGroup");
let subscription2 = channel_group.subscription(options: Option<Vec<SubscriptionOptions>>);

// create a subscription set from individual entities
let set = subscription1 + subscription2;

// Add another subscription to the set
set += subscription3
// Or
set.add_subscriptions(subscription3)

// Remove a subscription from the set
set -= subscription3
// Or
set.sub_subscriptions(subscription3)
```

###### Create a subscription set from 2 sets

```rust
// create a subscription set with multiple channels
let set1 = pubnub.subscription(parameters: (SubscriptionParams {
    channels: Some(&["channelName1", "channelName2"]),
    channel_groups: None,
    options: None
}))

// create a subscription set with multiple channel groups and options
let set2 = pubnub.subscription(parameters: (SubscriptionParams {
    channels: None,
    channel_groups: Some(&["channelGroup1", "channelGroup2"]),
    options: Option<Vec<SubscriptionOptions>>
}))

// create a new subscription set from 2 sets
let set_of_channels_and_channel_groups = set1 + set2;

// you can also remove sets
let set_of_channels_only = set_of_channels_and_channel_groups - set2;
```

##### Returns

The `subscribe()` method doesn't have a return value.

#### Subscribe with timetoken

To subscribe to real-time updates from a given timetoken, use the following method in the Rust SDK:

```rust
subscription.subscribe_with_timetoken(cursor: Into<SubscriptionCursor>)
```

| Parameter | Description |
| --- | --- |
| `cursor` *Type: `Into<SubscriptionCursor>` `String` `usize` `u64` | Cursor from which to return any available cached messages. Message retrieval with cursor is not guaranteed and should only be considered a best-effort service. A cursor consists of a timetoken and region: `SubscriptionCursor{timetoken: String, region: u32}` If you pass any primitive type, the SDK converts them into `SubscriptionCursor` but if their value is not a 17-digit number or a string with numeric characters, the provided value will be ignored. |

##### Sample code

```rust
let subscription = pubnub.subscription(SubscriptionParams {
    channels: Some(&["my_channel", "other_channel"]),
    channel_groups: None,
    options: Some(vec![SubscriptionOptions::ReceivePresenceEvents]),
});

let cursor = SubscriptionCursor {
    timetoken: "100000000000".to_string(),
    region: 1,
};

subscription.subscribe_with_timetoken(cursor);
```

##### Returns

The `subscribe_with_timetoken()` method doesn't have a return value.

## Entities

Entities are subscribable objects for which you can receive real-time updates (messages, events, etc).

* [Channel](#create-channels)
* [ChannelGroup](#create-channel-groups)
* [UserMetadata](#create-user-metadata)
* [ChannelMetadata](#create-channel-metadata)

### Create channels

These methods return one or more local `Channel` entities.

```rust
pubnub.channel(String)

pubnub.channels(&[String])
```

| Parameter | Description |
| --- | --- |
| `channel` *Type: `String` | The ID of the [channel](https://www.pubnub.com/docs/general/channels/overview) to create a subscription of. |
| `channel` *Type: `&[String]` | The slice with IDs of the channels to create a subscription of. |

#### Sample code

```rust
 #         .with_user_id("uuid")
```

```rust
 #         .with_user_id("uuid")
```

### Create channel groups

These methods return one or more local `ChannelGroup` entities.

```rust
pubnub.channel_group(String)

pubnub.channel_groups(&[String])
```

| Parameter | Description |
| --- | --- |
| `channel_group` *Type: `String` | The name of the [channel group](https://www.pubnub.com/docs/general/channels/subscribe#channel-groups) to create a subscription of. |
| `channel_groups` *Type: `&[String]` | The slice with names of the [channel groups](https://www.pubnub.com/docs/general/channels/subscribe#channel-groups) to create a subscription of. |

#### Sample code

```rust
 #         .with_user_id("uuid")
```

```rust
 #         .with_user_id("uuid")
```

### Create channel metadata

These methods return one or more local `ChannelMetadata` entities.

```rust
pubnub.channel_metadata(String)

pubnub.channels_metadata(&[String])
```

| Parameter | Description |
| --- | --- |
| `channel_metadata` *Type: `String` | The String identifier of the [channel metadata](https://www.pubnub.com/docs/general/metadata/channel-metadata) object to create a subscription of. |
| `channels_metadata` *Type: `&[String]` | The slice with string identifiers of the [channel metadata](https://www.pubnub.com/docs/general/metadata/channel-metadata) objects to create a subscription of. |

#### Sample code

```rust
 #         .with_user_id("uuid")
```

```rust
 #         .with_user_id("uuid")
 #         .build()?;
```

### Create user metadata

These methods return one or more local `UserMetadata` entities.

```rust
pubnub.user_metadata(String)

pubnub.users_metadata(&[String])
```

| Parameter | Description |
| --- | --- |
| `user_metadata` *Type: `String` | The String identifier of the [user metadata](https://www.pubnub.com/docs/general/metadata/users-metadata) object to create a subscription of. |
| `users_metadata` *Type: `&[String]` | The slice with string identifiers of the [user metadata](https://www.pubnub.com/docs/general/metadata/users-metadata) objects to create a subscription of. |

#### Sample code

```rust
 #         .with_user_id("uuid")
```

```rust
 #         .with_user_id("uuid")
```

## Event listeners

Messages and events are received in your app using a listener. This listener allows a single point to receive all messages, signals, and events.

You can attach listeners to the instances of [Subscription](#create-a-subscription), [SubscriptionSet](#create-a-subscription-set), and, in the case of the connection status, the PubNub client.

:::note No built-in event throttling
The PubNub SDK delivers every incoming event to your listener as it arrives — there is no built-in throttling or rate-limiting on the subscriber side. If you need to control how often your application processes events, wrap your listener callback with a throttle or debounce utility from your language or framework ecosystem.
To reduce the number of messages delivered to your client in the first place, use [Subscribe Filters](https://www.pubnub.com/docs/general/channels/subscribe-filters) to filter messages server-side before they reach your listener.
:::

### Add listeners

You can choose to implement a generic stream of updates for a given subscription (`DataStream<Update>`) or a stream dedicated to receiving only a selected type, like `Message` or `File`.

#### Method(s)

```rust
subscription
    /// Stream used to notify regular messages.
    .messages_stream() -> DataStream<Message>;

    /// Stream used to notify signals.
    .signals_stream() -> DataStream<Message>;

    /// Stream used to notify message action updates.
    .message_actions_stream() -> DataStream<MessageAction>;

    /// Stream used to notify about file receive.
    .files_stream() -> DataStream<File>;

    /// Stream used to notify about App Context (Channel and User) updates.
    .app_context_stream() -> DataStream<AppContext>;

    /// Stream used to notify about subscribers' presence updates.
    .presence_stream() -> DataStream<Presence>;

    /// Generic stream used to notify all updates mentioned above.
    .stream() -> DataStream<Update>;
```

#### Sample code

```rust
     let subscription = client.subscription(SubscriptionParams {
         channels: Some(&["my_channel"]),
         channel_groups: None,
         options: None
     });

     let channel_entity = client.channel("my_channel_2");
     let channel_entity_subscription = channel_entity.subscription(None);

     subscription.subscribe();
     channel_entity_subscription.subscribe();

     println!("Subscribed to channels");

     // Launch a new task to print out each received message
     tokio::spawn(client.status_stream().for_each(|status| async move {
         println!("\nStatus: {:?}", status)
     }));
     tokio::spawn(subscription.stream().for_each(|event| async move {
         match event {
             Update::Message(message) | Update::Signal(message) => {
                 // Silently log if UTF-8 conversion fails
                 if let Ok(utf8_message) = String::from_utf8(message.data.clone()) {
                     if let Ok(cleaned) = serde_json::from_str::<String>(&utf8_message) {
                         println!("message: {}", cleaned);
                     }
                 }
             }
             Update::Presence(presence) => {
                 println!("presence: {:?}", presence)
             }
             Update::AppContext(object) => {
                 println!("object: {:?}", object)
             }
             Update::MessageAction(action) => {
                 println!("message action: {:?}", action)
             }
             Update::File(file) => {
                 println!("file: {:?}", file)
             }
         }
     }));

     // Explicitly listen only for real-time `message` updates.
     tokio::spawn(
         channel_entity_subscription
             .messages_stream()
             .for_each(|message| async move {
                 if let Ok(utf8_message) = String::from_utf8(message.data.clone()) {
                     if let Ok(cleaned) = serde_json::from_str::<String>(&utf8_message) {
                         println!("message: {}", cleaned);
                     }
                 }
             }),
     );
```

### Add connection status listener

The PubNub client has a listener dedicated to handling connection status updates.

:::warning Client scope
This listener is only available on the PubNub object.
:::

#### Method(s)

```rust
pubnub.status_stream()
```

#### Sample code

```rust
    tokio::spawn(
        pubnub
            .status_stream()
            .for_each(|status| async move { println!("\nstatus: {:?}", status) }),
    );
```

#### Returns

The subscription status. For information about available statuses, refer to [SDK statuses](https://www.pubnub.com/docs/general/setup/connection-management#sdk-statuses).

## Clone empty

Create a clone of an existing subscription with the same subscription state but an empty list of real-time event listeners.

### Method(s)

```rust
subscription.clone_empty()
```

### Sample code

```rust
    let subscription = pubnub.subscription(SubscriptionParams {
        channels: Some(&["my_channel", "other_channel"]),
        channel_groups: None,
        options: Some(vec![SubscriptionOptions::ReceivePresenceEvents]),
    });
    subscription.subscribe();
    let subscription_clone = subscription.clone_empty();
```

### Returns

A new instance of the subscription object with an empty event dispatcher.

## Unsubscribe

Stop receiving real-time updates from a [Subscription](#create-a-subscription) or a [SubscriptionSet](#create-a-subscription-set).

### Method(s)

```rust
subscription.unsubscribe()

subscription_set.unsubscribe()
```

### Sample code

```rust
let subscription = client.subscription(SubscriptionParams {
    channels: Some(&["my_channel", "other_channel"]),
    channel_groups: None,
    options: None
});
subscription.subscribe(None);

subscription.unsubscribe();
```

### Returns

None

## Unsubscribe all

Stop receiving real-time updates from all data streams and remove the entities associated with them.

:::warning Client scope
This method is only available on the PubNub object.
:::

### Method(s)

```rust
pubnub.unsubscribe_all()
```

### Sample code

```rust
let subscription = client.subscription(SubscriptionParams {
    channels: Some(&["my_channel", "other_channel"]),
    channel_groups: None,
    options: None
});
subscription.subscribe();

let channel_group = client.channel_group("my_channel_group");
let cg_subscription = channel_group.subscription(None);
cg_subscription.subscribe();

pubnub.unsubscribe_all();
```

### Returns

None

## Terms in this document

* **Access Manager** - A cryptographic, token-based permission administrator that allows you to regulate clients' access to PubNub resources, such as channels, channel groups, and user IDs.
* **Action** - The type of activity (procedure) to execute when a condition is satisfied (for example, sending a message).
* **Billing alert notification** - A means of informing a user that a billing alert has been triggered. Before notifications can happen, a billing alert must be triggered first.
* **Business Object** - A container for data fields and metrics that defines aggregations and data sources.
* **Channel** - A pathway for sending and receiving messages between devices, created automatically when you first use it, that can handle any number of users and messages for different communication needs, like 1-1 text chats, group conversations, and other data streaming.
* **Channel pattern** - A way to group and analyze channel data to track performance metrics like message counts and user engagement over time with PubNub Insights.
* **Condition** - A requirement that must be satisfied or evaluated to true for an action to be executed. Input in a decision table.
* **Cryptor** - An implementation of a specific cryptographic algorithm used for data encryption/decryption that adheres to a standard interface.
* **Dashboard** - A collection of widgets (charts) that give an overview of the metrics one is evaluating.
* **Data fields** - Data you want Illuminate to track. These can be quantitative (measures), like "Number" or "Timestamp" or qualitative (dimensions) values, like "String" that can be used to categorize and segment data. Data fields can be aggregated and calculated.
* **Decision** - A collection (or decision table) of conditions and actions. When conditions are satisfied, the corresponding actions are triggered as per defined rules.
* **End Customer** - A customer of a PubNub partner. End customers do not have direct access to the Admin Portal. Instead, they interact with PubNub products—such as Illuminate—through the partner’s portal, where PubNub services are embedded. They can create PubNub objects only within this partner-provided environment.
* **Entity** - A subscribable object within a PubNub SDK that allows you to perform context-specific operations.
* **Listener** - A function or objectthat reacts to events or messages, like new chat messages or connection updates, letting your app respond in real-time.
* **Mapped/Unmapped** - Whether the data source for a data field has been defined or the action has been configured.
* **MCP Server** - A Model Context Protocol server that coordinates communication and synchronization between AI agents, clients, or services, such as Cursor IDE and Windsurf.
* **Message** - A unit of data transmitted between clients or between a client and a server in PubNub, containing information such as text, binary data, or structured data formats like JSON. Messages are sent over channels and can be tracked for delivery and read status.
* **Metric** - What exactly is evaluated using measures and dimensions (collectively called data fields), as well as aggregation functions.
* **Module** - A Functions v1 container that groups related functions for configuration and deployment on an app’s keysets.
* **Origin** - The subdomain used to establish a connection to the PubNub network that allows your application's traffic to appear like it's coming from your own domain.
* **Package** - A Functions v2 container that groups Functions, tracks Revisions, and is deployed to keysets.
* **Partner** - A PubNub customer who resells PubNub products, such as Illuminate, to their own customers. Partners have access to the Admin Portal, enabling them to create and manage PubNub objects for themselves or on behalf of their end customers.
* **Publish Key** - A unique identifier that allows your application to send messages to PubNub channels. It's part of your app's credentials and should be kept secure.
* **PubNub** - PubNub is a real-time messaging platform that provides APIs and SDKs for building scalable applications. It handles the complex infrastructure of real-time communication, including: Message delivery and persistence, Presence detection, Access control, Push notifications, File sharing, Serverless processing with Functions and Events & Actions, Analytics and monitoring with BizOps Workspace, AI-powered insights with Illuminate.
* **Push token** - A device identifier issued by a push provider (APNs or FCM) used to register a device for receiving mobile push notifications.
* **Rule** - A definition (row in a decision table) stating which action should be triggered for which condition.
* **Service Integration** - A machine identity that represents a program or service consuming the Admin API, scoped to your account and authenticated using expirable API keys with configurable permissions.
* **Signal** - A non-persistent message limited to 64 bytes designed for high-volume usecases where the the most recent data is relevant, like GPS location updates.
* **Subscribe Key** - A unique identifier that allows your application to receive messages from PubNub channels. It's part of your app's credentials and should be kept secure.
* **Timetoken** - A unique identifier for each message that represents the number of 100-nanosecond intervals since January 1, 1970, for example, 16200000000000000.
* **Trigger details** - A set of predefined criteria for a given billing alert. When met, billing alert notifications are generated.
* **User** - An individual or entity that interacts with a system, application, or service. In PubNub, a user typically refers to someone who sends or receives messages through the platform, identified by a unique user ID or username.
* **User ID** - UTF-8 encoded, unique string of up to 92 characters used to identify a single client (end user, device, or server) that connects to PubNub.
* **Vibe Coding** - A way to build applications in an intuitive, relaxed, and improvisational manner, using AI tools and natural language descriptions.