Messaging Platform SDK - Real-Time Communication Demos

⭐ FEATURED

🎨

Collaborative Whiteboard

Draw together in real-time. Excalidraw-inspired design with instant sync. Perfect for brainstorming, teaching, or creative sessions.

2-20 users simultaneously
Drawing tools & colors
Pan, zoom, undo/redo
Shareable room links

Try Whiteboard Demo

⭐ FEATURED

📁

Quick Share

P2P file sharing via WebRTC DataChannels. Share files directly between browsers with no server storage. Fast, secure, and encrypted end-to-end.

Up to 100MB file transfers
DTLS encryption (P2P)
Real-time progress tracking
Multi-peer file sharing

Try Quick Share

⭐ FEATURED

💬

Real-Time Chat PUBLIC API

Full-featured chat with channels, encrypted sharing, and mobile support.

Real-time messaging
Multi-agent connectivity
QR code room sharing

Open Chat Demo

🧪 EXPERIMENTAL

📹

WebRTC Video PUBLIC API

Video calls with P2P connections. Camera and screen sharing support.

Peer-to-peer video
Screen sharing
TURN/STUN support

Open Video Demo

🔧

Connection Tester

Diagnose WebRTC connectivity. Test TURN/STUN servers and ICE candidates.

Test server connectivity
Verify ICE candidates
Debug connection issues

Open Test Tool

💾

Channel Storage

Persistent key-value storage for channels. Store game state and settings.

PUT/GET/DELETE/LIST
Survives across sessions
Perfect for game saves

Open Storage Demo

👨‍💻

Developer Portal

Manage API keys, channels, view usage stats, and access testing tools.

API key management
Channel management
Usage monitoring

Open Developer Portal

Looking for more examples?

🎮 Check out Mini-Games →

🏗️ System Architecture Overview

The Messaging Platform is a real-time communication system that enables agents (clients) to exchange messages through channels. It supports multiple protocols (HTTP, WebSocket, UDP) and provides features like encryption, WebRTC relay, channel isolation, and ephemeral messaging. The system includes a DB Persistence Layer for session management and a Caching Layer for high-performance operations.

📊 HIGH-LEVEL ARCHITECTURE

🔑 API Key System

The platform uses a flexible API key system with two types of keys for different security requirements.

Original API Key vs Temporary API Key

🔐 API KEY ARCHITECTURE

┌─────────────────────────────────────────────────────────────────────────────────┐
│                           API KEY SYSTEM                                         │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                  │
│   ORIGINAL API KEY (Developer Key)                                             │
│   ├── Permanent key issued to developer                                         │
│   ├── Full access to all features                                               │
│   ├── Used for server-side applications                                         │
│   └── Should be kept SECRET (never expose to clients)                           │
│                                                                                  │
│                          │                                                       │
│                          ▼                                                       │
│   ┌──────────────────────────────────────────────────────────────┐              │
│   │              TEMPORARY KEY SERVICE                          │              │
│   │  ┌────────────────────────────────────────────────────────┐  │              │
│   │  │  • Creates short-lived keys from original key          │  │              │
│   │  │  • Sets expiration time (e.g., 1 hour, 24 hours)       │  │              │
│   │  │  • Restricts capabilities (read-only, specific events) │  │              │
│   │  │  • Limits to specific agent names                      │  │              │
│   │  └────────────────────────────────────────────────────────┘  │              │
│   └──────────────────────────────────────────────────────────────┘              │
│                          │                                                       │
│                          ▼                                                       │
│   TEMPORARY API KEY (Client Key)                                               │
│   ├── Short-lived (expires automatically)                                       │
│   ├── Limited capabilities                                                      │
│   ├── Safe for client-side applications                                         │
│   └── If compromised, expires soon anyway                                       │
│                                                                                  │
└─────────────────────────────────────────────────────────────────────────────────┘

💡 WHEN TO USE EACH:

┌──────────────────────────────────┬──────────────────────────────────────────────┐
│         Original API Key          │              Temporary API Key              │
├──────────────────────────────────┼──────────────────────────────────────────────┤
│ ✓ Server-side applications       │ ✓ Web browsers (JavaScript)                  │
│ ✓ Backend services               │ ✓ Mobile apps                                │
│ ✓ Trusted environments           │ ✓ Untrusted clients                          │
│ ✓ Full feature access needed     │ ✓ Limited feature access OK                  │
│ ✗ Never in client-side code      │ ✓ Safe to expose in client code              │
└──────────────────────────────────┴──────────────────────────────────────────────┘

