--- source_url: https://www.pubnub.com/docs/sdks/python/api-reference/configuration title: Configuration API for Python SDK updated_at: 2026-06-04T11:12:44.288Z sdk_name: PubNub Python SDK sdk_version: 10.6.3 --- > 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 # Configuration API for Python SDK PubNub Python SDK, use the latest version: 10.6.3 Install: ```bash pip install pubnub@10.6.3 ``` Complete API reference for building real-time applications on PubNub with the Python Software Development Kit (SDK). This page covers configuration, initialization, and event handling with concise, working examples. ## Configuration `PNConfiguration` stores user-provided settings that control PubNub client behavior. It includes properties for precise client configuration. ### Method(s) To create `configuration` instance you can use the following function in the Python SDK: ```python pnconfig = PNConfiguration() ``` | Parameter | Type | Required | Default | Description | | --- | --- | --- | --- | --- | | subscribe_key | String | Yes | | `subscribe_key` from Admin Portal. | | publish_key | String | Optional | `None` | `publish_key` from Admin Portal (only required if publishing). | | secret_key | String | Optional | `None` | `secret_key` (only required for modifying/revealing access permissions) | | user_id | String | Yes | | `user_id` to use. You should set a unique `user_id` to identify the user or the device that connects to PubNub. It's a UTF-8 encoded string of up to 92 alphanumeric characters. If you don't set the `user_id`, you won't be able to connect to PubNub. | | auth_key | String | Optional | `None` | If Access Manager is utilized, client will use this `authKey` in all restricted requests. | | ssl | Boolean | Optional | `True` | Use Secure Sockets Layer (SSL). | | connect_timeout | Int | Optional | `5` | How long to wait before giving up connection to client. The value is in seconds. | | subscribe_request_timeout | Int | Optional | `310` | How long to keep the `subscribe` loop running before disconnect. The value is in seconds. | | non_subscribe_request_timeout | Int | Optional | `10` | On `non subscribe` operations, how long to wait for server response. The value is in seconds. | | filter_expression | String | Optional | `None` | Feature to subscribe with a custom filter expression. | | heartbeat_notification_options | PNHeartbeatNotificationOptions | Optional | `PNHeartbeatNotificationOptions.FAILURES` | `Heartbeat` notifications, by default, the SDK will alert on failed heartbeats (equivalent to: `PNHeartbeatNotificationOptions.FAILURES`). Other options such as all heartbeats (`PNHeartbeatNotificationOptions.ALL`) or no heartbeats (`PNHeartbeatNotificationOptions.NONE`) are supported. | | reconnect_policy | PNReconnectionPolicy | Optional | `PNReconnectionPolicy.EXPONENTIAL (subscribe only)` | Custom reconnection configuration parameters. `PNReconnectionPolicy` is the type of policy to be used. Available values: PNReconnectionPolicy.NONE, PNReconnectionPolicy.LINEAR (see maximum_reconnection_retries and reconnection_interval below), PNReconnectionPolicy.EXPONENTIAL (see maximum_reconnection_retries, reconnection_interval, and maximum_reconnection_interval below) For more information, refer to [SDK connection lifecycle](https://www.pubnub.com/docs/general/setup/connection-management#sdk-connection-lifecycle). Set retry limits explicitlyThe Python SDK doesn't enforce upper bounds on maximum_reconnection_retries or maximum_reconnection_interval.Without limits, misconfigured policies may cause excess network traffic, battery drain, or usage spikes. Always choose values suited to your app. | | maximum_reconnection_retries | int | Optional | `None` | Maximum number of reconnection attempts before the SDK stops retrying. Applies to both `PNReconnectionPolicy.LINEAR` and `PNReconnectionPolicy.EXPONENTIAL`. When `None`, the policy default applies (`10` for LINEAR, `6` for EXPONENTIAL). Set to `-1` for unlimited retries, or `0` to stop without retrying. | | reconnection_interval | float | Optional | `None` | Delay in seconds between reconnection attempts. For `PNReconnectionPolicy.LINEAR`, sets the fixed retry interval. For `PNReconnectionPolicy.EXPONENTIAL`, sets the minimum backoff delay. When `None`, each policy uses its built-in default. | | maximum_reconnection_interval | float | Optional | `None` | Maximum delay in seconds between reconnection attempts. Only applicable to `PNReconnectionPolicy.EXPONENTIAL`. When set, the exponential backoff delay never exceeds this value. When `None`, the default maximum from `ExponentialDelay` is used. | | suppress_leave_events | Boolean | Optional | `False` | If `True`, the client doesn't send presence leave events during the unsubscribe process. | | enable_subscribe | Boolean | Optional | `True` | You can disable the `subscribe loop` if you don't need to perform subscribe operations. By default, `subscribe loop` is enabled and extra threads/loops are started. They should be explicitly stopped by `pubnub.stop()` method invocation. | | daemon | Boolean | Optional | `False` | When set to `True`, spawned thread won't keep the application running after SIGTERM. (ctrl-c from command line, for example) | | disable_token_manager | Boolean | Optional | `False` | When set to `True`, the Token Manager System (TMS) will be disabled. Even if there are applicable tokens, no requests will be authorized. | | cipher_mode | AES.MODE_CBC | Optional | `AES.MODE_CBC` | The cipher method to be used for message encryption for the legacy crypto module. By default, all PubNub SDKs use CBC. ⚠️**Warning!** If you set the Python SDK's `cipher_mode` to GCM, ensure that all other clients can decode the message. | | fallback_cipher_mode | AES.MODE_CBC | Optional | `None` | The secondary cipher method used for message decryption for the legacy crypto module. It is used if the method set in the `cipher_mode` parameter fails to decrypt the messages. | | cipher_key | String | Optional | `None` | If `cipher_key` is passed, all communications to/from PubNub will be encrypted. | | use_random_initialization_vector | Boolean | Optional | `True` | When `True` the initialization vector (IV) is random for all requests (not just for file upload). When `False` the IV is hard-coded for all requests except for file upload. | | crypto_module | PubNubCryptoModule | Optional | `None` | The cryptography module used for encryption and decryption of messages and files. Takes the `config` (`PNConfiguration` instance with `cipher_key` and `use_random_initialization_vector`) parameter as argument. For more information, refer to the [crypto_module](#crypto_module) section. | | uuid | String | Yes | `N/A` | This parameter is deprecated, use `user_id` instead. UUID to use. You should set a unique UUID to identify the user or the device that connects to PubNub. If you don't set the UUID, you won't be able to connect to PubNub. | :::warning Disabling random initialization vector Disable random initialization vector (IV) only for backward compatibility (<`5.1.0`) with existing applications. Never disable random IV on new applications. ::: ##### Working with cipher mode By default, all PubNub SDKs use the CBC mode. If you set your Python SDK to use GCM, only another Python SDK with `cipher_mode` set to `AES.MODE_GCM` will be able to decode the messages. If you set your Python SDK to use the GCM mode but still want to decode messages encoded using CBC (sent from other PubNub SDKs) or fetch messages using Message Persistence, set the `fallback_cipher_mode` to `AES.MODE_CBC`. The following example shows how to work with messages sent using different cipher modes: ```python from Cryptodome.Cipher import AES from os import getenv from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub from time import sleep channel = 'cipher_algorithm_experiment' def PNFactory(cipher_mode=AES.MODE_GCM, fallback_cipher_mode=AES.MODE_CBC) -> PubNub: config = config = PNConfiguration() config.publish_key = getenv('PN_KEY_PUBLISH') config.subscribe_key = getenv('PN_KEY_SUBSCRIBE') config.secret_key = getenv('PN_KEY_SECRET') config.cipher_key = getenv('PN_KEY_CIPHER') config.user_id = 'experiment' config.cipher_mode = cipher_mode config.fallback_cipher_mode = fallback_cipher_mode return PubNub(config) # let's build history with legacy AES.CBC pn = PNFactory(cipher_mode=AES.MODE_CBC, fallback_cipher_mode=None) pn.publish().channel(channel).message('message encrypted with CBC').sync() pn.publish().channel(channel).message('message encrypted with CBC').sync() # now with upgraded config pn = PNFactory(cipher_mode=AES.MODE_GCM, fallback_cipher_mode=AES.MODE_CBC) pn.publish().channel(channel).message('message encrypted with GCM').sync() pn.publish().channel(channel).message('message encrypted with GCM').sync() # give some time to store messages sleep(3) # after upgrade decoding with GCM and fallback CBC pn = PNFactory(cipher_mode=AES.MODE_GCM, fallback_cipher_mode=AES.MODE_CBC) messages = pn.history().channel(channel).sync() print([message.entry for message in messages.result.messages]) # before upgrade decoding with CBC and without fallback pn = PNFactory(cipher_mode=AES.MODE_CBC, fallback_cipher_mode=None) try: messages = pn.history().channel(channel).sync() print([message.entry for message in messages.result.messages]) except UnicodeDecodeError: print('Unable to decode - Exception has been thrown') ``` #### crypto_module `crypto_module` encrypts and decrypts messages and files. From 7.2.0, you can configure the algorithms it uses. Each SDK includes two options: legacy 128‑bit encryption and recommended 256‑bit AES‑CBC. For background, see [Message Encryption](https://www.pubnub.com/docs/general/setup/data-security#message-encryption) and [File Encryption](https://www.pubnub.com/docs/general/setup/data-security#file-encryption). If you don't set `crypto_module` but set `cipher_key` and `use_random_initialization_vector` in config, the client uses legacy encryption. For configuration details, utilities, and examples, see [Encryption](https://www.pubnub.com/docs/sdks/python/api-reference/encryption). :::note Legacy encryption with 128-bit cipher key entropy You don't have to change your encryption configuration if you want to keep using the legacy encryption. If you want to use the recommended 256-bit AES-CBC encryption, you must explicitly set that in PubNub config. ::: ### Sample code :::note Required User ID Always set the `user_id` to uniquely identify the user or device that connects to PubNub. This `user_id` should be persisted, and should remain unchanged for the lifetime of the user or the device. If you don't set the `user_id`, you won't be able to connect to PubNub. ::: :::tip Reference code This example is a self-contained code snippet ready to be run. It includes necessary imports and executes methods with console logging. Use it as a reference when working with other examples in this document. ::: ```python import os from pubnub.pnconfiguration import PNConfiguration from pubnub.enums import PNHeartbeatNotificationOptions from pubnub.pubnub import PubNub from pubnub.crypto import AesCbcCryptoModule # Configuration for PubNub instance pn_configuration = PNConfiguration() # Set configuration values pn_configuration.subscribe_key = os.getenv('SUBSCRIBE_KEY', 'demo') # required pn_configuration.publish_key = os.getenv('PUBLISH_KEY', 'demo') # only required if publishing pn_configuration.secret_key = os.getenv('SECRET_KEY', 'my_secret_key') # optional pn_configuration.cipher_key = os.getenv('CIPHER_KEY', 'my_cipher_key') # for encryption/decryption pn_configuration.crypto_module = AesCbcCryptoModule(pn_configuration) # for encryption/decryption pn_configuration.user_id = os.getenv('USER_ID', 'my_custom_user_id') # must be set pn_configuration.auth_key = os.getenv('AUTH_KEY', 'my_auth_key') # optional pn_configuration.ssl = True pn_configuration.connect_timeout = 100 pn_configuration.subscribe_request_timeout = 310 pn_configuration.non_subscribe_request_timeout = 300 pn_configuration.filter_expression = "such=wow" pn_configuration.heartbeat_notification_options = PNHeartbeatNotificationOptions.ALL # Initialize the PubNub client pubnub = PubNub(pn_configuration) print("Configuration set up complete and PubNub client initialized.") ``` ## Initialization Add PubNub to your project using one of the procedures defined in the [Getting Started guide](https://www.pubnub.com/docs/sdks/python). ### Description Initialize the PubNub Client API context before calling any APIs. This establishes account-level credentials such as `publish_key` and `subscribe_key`. ### Method(s) To `Initialize` PubNub you can use the following method(s) in the Python SDK: ```python pubnub = PubNub(pn_configuration, custom_request_handler) ``` | Parameter | Description | | --- | --- | | `pn_configuration` *Type: [PNConfiguration](#configuration)Default: n/a | The configuration object. For more details, refer to [Configuration](#configuration). | | `custom_request_handler`Type: subclass of `BaseRequestHandler`Default: `HttpxRequestHandler` | The optional custom HTTP request handler. For more information, refer to [Custom request handler](#custom-request-handler). | #### Custom request handler The optional `custom_request_handler` lets you select the HTTP library for requests. If you omit it, the SDK checks the `PUBNUB_REQUEST_HANDLER` environment variable. If the value isn't a subclass of `BaseRequestHandler`, the SDK defaults to `HttpxRequestHandler`. | Class | Description | | --- | --- | | `HttpxRequestHandler` | Python SDK synchronous requests handler based on the [httpx](https://www.python-httpx.org/) HTTP library. | | `RequestsRequestHandler` | Python SDK synchronous requests handler based on the [requests](https://requests.readthedocs.io/en/latest/) HTTP library. | ### Sample code #### Initialize the PubNub client API :::note Required User ID Always set the `user_id` to uniquely identify the user or device that connects to PubNub. This `user_id` should be persisted, and should remain unchanged for the lifetime of the user or the device. If you don't set the `user_id`, you won't be able to connect to PubNub. ::: ```python from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub pnconfig = PNConfiguration() pnconfig.subscribe_key = "my_subkey" pnconfig.publish_key = "my_pubkey" pnconfig.ssl = True pnconfig.user_id = "my_custom_user_id" pubnub = PubNub(pnconfig) ``` ### Returns Returns a PubNub instance for APIs like `publish()`, `subscribe()`, `history()`, and `here_now()`. ### Other examples #### Use a custom request handler You can set a custom request handler by specifying one of the available request handlers during the initialization of the PubNub client. :::note Required User ID Always set the `user_id` to uniquely identify the user or device that connects to PubNub. This `user_id` should be persisted, and should remain unchanged for the lifetime of the user or the device. If you don't set the `user_id`, you won't be able to connect to PubNub. ::: ```python from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub from pubnub.request_handlers.requests_handler import RequestsRequestHandler pnconfig = PNConfiguration() pnconfig.subscribe_key = "my_subkey" pnconfig.publish_key = "my_pubkey" pnconfig.user_id = "my_custom_user_id" pubnub = PubNub(pnconfig, custom_request_handler=RequestsRequestHandler) ``` #### Initialize a non-secure client :::note Required User ID Always set the `user_id` to uniquely identify the user or device that connects to PubNub. This `user_id` should be persisted, and should remain unchanged for the lifetime of the user or the device. If you don't set the `user_id`, you won't be able to connect to PubNub. ::: ```python from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub pnconfig = PNConfiguration() pnconfig.subscribe_key = "my_subkey" pnconfig.publish_key = "my_pubkey" pnconfig.ssl = False pnconfig.user_id = "my_custom_user_id" pubnub = PubNub(pnconfig) ``` #### Initialization for a Read-Only client In the case where a client will only read messages and never publish to a channel, you can simply omit the `publish_key` when initializing the client: :::note Required User ID Always set the `user_id` to uniquely identify the user or device that connects to PubNub. This `user_id` should be persisted, and should remain unchanged for the lifetime of the user or the device. If you don't set the `user_id`, you won't be able to connect to PubNub. ::: ```python from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub pnconfig = PNConfiguration() pnconfig.subscribe_key = "my_subkey" pubnub = PubNub(pnconfig) ``` #### Use a custom user ID Set a custom `user_id` to identify your users. :::note Required User ID Always set the `user_id` to uniquely identify the user or device that connects to PubNub. This `user_id` should be persisted, and should remain unchanged for the lifetime of the user or the device. If you don't set the `user_id`, you won't be able to connect to PubNub. ::: ```python from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub pnconfig = PNConfiguration() pnconfig.subscribe_key = 'mySubscribeKey' pnconfig.publish_key = 'myPublishKey' pnconfig.user_id = "my_custom_user_id" pubnub = PubNub(pnconfig) ``` #### Initializing with SSL enabled This examples demonstrates how to enable PubNub Transport Layer Encryption with `SSL`. Just initialize the client with `ssl` set to `True`. The hard work is done, now the PubNub API takes care of the rest. Just subscribe and publish as usual and you are good to go. :::note Required User ID Always set the `user_id` to uniquely identify the user or device that connects to PubNub. This `user_id` should be persisted, and should remain unchanged for the lifetime of the user or the device. If you don't set the `user_id`, you won't be able to connect to PubNub. ::: ```python from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub pnconfig = PNConfiguration() pnconfig.subscribe_key = "my_subkey" pnconfig.publish_key = "my_pubkey" pnconfig.ssl = True pnconfig.user_id = "my_custom_user_id" pubnub = PubNub(pnconfig) ``` #### Initializing with Access Manager :::note Requires Access Manager add-on This method requires that the *Access Manager* add-on is enabled for your key in the [Admin Portal](https://admin.pubnub.com/). Read the [support page](https://support.pubnub.com/hc/en-us/articles/360051974791-How-do-I-enable-add-on-features-for-my-keys-) on enabling add-on features on your keys. ::: :::note Secure your secret_key Anyone with the `secret_key` can grant and revoke permissions to your app. Never let your `secret_key` be discovered, and to only exchange it / deliver it securely. Only use the `secret_key` on secure server-side platforms. When you init with `secret_key`, you get root permissions for the Access Manager. With this feature you don't have to grant access to your servers to access channel data. The servers get all access on all channels. ::: For applications that will administer Access Manager permissions, the API is initialized with the `secret_key` as in the following example: :::note Required User ID Always set the `user_id` to uniquely identify the user or device that connects to PubNub. This `user_id` should be persisted, and should remain unchanged for the lifetime of the user or the device. If you don't set the `user_id`, you won't be able to connect to PubNub. ::: ```python from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub pnconfig = PNConfiguration() pnconfig.subscribe_key = "my_subkey" pnconfig.publish_key = "my_pubkey" pnconfig.secret_key = "my_secretkey" pnconfig.user_id = "my_custom_user_id" pnconfig.ssl = True pubnub = PubNub(pnconfig) ``` Now that the pubnub object is instantiated the client will be able to access the Access Manager functions. The pubnub object will use the `secret_key` to sign all Access Manager messages to the PubNub Network. ## Event listeners PubNub SDKs provide several sources for real-time updates: * The PubNub client can receive updates from all subscriptions: all channels, channel groups, channel metadata, and users. * The [Subscription](https://www.pubnub.com/docs/sdks/python/api-reference/publish-and-subscribe#create-a-subscription) object can receive updates only for the particular object for which it was created: channel, channel group, channel metadata, or user. * The [SubscriptionsSet](https://www.pubnub.com/docs/sdks/python/api-reference/publish-and-subscribe#create-a-subscription-set) object can receive updates for all objects for which a list of subscription objects was created. To work with these sources, the SDK provides local representations of server entities, so you can subscribe and add handlers per entity. For details, see [Publish & Subscribe](https://www.pubnub.com/docs/sdks/python/api-reference/publish-and-subscribe#event-listeners). ## Filter expression :::note Requires Stream Controller add-on This method requires that the *Stream Controller* add-on is enabled for your key in the [Admin Portal](https://admin.pubnub.com/). Read the [support page](https://support.pubnub.com/hc/en-us/articles/360051974791-How-do-I-enable-add-on-features-for-my-keys-) on enabling add-on features on your keys. ::: Stream filtering lets a subscriber receive only messages that match a filter. The client sets the filter, and the server applies it to block messages that do not match. To set or get message filters, you can use the following methods. To learn more about filtering, refer to the [Publish Messages](https://www.pubnub.com/docs/general/messages/publish) documentation. ### Method(s) ```python Set Filter Expression ``` The property accepts a `string`. ```python Get Filter Expression ``` The property returns a `string`. ### Sample code #### Set filter expression :::note Required User ID Always set the `user_id` to uniquely identify the user or device that connects to PubNub. This `user_id` should be persisted, and should remain unchanged for the lifetime of the user or the device. If you don't set the `user_id`, you won't be able to connect to PubNub. ::: ```python from pubnub.pnconfiguration import PNConfiguration pnconfig = PNConfiguration() pnconfig.filter_expression = "such=wow" ``` #### Get filter expression ```python filter = pnconfig.filter_expression ``` ## 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.