Getting Started with Realtime

1
npm install @supabase/supabase-js

1
flutter pub add supabase_flutter

1
let package = Package(
2
    // ...
3
    dependencies: [
4
        // ...
5
        .package(
6
            url: "https://github.com/supabase/supabase-swift.git",
7
            from: "2.0.0"
8
        ),
9
    ],
10
    targets: [
11
        .target(
12
            name: "YourTargetName",
13
            dependencies: [
14
                .product(
15
                    name: "Supabase",
16
                    package: "supabase-swift"
17
                ),
18
            ]
19
        )
20
    ]
21
)

1
pip install supabase

1
conda install -c conda-forge supabase

1
dotnet add package Supabase

1
import { createClient } from '@supabase/supabase-js'
2
3
const supabase = createClient('https://<project>.supabase.co', '<sb_publishable_key>')

1
import 'package:supabase_flutter/supabase_flutter.dart';
2
3
void main() async {
4
  await Supabase.initialize(
5
    url: 'https://<project>.supabase.co',
6
    publishableKey: '<sb_publishable_key>',
7
  );
8
  runApp(MyApp());
9
}
10
11
final supabase = Supabase.instance.client;

1
import Supabase
2
3
let supabase = SupabaseClient(
4
  supabaseURL: URL(string: "https://<project>.supabase.co")!,
5
  supabaseKey: "<sb_publishable_key>"
6
)

1
from supabase import create_client, Client
2
3
url: str = "https://<project>.supabase.co"
4
key: str = "<sb_publishable_key>"
5
supabase: Client = create_client(url, key)

1
using Supabase;
2
3
var supabase = new Client(
4
  "https://<project>.supabase.co",
5
  "<sb_publishable_key>"
6
);
7
await supabase.InitializeAsync();

1
// Create a channel with a descriptive topic name
2
const channel = supabase.channel('room:lobby:messages', {
3
  config: { private: true }, // Recommended for production
4
})

1
// Create a channel with a descriptive topic name
2
final channel = supabase.channel('room:lobby:messages');

1
// Create a channel with a descriptive topic name
2
let channel = supabase.channel("room:lobby:messages") {
3
  $0.isPrivate = true
4
}

1
# Create a channel with a descriptive topic name
2
channel = supabase.channel('room:lobby:messages', params={'config': {'private': True }})

1
// Create a channel with a descriptive topic name.
2
// Note: The C# SDK does not yet support private channel configuration,
3
// so this connects to a public channel.
4
var channel = supabase.Realtime.Channel("room:lobby:messages");

1
// Listen for messages
2
channel
3
  .on('broadcast', { event: 'message_sent' }, (payload: { payload: any }) => {
4
    console.log('New message:', payload.payload)
5
  })
6
  .subscribe()
7
8
// Send a message
9
channel.send({
10
  type: 'broadcast',
11
  event: 'message_sent',
12
  payload: {
13
    text: 'Hello, world!',
14
    user: 'john_doe',
15
    timestamp: new Date().toISOString(),
16
  },
17
})

1
// Listen for messages
2
channel.onBroadcast(
3
  event: 'message_sent',
4
  callback: (payload) {
5
    print('New message: ${payload['payload']}');
6
  },
7
).subscribe();
8
9
// Send a message
10
channel.sendBroadcastMessage(
11
  event: 'message_sent',
12
  payload: {
13
    'text': 'Hello, world!',
14
    'user': 'john_doe',
15
    'timestamp': DateTime.now().toIso8601String(),
16
  },
17
);

1
// Listen for messages
2
await channel.onBroadcast(event: "message_sent") { message in
3
  print("New message: \(message.payload)")
4
}
5
6
let status = await channel.subscribe()
7
8
// Send a message
9
await channel.sendBroadcastMessage(
10
  event: "message_sent",
11
  payload: [
12
    "text": "Hello, world!",
13
    "user": "john_doe",
14
    "timestamp": ISO8601DateFormatter().string(from: Date())
15
  ]
16
)

1
# Listen for messages
2
def message_handler(payload):
3
    print(f"New message: {payload['payload']}")
4
5
channel.on_broadcast(event="message_sent", callback=message_handler).subscribe()
6
7
# Send a message
8
channel.send_broadcast_message(
9
    event="message_sent",
10
    payload={
11
        "text": "Hello, world!",
12
        "user": "john_doe",
13
        "timestamp": datetime.now().isoformat()
14
    }
15
)