Temporary Key Flow

Server Creates Temporary Key

Your backend server uses the original API key to create a temporary key with specific restrictions.

Client Receives Temporary Key

The temporary key is sent to the client (browser, mobile app). It's safe to transmit over the network.

Client Connects to Channel

The client uses the temporary key to connect. The platform validates it and applies restrictions.

Key Expires Automatically

After the expiration time, the key stops working. Client needs a new temporary key to continue.

🌐 API Key Scope - Channel Isolation

The apiKeyScope parameter controls how channels are isolated between different developers. This is crucial for both security (production) and convenience (testing).

🔒 PRIVATE SCOPE (Default) - Channel Isolation

🌍 API Key Scope - Shared Channels

The apiKeyScope parameter controls how channels are isolated between different developers. This is crucial for both security (production) and convenience (testing).

🌍 PUBLIC SCOPE - Shared Channels

When to Use Each Scope

🔒 Private Scope (Default)

Production applications
Multi-tenant systems
When user data must be isolated
Billing/metering per developer
Security-sensitive applications

🌍 Public Scope

Testing with teammates
SDK examples and demos
Cross-developer collaboration
Public game lobbies
Community features

📡 Connection & Message Flow

Understanding how agents connect and exchange messages through the platform.

🔄 CONNECTION FLOW

📦 Three-Layer Messaging Architecture

The platform uses a sophisticated three-layer storage system to optimize message delivery for different use cases. Messages flow through Cache for instant access, Kafka for reliable message brokering, and Database for permanent persistence.

🗄️ MESSAGE STORAGE LAYERS

📤 Message Send Flow

When an agent sends a regular (persistent) message, it flows through all three layers:

Message Sent to Service

Agent sends message via HTTP/WebSocket/UDP to the messaging service.

Written to Cache

Message is immediately cached in memory for fast access. Limited retention time (TTL-based).

Published to Kafka

Message is published to Kafka for reliable delivery and event streaming. Has retention limits (not permanent).

Persisted to Database

Message is saved to the database for permanent storage, structured querying, and long-term audit trails.

📥 Message Receive with pollSource

The pollSource parameter lets you control which layer(s) to read from. This is crucial for optimizing performance based on your use case.

🎯 pollSource OPTIONS

┌─────────────────────────────────────────────────────────────────────────────────┐
│                          pollSource VALUES                                       │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                  │
│  AUTO (Default - Recommended)                                                   │
│  ├── Tries all layers in order: Cache → Kafka → Database                        │
│  ├── Falls back automatically if a layer has no data                            │
│  ├── Best for: General purpose, balanced performance                            │
│  └── 💡 Smartly optimizes between speed and completeness                        │
│                                                                                  │
│  CACHE (Ultra-Fast Mode)                                                         │
│  ├── Reads ONLY from in-memory cache                                            │
│  ├── Fastest possible response time (< 1ms typical)                             │
│  ├── Best for: Real-time gaming, live updates, high-frequency polling           │
│  ├── ⚠️ Warning: May miss messages not yet cached or already expired            │
│  └── 🎮 Use case: Air Hockey game, cursor tracking, live player positions       │
│                                                                                  │
│  KAFKA (Message Broker Mode)                                                    │
│  ├── Reads ONLY from Kafka message broker                                       │
│  ├── Access to recent message stream (has retention limits)                     │
│  ├── Best for: Event streaming, real-time delivery, recent history              │
│  ├── ⚠️ Note: Not permanent - messages expire after retention period            │
│  └── 📨 Use case: Live event streaming, recent message replay                   │
│                                                                                  │
│  DATABASE (Permanent Storage Mode)                                             │
│  ├── Reads ONLY from database (permanent storage)                               │
│  ├── Access to complete, permanent message history                              │
│  ├── Best for: Audit trails, compliance, historical queries, analytics          │
│  ├── ♾️ Source of truth - messages stored permanently                           │
│  └── 🔐 Use case: Compliance reporting, audit logs, data analysis               │
│                                                                                  │
└─────────────────────────────────────────────────────────────────────────────────┘

