Struct RealtimeClient 

pub struct RealtimeClient { /* private fields */ }

The main entry point for interacting with Supabase Realtime.

RealtimeClient manages the WebSocket connection to Supabase Realtime servers, handles automatic reconnection with exponential backoff, and provides channel creation for real-time subscriptions.

Example

use supabase_realtime_rs::{RealtimeClient, RealtimeClientOptions};

let client = RealtimeClient::new(
    "wss://your-project.supabase.co/realtime/v1",
    RealtimeClientOptions {
        api_key: "your-anon-key".to_string(),
        ..Default::default()
    }
)?;

client.connect().await?;
// Use the client...
client.disconnect().await?;

Implementations

impl RealtimeClient

pub fn new( endpoint: impl Into<String>, options: RealtimeClientOptions, ) -> Result<Self>

Creates a new RealtimeClient instance.

This initializes the client but does not establish a connection. You must call connect() to establish the WebSocket connection.

Arguments

• endpoint - The WebSocket endpoint URL (e.g., wss://your-project.supabase.co/realtime/v1)
• options - Configuration options including API key and optional settings

Returns

Returns Ok(RealtimeClient) if the endpoint is valid, or an error if the URL is malformed.

Errors

Returns RealtimeError::UrlParse if the endpoint URL cannot be parsed.

Example

use supabase_realtime_rs::{RealtimeClient, RealtimeClientOptions};

let client = RealtimeClient::new(
    "wss://your-project.supabase.co/realtime/v1",
    RealtimeClientOptions {
        api_key: "your-anon-key".to_string(),
        ..Default::default()
    }
)?;

pub async fn resubscribe_all_channels(&self) -> Result<()>

pub async fn try_reconnect(&self) -> Result<()>

pub async fn connect(&self) -> Result<()>

Establishes a WebSocket connection to the Supabase Realtime server.

This method opens the WebSocket connection, starts the heartbeat mechanism, and spawns background tasks for reading messages and maintaining the connection. If already connected, this method returns immediately without error.

After connecting successfully, the client will automatically:

• Send periodic heartbeat messages
• Attempt reconnection if the connection drops (unless manually disconnected)
• Route incoming messages to subscribed channels

Errors

Returns an error if:

• The WebSocket handshake fails
• The endpoint URL is invalid
• TLS/SSL negotiation fails

Example

use supabase_realtime_rs::{RealtimeClient, RealtimeClientOptions};

let client = RealtimeClient::new(
    "wss://your-project.supabase.co/realtime/v1",
    RealtimeClientOptions {
        api_key: "your-anon-key".to_string(),
        ..Default::default()
    }
)?;

// Establish connection
client.connect().await?;

// Now you can create channels and subscribe

pub async fn channel( &self, topic: &str, options: RealtimeChannelOptions, ) -> Arc<RealtimeChannel>

Creates or retrieves a channel for real-time subscriptions.

Channels are the primary way to subscribe to real-time events. Each channel is identified by a unique topic string. If a channel with the given topic already exists, this method returns the existing channel instead of creating a new one.

Arguments

• topic - The channel topic (e.g., “room:lobby”, “public:todos”). The “realtime:” prefix is automatically added.
• options - Configuration options for the channel (broadcast settings, presence key, etc.)

Returns

Returns an Arc<RealtimeChannel> that can be used to subscribe to events, send broadcasts, and track presence.

Example

use supabase_realtime_rs::{RealtimeClient, RealtimeClientOptions, RealtimeChannelOptions};

// Create a channel
let channel = client.channel("room:lobby", Default::default()).await;

// Subscribe to receive events
channel.subscribe().await?;

pub async fn disconnect(&self) -> Result<()>

Gracefully disconnects from the WebSocket server.

This method closes the WebSocket connection, aborts all background tasks (heartbeat, message reading), and marks the disconnect as manual. When disconnected manually, the client will NOT attempt automatic reconnection.

To reconnect after a manual disconnect, call connect() again.

Errors

Returns an error if the WebSocket close handshake fails (rare).

Example

use supabase_realtime_rs::{RealtimeClient, RealtimeClientOptions};

// When done, disconnect gracefully
client.disconnect().await?;

pub async fn is_connected(&self) -> bool

Checks whether the client is currently connected to the server.

Returns

Returns true if the WebSocket connection is open, false otherwise.

Example

use supabase_realtime_rs::{RealtimeClient, RealtimeClientOptions};

if !client.is_connected().await {
    client.connect().await?;
}

pub async fn make_ref(&self) -> String

Generate next message reference

pub async fn push(&self, message: RealtimeMessage) -> Result<()>

Push a message to the server

pub fn http_endpoint(&self) -> String

Get HTTP endpoint URL (for broadcasts)

pub fn api_key(&self) -> &str

Get API key

pub fn access_token(&self) -> Option<&str>

Get access token

Trait Implementations

impl Clone for RealtimeClient

fn clone(&self) -> RealtimeClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.