1
class MessageBroadcast : BaseBroadcast
2
{
3
    [JsonProperty("text")]
4
    public string Text { get; set; }
5
6
    [JsonProperty("user")]
7
    public string User { get; set; }
8
9
    [JsonProperty("timestamp")]
10
    public string Timestamp { get; set; }
11
}
12
13
// Listen for messages
14
var broadcast = channel.Register<MessageBroadcast>();
15
broadcast.AddBroadcastEventHandler((sender, _) =>
16
{
17
    Console.WriteLine($"New message: {broadcast.Current()}");
18
});
19
20
await channel.Subscribe();
21
22
// Send a message
23
await broadcast.Send("message_sent", new MessageBroadcast
24
{
25
    Text = "Hello, world!",
26
    User = "john_doe",
27
    Timestamp = DateTime.UtcNow.ToString("o")
28
});

1
// Send message via REST API
2
const response = await fetch(`https://<project>.supabase.co/rest/v1/rpc/broadcast`, {
3
  method: 'POST',
4
  headers: {
5
    'Content-Type': 'application/json',
6
    -H "apikey: <SECRET_KEY>"
7
  },
8
  body: JSON.stringify({
9
    topic: 'room:lobby:messages',
10
    event: 'message_sent',
11
    payload: {
12
      text: 'Hello from server!',
13
      user: 'system',
14
      timestamp: new Date().toISOString(),
15
    },
16
    private: true,
17
  }),
18
})

1
import 'package:http/http.dart' as http;
2
import 'dart:convert';
3
4
// Send message via REST API
5
final response = await http.post(
6
  Uri.parse('https://<project>.supabase.co/rest/v1/rpc/broadcast'),
7
  headers: {
8
    'Content-Type': 'application/json',
9
    -H "apikey: <SECRET_KEY>"
10
  },
11
  body: jsonEncode({
12
    'topic': 'room:lobby:messages',
13
    'event': 'message_sent',
14
    'payload': {
15
      'text': 'Hello from server!',
16
      'user': 'system',
17
      'timestamp': DateTime.now().toIso8601String(),
18
    },
19
    'private': true,
20
  }),
21
);

1
import Foundation
2
3
// Send message via REST API
4
let url = URL(string: "https://<project>.supabase.co/rest/v1/rpc/broadcast")!
5
var request = URLRequest(url: url)
6
request.httpMethod = "POST"
7
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
8
request.setValue("<SECRET_KEY>", forHTTPHeaderField: "apikey")
9
10
let payload = [
11
  "topic": "room:lobby:messages",
12
  "event": "message_sent",
13
  "payload": [
14
    "text": "Hello from server!",
15
    "user": "system",
16
    "timestamp": ISO8601DateFormatter().string(from: Date())
17
  ],
18
  "private": true
19
] as [String: Any]
20
21
request.httpBody = try JSONSerialization.data(withJSONObject: payload)
22
23
let (data, response) = try await URLSession.shared.data(for: request)

1
import requests
2
from datetime import datetime
3
4
# Send message via REST API
5
response = requests.post(
6
    'https://<project>.supabase.co/rest/v1/rpc/broadcast',
7
    headers={
8
        'Content-Type': 'application/json',
9
        'apikey': '<SECRET_KEY>'
10
    },
11
    json={
12
        'topic': 'room:lobby:messages',
13
        'event': 'message_sent',
14
        'payload': {
15
            'text': 'Hello from server!',
16
            'user': 'system',
17
            'timestamp': datetime.now().isoformat()
18
        },
19
        'private': True
20
    }
21
)

1
// React example
2
import { useEffect } from 'react'
3
4
useEffect(() => {
5
  const channel = supabase.channel('room:123:messages')
6
7
  return () => {
8
    supabase.removeChannel(channel)
9
  }
10
}, [])

1
// Flutter example
2
class _MyWidgetState extends State<MyWidget> {
3
  RealtimeChannel? _channel;
4
5
  @override
6
  void initState() {
7
    super.initState();
8
    _channel = supabase.channel('room:123:messages');
9
  }
10
11
  @override
12
  void dispose() {
13
    _channel?.unsubscribe();
14
    super.dispose();
15
  }
16
}

1
// SwiftUI example
2
struct ContentView: View {
3
  @State private var channel: RealtimeChannelV2?
4
5
  var body: some View {
6
    // Your UI here
7
    .onAppear {
8
      channel = supabase.realtimeV2.channel("room:123:messages")
9
    }
10
    .onDisappear {
11
      Task {
12
        await channel?.unsubscribe()
13
      }
14
    }
15
  }
16
}

1
# Python example with context manager
2
class RealtimeManager:
3
    def __init__(self):
4
        self.channel = None
5
6
    def __enter__(self):
7
        self.channel = supabase.channel('room:123:messages')
8
        return self.channel
9
10
    def __exit__(self, exc_type, exc_val, exc_tb):
11
        if self.channel:
12
            self.channel.unsubscribe()
13
14
# Usage
15
with RealtimeManager() as channel:
16
    # Use channel here
17
    pass

1
// Remove the channel when you are done with it to free up resources
2
supabase.Realtime.Remove(channel);