Blind encrypted relay for modern product teams

Real-time messaging, calls, and encryption for apps that need trust.

Compose your real-time stack from eight solutions — messaging, video calls, meeting rooms, broadcast, groups, transport choices, attachments, trust — on one SDK across web, Android, and iOS.

Start freeExplore solutions
JavaScript, Android, iOS SDKsOffline delivery and receiptsEncrypted and cleartext modes

Product flow

From identity to delivery in one system.

Your productAuth, UI, business rules
  • User signs in
  • Backend exchanges SDK token
  • Client initializes once
DropOnAirDelivery and control plane
  • Messages and offline queue
  • Call signaling and broadcasts
  • Receipts, retention, and quotas
User experienceTrusted real-time UX
  • Encrypted chat
  • Voice and video handoff
  • Multi-device continuity
MessagingGroup callsRooms & SFUBroadcastTransportAttachmentsTrust

Solutions

Eight ways to use the platform, one SDK.

Each solution maps a piece of DropOnAir to something your customers actually use. Pick the one that fits your roadmap; the rest are still there when you need them.

Video & calls

Group voice & video

Mesh up to 16, SFU up to 64. Recording to your bucket. E2EE by default.

Explore →

Real-time messaging

E2EE messaging

Encrypted 1:1 & group chat, offline delivery, multi-device sync.

Explore →

Meeting rooms

Scheduled rooms & stages

Persistent rooms, host controls, audience roles, server-side recording.

Explore →

Pub-sub broadcast

Fan-out at speed

One publisher to thousands of subscribers in milliseconds.

Explore →

Groups & communities

Group messaging

Server-managed groups, member roles, encrypted or cleartext.

Explore →

Transport choices

WS · SSE · HTTP/3 · MQTT

Pick the right lane per environment. Same wire format everywhere.

Explore →

Your storage

Customer-managed attachments

Direct upload to your S3 / GCS / Azure bucket via presigned URLs.

Explore →

Trust & security

Blind relay & per-device keys

E2EE by architecture. Per-device keys, remote revoke, BYO storage.

Explore →

Inside the platform

The pillars under every solution.

The solutions above are how customers compose the platform. The pillars below are what's under each one — open them to see how the relay stays blind, how delivery survives offline windows, and how cleartext + encrypted coexist.

Blind relay encryption

DropOnAir routes ciphertext, receipts, and presence without seeing plaintext content.

Client SDKs generate keys locally, derive shared secrets, and encrypt before transmission. Your backend remains the authentication source of truth through token exchange, while message content stays outside the relay.

Read the docs

One platform for encrypted and cleartext delivery

Use E2EE when privacy matters and cleartext when moderation, bots, or searchable content matters.

Both modes share the same delivery lifecycle, SDK surface, and operational controls, so product teams do not need to maintain separate real-time stacks for each content type.

Read the docs

Offline delivery and receipt state

Messages survive reconnects and return send, delivered, and read-style updates over the same session.

DropOnAir queues offline messages, preserves order, and exposes receipt events through the same transport used for content delivery, which keeps inbox UX reliable without extra infrastructure.

Read the docs

Call signaling and group coordination

Move from private chat into voice, video, and group call flows without a second backend.

The platform handles call frames, participant events, and usage tracking while your app controls the media experience. This keeps real-time behavior cohesive as products grow from messaging into live communication.

Read the docs

Dashboard controls built for production

API keys, quotas, retention, and billing stay visible in one control plane.

Instead of assembling separate tools for auth, usage tracking, and retention policy, your team can manage the product surface and the operational surface from the same place.

Read the docs

How it works

From first token exchange to production controls in four steps.

01

Create your app and keys

Register an app in the dashboard, copy the App ID, and issue server-side credentials once.

02

Exchange a short-lived user token

Your backend authenticates the user and exchanges a DropOnAir SDK token for that session.

03

Connect the SDK and ship product flows

Initialize the client, open the socket, and deliver messaging, calling, or broadcast events.

04

Control usage as you scale

Use retention settings, quotas, and the dashboard to move from prototype to production.

Use cases

Built for teams that need trust, speed, and clear product boundaries.

Marketplaces and community apps

Blend private chat, group experiences, alerts, and live calls without stitching together four vendors.

Messaging, groups, broadcast, and calls share one identity and delivery plane.

Healthcare, finance, and private workflows

Protect sensitive conversations while keeping authorization and operational policy in your backend.

The relay never needs plaintext access to deliver encrypted payloads.

SaaS products adding collaboration

Embed messaging and live presence into an existing workflow instead of building a separate communication stack.

Short-lived token exchange keeps auth aligned with your existing application model.

Teams shipping across web and mobile

Keep continuity when users move between phone, tablet, and desktop over unstable networks.

Multi-device delivery, offline queueing, and SDK versioning are part of the platform.

Developers

Quickstart without the marketing fog.

The first meaningful integration is simple: authenticate the user, initialize the SDK, then ship the messaging and calling flows your app actually needs.

InstallationPackage managers, supported platforms, and the credentials you need first.Read installation guideQuick startSee the minimal token exchange and SDK initialization path before you build UI.Open quick startDemo applicationsReference apps and backend samples that show the complete integration flow.See demo appsPricingUnderstand how messaging, calls, and growth limits map to production usage.View pricing
// Authenticate in your backend, then initialize once
import { initialize } from '@droponair/sdk-js';

const client = await initialize({
  appId: 'your-app-id',
  publicApiKey: 'your-public-api-key',
  getUserJwt: async () => fetchJwt(),
  tokenExchangeEndpoint: '/api/droponair/token',
  keyDirectoryEndpoint: '/api/droponair/keys',
});

// Ship the product surface you need
await client.sendMessage('recipient-id', 'Hello!');
client.onCallEvent(event => handleCall(event));
await client.subscribeBroadcast('announcements');

Trust and scale

Security, reliability, and operational control are part of the product, not add-ons.

Security by architecture

The platform is designed so content protection and delivery can coexist.

  • Client-side encryption for private messaging flows
  • Your backend remains the identity and authorization source
  • Blind relay transport for ciphertext, receipts, and presence

Reliable delivery for real products

The user experience holds up when people go offline, reconnect, or move devices.

  • Offline queueing with ordered delivery on reconnect
  • Receipt events on the same real-time session
  • Messaging and calls on one transport plane

Operational control as you scale

Product teams get controls for apps, keys, retention, usage, and plan limits.

  • Dashboard-managed API credentials and app settings
  • Retention and usage guardrails tied to your app plan
  • Broadcast, group, and call limits in the same control plane

Start with the free plan

Build with 500 messages and 30 call minutes included.

Keep the first integration small, preserve your existing auth model, and grow into production features when the product is ready.

Create free accountRead quick start