💡 HOW TO USE pollSource:

JavaScript:
agent.connect({
    channelName: 'game-room',
    channelPassword: 'secret',
    agentName: 'Player-1',
    pollSource: 'CACHE'  // Set default for all receives
});

// All receives use CACHE automatically
agent.receive(range);  // Uses CACHE

// Override per-request if needed
agent.receive({...range, pollSource: 'KAFKA'});

Python:
agent.connect(
    channel_name='game-room',
    channel_password='secret',
    agent_name='Player-1',
    poll_source='CACHE'  # Set default
)

# Receives use CACHE by default
agent.receive(session_id, config)

C++:
api.connect(
    "game-room",
    "secret",
    "Player-1",
    "",        // sessionId
    "",        // channelId
    false,     // enableWebrtcRelay
    "private", // apiKeyScope
    "CACHE"    // pollSource
);

api.receive(sessionId, config);  // Uses CACHE

🎮 Real-World Example: Gaming vs Audit

🎮

Gaming Scenario - Ultra-Low Latency

Use pollSource: 'CACHE' - Air Hockey game needs to update paddle positions 60 times per second. Cache-only polling provides sub-millisecond response times, perfect for real-time gameplay.

🔐

Audit Scenario - Permanent History

Use pollSource: 'DATABASE' - Compliance system needs to retrieve all chat messages from last month. Database provides complete, permanent message history for regulatory reporting and audit trails.

📨

Event Streaming - Recent Messages

Use pollSource: 'KAFKA' - Real-time event streaming for recent activity feeds. Kafka provides high-throughput access to recent messages within the retention period.

📊

General Chat - Balanced Approach

Use pollSource: 'AUTO' - Normal chat application benefits from the automatic fallback. Recent messages come from cache (fast), then Kafka, with database as the permanent backup.

🚀 Future Enhancement

Channel-level capabilities will eventually control storage behavior per channel, allowing fine-grained control over which layers are used for different types of channels (e.g., ephemeral-only channels, audit channels, etc.).

⚡ Ephemeral Message Flow

Ephemeral messages provide low-latency, non-persistent communication ideal for real-time updates like player positions, cursor movements, or live status changes.

Agent Sends Ephemeral Message

Message is sent with ephemeral: true flag. The message is not stored in the database and is only held in memory.

Service Routes to Connected Agents

The messaging service immediately delivers the message to all connected agents in the channel without persistence overhead.

Message Discarded After Delivery

Once delivered, ephemeral messages are discarded. Agents that join later will not receive historical ephemeral messages.

💡

Use Cases for Ephemeral Messages

Player positions in games, cursor movements in collaborative tools, live typing indicators, real-time sensor data, and other high-frequency updates that don't need persistence.

🔌 Protocol Support

The platform supports multiple communication protocols for different use cases.

📶 SUPPORTED PROTOCOLS

┌─────────────────────────────────────────────────────────────────────────────────┐
│                           TRANSPORT PROTOCOLS                                    │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                  │
│  ┌─────────────────────┐   ┌─────────────────────┐   ┌─────────────────────┐    │
│  │      HTTP/REST       │   │     WebSocket        │   │        UDP          │    │
│  │      ✅ STABLE       │   │   🚧 IN PROGRESS    │   │   🚧 IN PROGRESS    │    │
│  ├─────────────────────┤   ├─────────────────────┤   ├─────────────────────┤    │
│  │ • Request/Response  │   │ • Persistent conn   │   │ • Low latency       │    │
│  │ • Reliable delivery │   │ • Real-time push    │   │ • Unreliable        │    │
│  │ • Long polling      │   │ • Auto-reconnect    │   │ • Best for games    │    │
│  │ • Works everywhere  │   │ • Efficient         │   │ • Position updates  │    │
│  │ • Production ready  │   │ • Coming soon...    │   │ • Coming soon...    │    │
│  └─────────────────────┘   └─────────────────────┘   └─────────────────────┘    │
│           │                         │                         │                  │
│           │    ┌────────────────────┼────────────────────┐    │                  │
│           └────┤                    │                    ├────┘                  │
│                │          AGENT SDK                    │                       │
│                │   (Automatically selects best protocol) │                       │
│                └─────────────────────────────────────────┘                       │
│                                                                                  │
│  CURRENT STATUS:                                                               │
│  ┌─────────────────────────────────────────────────────────────────────────┐    │
│  │ ✅ HTTP/REST   - Fully supported, production ready                       │    │
│  │ 🚧 WebSocket   - In development, basic support available                 │    │
│  │ 🚧 UDP         - In development, experimental support                    │    │
│  └─────────────────────────────────────────────────────────────────────────┘    │
│                                                                                  │
│  USE CASE RECOMMENDATIONS:                                                    │
│                                                                                  │
│  ┌─────────────────────────────────────────────────────────────────────────┐    │
│  │ Chat Apps        → HTTP (polling) - stable, WebSocket coming soon       │    │
│  │ Multiplayer Games → HTTP now, UDP support coming for fast updates        │    │
│  │ IoT Devices      → HTTP (simple, reliable)                              │    │
│  │ Web Browsers     → HTTP (stable) or WebSocket (when available)         │    │
│  └─────────────────────────────────────────────────────────────────────────┘    │
│                                                                                  │
└─────────────────────────────────────────────────────────────────────────────────┘

📹 WebRTC Integration

The platform provides signaling support for WebRTC peer-to-peer connections.

🎥 WEBRTC SIGNALING FLOW

┌─────────────────────┐              ┌─────────────────┐              ┌─────────────────────┐
│     Browser A       │              │ MESSAGING CHANNEL│             │     Browser B       │
│  agentName: "alice" │              │  (Signaling)    │              │  agentName: "bob"   │
│  (Caller)           │              │              │  (Callee)           │
└──────────┬──────────┘              └────────┬────────┘              └──────────┬──────────┘
           │                                  │                                  │
           │  Both connected to same channel: │                                  │
           │  channelName: "video-room"       │                                  │
           │  channelPassword: "secret"       │                                  │
           │  apiKey: "key-123"               │                                  │
           │                                  │                                  │
           │  1. Create Offer (SDP)           │                                  │
           │  send({to: "bob", type: WEBRTC}) │                                  │
           │─────────────────────────────────►│                                  │
           │                                  │  2. Relay Offer to "bob"         │
           │                                  │─────────────────────────────────►│
           │                                  │                                  │
           │                                  │  3. Create Answer (SDP)          │
           │                                  │  send({to: "alice", type: WEBRTC})
           │                                  │◄─────────────────────────────────│
           │  4. Relay Answer to "alice"      │                                  │
           │◄─────────────────────────────────│                                  │
           │                                  │                                  │
           │  5. Exchange ICE Candidates      │                                  │
           │  (via channel messages)          │                                  │
           │◄────────────────────────────────►│◄────────────────────────────────►│
           │                                  │                                  │
           │                                                                     │
           │  ═══════════════════════════════════════════════════════════════════│
           │                     6. DIRECT P2P CONNECTION                      │
           │                     (Video/Audio Stream)                            │
           │                     No server involved!                             │
           │═════════════════════════════════════════════════════════════════════│
           │                                                                     │

✓ The messaging channel is only used for signaling - actual media flows directly P2P!
✓ Use agentName to target specific peer for WebRTC offers/answers

📋 Quick Reference

🚀 CONNECT API - ALL OPTIONS

// JavaScript Example - All Connection Options
const agent = new AgentConnection();

agent.connect({
    // Required
    channelName: 'my-channel',        // Channel name
    channelPassword: 'secret123',      // Channel password (hashed automatically)
    agentName: 'player-1',             // Your agent identifier

    // API Key Options
    apiKey: 'your-api-key',            // Original or Temporary API key
    apiKeyScope: 'private',            // 'private' (default) or 'public'

    // Optional Features
    autoReceive: true,                 // Auto-poll for messages
    useWebsocket: true,                // Use WebSocket if available
    enableWebrtcRelay: false,          // Enable WebRTC signaling relay

    // Advanced
    sessionId: null,                   // For reconnection
    channelId: null,                   // Pre-computed channel ID
    customEventType: 'game,chat'       // Filter specific event types
});

// EVENT HANDLERS
agent.onMessage = (msg) => console.log('Received:', msg);
agent.onConnect = () => console.log('Connected!');
agent.onDisconnect = () => console.log('Disconnected');
agent.onError = (err) => console.error('Error:', err);

🎮 Mini-Games

Interactive multiplayer games built with the Messaging Platform SDK. These examples demonstrate real-time communication, WebRTC peer-to-peer networking, physics synchronization, and game state management.

⭐ FEATURED

🏒

Air Hockey

Classic 2-player air hockey game with realistic physics. Use your paddle to hit the puck into your opponent's goal. Perfect showcase of real-time P2P gameplay!

2-player competitive gameplay
Realistic physics engine
Score tracking & animations
Ultra-low latency P2P

Play Air Hockey

⭐ FEATURED

❓

Quiz Battle

Multiplayer trivia quiz game. Answer questions quickly to earn points. Compete with friends across multiple categories with real-time scoring.

2-8 players simultaneously
Multiple quiz categories
Real-time scoring
Timed questions
Leaderboard

Play Quiz Battle

🚧 COMING SOON

⚡

4-Player Reactor

Fast-paced 4-player reaction game. Compete to click targets as quickly as possible. Test your reflexes and compete for the best reaction times!

4 players real-time competition
Reaction time tracking
Multiple game modes
Visual & audio cues
High score system

Coming Soon

🧪 EXPERIMENTAL

🤥

Find the Liar

Social deduction party game where players answer questions about a secret item. Liars get hints while others know the truth. Vote to catch the liar!

3-10 players party game
Multiple liars support
Vote threshold mechanics
80 items & 30 questions
Liar celebration effects

Play Find the Liar

🆕 NEW

🎉

Party Physics Brawl

Multiplayer physics-based party game! Battle with unique characters in arenas. Host-authoritative with Rapier physics and Three.js graphics.

2-8 players real-time combat
5 unique character archetypes
Fight Mode (MVP complete)
Mobile touch controls
HP & stamina system

Play Party Physics

🚧 COMING SOON

🏁

Race Balls

3D racing game with physics-based ball controls. Race against other players through obstacles, boost pads, and checkpoints to reach the finish line first.

2-4 players real-time racing
Three.js 3D graphics
Physics synchronization
Multiple race tracks
Boost & stamina system

Coming Soon

IN PROGRESS

🏃

Fall Guys Race

Obstacle course racing game inspired by Fall Guys. Navigate through challenging obstacles, avoid hazards, and race to the finish line with other players.

Multi-player obstacle racing
Dynamic obstacles
Colorful 3D graphics
Player collisions
Multiple rounds

Coming Soon

🔧 Technical Implementation

All games are built using the Messaging Platform SDK with:

📡

Real-time Messaging

AgentConnection for player synchronization and game events

🔗

WebRTC P2P

Low-latency peer-to-peer for fast-paced gameplay (10-30ms)

🎨

Three.js Graphics

3D rendering, physics simulation, and visual effects

💾

Channel Storage

Persistent game state, leaderboards, and player progress

💻 Code Examples

Quick code snippets to get you started with the Messaging Platform SDK. For complete documentation, visit the User Guide.

🔌 Basic Connection

JavaScript (Web Agent)

// Include SDK files
<script src="js/web-agent.libs.js"></script>
<script src="js/web-agent.js"></script>

// Create connection
const agent = new AgentConnection();

// Connect to channel
agent.connect({
    channelName:     'my-game-lobby',
    channelPassword: 'secure-password',
    agentName:       'player-1',
    api:             'https://hmdevonline.com/messaging-platform/api/v1/messaging-service',
    apiKey:          'your-api-key',
    autoReceive:     true
});

// Handle messages
agent.onMessage = (msg) => {
    console.log('Received:', msg.content);
};

// Send message
agent.sendTextMessage('Hello, World!');

Java Agent

import com.hmdev.messaging.agent.core.AgentConnection;

AgentConnection agent = new AgentConnection(
    "https://hmdevonline.com/messaging-platform/api/v1/messaging-service",
    "your-api-key"
);

agent.connect("my-game-lobby", "player-1", "secure-password");
agent.sendMessage("Hello, World!");
agent.disconnect();

Python Agent

from messaging_agent import AgentConnection

agent = AgentConnection(
    api_url="https://hmdevonline.com/messaging-platform/api/v1/messaging-service",
    api_key="your-api-key"
)

agent.connect("my-game-lobby", "player-1", "secure-password")
agent.send_message("Hello, World!")
agent.disconnect()

💬 Sending Messages

Simple Text Message

// Quick way to send text
agent.sendTextMessage('Hello, World!');

Object Format (Full Control)

// Send with all options
agent.sendMessage({
    content:    'Hello, World!',
    type:       'chat-text',        // Message type (default: 'chat-text')
    to:         'player-2',         // Target specific agent (optional)
    ephemeral:  false               // Non-persistent message (optional)
});

// Broadcast to all agents
agent.sendMessage({
    content: 'Game started!',
    type:    'game-event'
});

// Send to specific agent
agent.sendMessage({
    content: 'Private message',
    to:      'player-2'
});

// Use filter (regex pattern)
agent.sendMessage({
    content: 'Team message',
    filter:  'team-.*'              // Matches team-red, team-blue, etc.
});

Custom Message Types

// Game state update
agent.sendMessage({
    content: JSON.stringify({
        position: { x: 10, y: 20 },
        health:   100
    }),
    type:    'game-state'
});

// Player action
agent.sendMessage({
    content: JSON.stringify({ action: 'jump' }),
    type:    'player-action'
});

// Ephemeral message (not stored)
agent.sendMessage({
    content:   'Typing...',
    type:      'typing-indicator',
    ephemeral: true
});

📹 WebRTC Peer-to-Peer

Setup WebRTC Helper

// Include WebRTC support
<script src="js/web-agent.webrtc.js"></script>

// Create WebRTC helper (after connecting agent)
const webrtc = new WebRTCHelper(agent);

// Handle incoming data
webrtc.onDataReceived = (data, peerId) => {
    console.log('Received from', peerId, ':', data);
};

// Send data to all peers
webrtc.sendData({
    type:     'game-state',
    position: { x: 10, y: 20 }
});

// Send to specific peer
webrtc.sendData(data, 'specific-peer-id');

💾 Channel Storage

Store and Retrieve Data

// Store data
await agent.putStorage(
    'player-score',
    JSON.stringify({ score: 1000 })
);

// Retrieve data
const data  = await agent.getStorage('player-score');
const score = JSON.parse(data);

// Delete data
await agent.deleteStorage('player-score');

// List all keys
const keys = await agent.listStorageKeys();
console.log('Stored keys:', keys);

🎮 Game State Synchronization

Example: Player Position Sync

// Send player position update
function updatePosition(x, y, z) {
    const update = {
        type:      'position',
        playerId:  agent.agentName,
        position:  { x, y, z },
        timestamp: Date.now()
    };

    // Use WebRTC for low latency
    if (webrtc && webrtc.isConnected()) {
        webrtc.sendData(update);
    } else {
        // Fallback to messaging
        agent.sendTextMessage(JSON.stringify(update));
    }
}

// Receive position updates
webrtc.onDataReceived = (data) => {
    if (data.type === 'position') {
        updateRemotePlayer(data.playerId, data.position);
    }
};

🔐 API Key Scopes

Private vs Public Channels

// PRIVATE scope (default) - isolated per API key
agent.connect({
    channelName:     'production-game',
    channelPassword: 'secure123',
    agentName:       'player-1',
    api:             'https://hmdevonline.com/messaging-platform/api/v1/messaging-service',
    apiKey:          'your-api-key',
    apiKeyScope:     'private'  // Each developer gets separate channel
});

// PUBLIC scope - shared across all API keys
agent.connect({
    channelName:     'test-lobby',
    channelPassword: 'demo',
    agentName:       'tester-1',
    api:             'https://hmdevonline.com/messaging-platform/api/v1/messaging-service',
    apiKey:          'your-api-key',
    apiKeyScope:     'public'  // Anyone with same name+password connects to same channel
});

📚 More Resources

For complete API documentation, detailed guides, and advanced examples:

📖 Full Documentation 👨‍💻 Developer Portal GitHub Repo

✨ Platform Features

Comprehensive real-time communication features for building modern multiplayer applications

Core Communication

📡

Real-time Messaging

WebSocket-based messaging with automatic reconnection, message ordering, and delivery guarantees. Support for text, binary, and structured data.

🔗

WebRTC P2P

Ultra-low latency peer-to-peer communication (10-30ms) using WebRTC DataChannels. Perfect for real-time games and interactive applications.

🔐

Channel Isolation

Private and public channel scopes with password protection. Flexible API key system with temporary keys for client-side applications.

💾

Channel Storage

Persistent key-value storage per channel. Perfect for game state, leaderboards, settings, and any data that needs to survive across sessions.

🌐

Multi-Platform SDKs

Consistent API across JavaScript (Web), Java (Desktop), Python (Scripts), and C++ (Games). Write once, deploy everywhere.

📹

Video/Audio Streaming

WebRTC video and audio streaming with camera, screen sharing, and recording capabilities. Built-in TURN/STUN server support.

Developer Experience

👨‍💻

Developer Portal

Web-based dashboard for API key management, channel monitoring, usage statistics, and account settings. No installation required.

📚

Comprehensive Docs

Detailed documentation with code examples, tutorials, and best practices. Interactive demos and working examples for every feature.

🚀

Quick Start

Get started in minutes with simple API design and minimal configuration. Include SDK files, connect to a channel, and start messaging.

🔧

Debugging Tools

Built-in connection testing, TURN/STUN verification, WebRTC diagnostics, and comprehensive logging for troubleshooting.

🎮

Game-Ready Examples

Complete multiplayer game examples including racing, air hockey, quiz battle, and more. Learn from production-ready code.

📱

Mobile Optimized

Responsive design and touch-friendly interfaces. All demos and games work seamlessly on mobile devices and tablets.

🔮

Coming Soon

📊 Advanced Analytics

🔔 Push Notifications

🤖 Bot SDK

🌍 Regional Servers

📦 File Sharing

🔒 End-to-End Encryption

📋 Current Status

🚧

Free Pre-Production Demo

This SDK is currently available as a free demo and pre-production release for exploration, testing, and feedback. The platform is in active development, and APIs, features, and functionality may change as we refine the system.

What This Means:

✓ The SDK is completely free to use for development and experimentation
✓ There are no paid plans or pricing commitments at this time
✓ APIs and features may change as we gather feedback and improve the platform
✓ This is an excellent opportunity to explore real-time messaging capabilities and provide input

⚠️

Not Recommended for Production

As this is a pre-production release, we recommend using it for development, testing, and prototyping rather than production deployments. Service availability and data persistence are not guaranteed during this phase.

We're actively working toward a stable production release. If you have questions, feedback, or encounter issues, please reach out—your input helps shape the platform's future.

Current Features & Capabilities

🔌

Full SDK Access Web, Java, Python, and C++ SDKs with complete API access

📡

Real-Time Messaging Channel-based messaging with encryption and ephemeral support

📹

WebRTC Integration Signaling support for peer-to-peer connections

🔐

Security Features API key management, channel isolation, temporary keys

Approximate Technical Limits (Subject to change)

~100

Agents per channel

~1000

Messages per hour

~10 MB

Storage per channel

These are approximate limits and may be adjusted during development

Ready to Explore?

Request a free API key to start building with the Messaging Platform SDK. No credit card required, and you'll have instant access upon approval.

🚀 Platform Roadmap & Future Enhancements

The Messaging Platform is continuously evolving. Here's what's currently implemented, in progress, and planned for the future.

Implemented

In Progress

Planned

📡

Multi-Mode Communication Architecture

IN PROGRESS

5 distinct communication modes for developers to choose the optimal architecture for their use case

✓ P2P Mesh

Direct peer-to-peer for 2-3 players. Ultra-low latency (10-30ms). SDK complete.

✓ P2P Host Mode

Host-based star topology with automatic migration. Perfect for 4-10 players. SDK complete.

⏳ WebSocket Relay

Server relay via WebSocket. Firewall-friendly, no WebRTC needed. SDK complete, backend partial.

📋 DataChannel Server

Low-latency server validation via DataChannel relay. SDK complete, backend pending.

✓ SFU Media

Node.js SFU server ready. Uses SDK's unified WebRtcHelper. Client integration pending.

Developer Benefits: Choose the right mode for your use case. Switch modes without code changes. Same API across all modes.

🔧

Unified WebRTC Helper

COMPLETE

Single codebase for WebRTC functionality across browser clients and Node.js SFU server

✓ Supports @roamhq/wrtc and wrtc for Node.js
✓ SFU relay support via sourceStreamId option
✓ Browser and Node.js compatibility with single codebase
✓ Easier maintenance: fix once, applies everywhere

🎮

Game Server Integration

PLANNED

Allow developers to run authoritative game servers with full control over game logic

Webhook Integration

HTTP POST to developer's server for all game events

WebSocket Connection

Persistent connection for real-time event streaming

Server-Side Agent

Developer's server acts as special relay agent

✨

Recent Updates

Latest improvements and additions to the platform

January 31, 2026: NEW API Key Scope Feature

New apiKeyScope parameter for channel isolation. Use "private" (default) for production or "public" for testing/demos.

January 31, 2026: NEW Architecture Diagrams

Added SVG architecture diagrams: System Overview, API Key System, Private/Public Scope visualization, Connection Flow, and Protocol Support status.

January 31, 2026: NEW Temporary API Key Docs

Clarified temporary API keys are optional. Use original API key directly or temporary keys for enhanced client-side security.

January 2026: Multi-Mode Relay Architecture

Added 5 communication modes, unified WebRtcHelper, and Node.js SFU server

January 2026: TURN/STUN Over TLS

Added TCP-TLS relay on port 443 for corporate/VPN environments

January 2026: Developer Console

API key request system with admin approval, email notifications, and developer portal

January 2026: Whiteboard Enhancements

Professional undo/redo system, board locking, zoom controls, and mobile optimization

💾

Channel Storage API

PARTIAL

Persistent key-value storage for channels. Store game state, leaderboards, and settings.

✓ Web Agent (JS)

Complete implementation with PUT, GET, DELETE, and LIST operations

⏳ Java Agent

Coming soon - same API for desktop and server applications

⏳ Python Agent

Coming soon - async/await support for bots and scripts

⏳ C++ Agent

Coming soon - high-performance game integration

Try it now: Check out the Storage Demo to see the Channel Storage API in action with the Web Agent.

💡 Have Suggestions?

This platform is evolving based on developer feedback. Request an API key to start building and share your ideas!

🚀 Quick Start — 3 Steps

Collaborative Whiteboard

Quick Share

Real-Time Chat PUBLIC API

WebRTC Video PUBLIC API

Connection Tester

Channel Storage

Developer Portal

Pictionary

Chess

Pixel Art Editor

Collaborative Document

Mind Map Builder

🏗️ System Architecture Overview

🔑 API Key System

Original API Key vs Temporary API Key

Temporary Key Flow

Server Creates Temporary Key

Client Receives Temporary Key

Client Connects to Channel

Key Expires Automatically

🌐 API Key Scope - Channel Isolation

🌍 API Key Scope - Shared Channels

When to Use Each Scope

🔒 Private Scope (Default)

🌍 Public Scope

📡 Connection & Message Flow

📦 Three-Layer Messaging Architecture

📤 Message Send Flow

Message Sent to Service

Written to Cache

Published to Kafka

Persisted to Database

📥 Message Receive with pollSource

🎮 Real-World Example: Gaming vs Audit

Gaming Scenario - Ultra-Low Latency

Audit Scenario - Permanent History

Event Streaming - Recent Messages

General Chat - Balanced Approach

⚡ Ephemeral Message Flow

Agent Sends Ephemeral Message

Service Routes to Connected Agents

Message Discarded After Delivery

Use Cases for Ephemeral Messages

🔌 Protocol Support

📹 WebRTC Integration

📋 Quick Reference

🎮 Mini-Games

Air Hockey

Quiz Battle

4-Player Reactor

Find the Liar

Party Physics Brawl

Race Balls

Fall Guys Race

🔧 Technical Implementation

💻 Code Examples

🔌 Basic Connection

JavaScript (Web Agent)

Java Agent

Python Agent

💬 Sending Messages

Simple Text Message

Object Format (Full Control)

Custom Message Types

📹 WebRTC Peer-to-Peer

Setup WebRTC Helper

💾 Channel Storage

Store and Retrieve Data

🎮 Game State Synchronization

Example: Player Position Sync

🔐 API Key Scopes

Private vs Public Channels

📚 More Resources

✨ Platform Features

Core Communication

Real-time Messaging

WebRTC P2P

Channel Isolation

Channel Storage