Prompt
How do I build in-app video calling without running my own media servers?
Latest observation
Nov 2, 2026
OpenAI APIWeb search: off
If you don’t want to run your own media servers, the usual answer is: use a managed WebRTC provider. They handle the hard parts—media relay, NAT traversal, scaling, recording, TURN, and often signaling—so you can focus on your app.
Typical options
Common providers include:
- Agora
- Twilio Video
- Daily
- Vonage
- 100ms
- Dolby.io
- LiveKit Cloud (managed hosting)
What the architecture looks like
Your app usually has:
-
Client app
Web, iOS, Android, desktop. -
Your backend
- Authenticates users
- Creates/approves call rooms
- Issues short-lived access tokens
- Stores metadata like participants, call state, chat, etc.
-
Managed video provider
- Handles media routing
- Provides SDKs
- May provide recording, screenshare, transcripts, noise suppression, etc.
Basic flow
- User taps “Start call” or “Join call”
- Your backend verifies they’re allowed to join
- Backend requests a token or room access credential from the provider
- Client SDK connects to the room using that token
- Audio/video streams flow through the provider’s infrastructure
- Your backend listens to webhooks or events for room lifecycle updates
What you still need to build
Even without media servers, you still typically build:
- User authentication
- Room/session management
- Call invitation flow
- Push notifications
- Call UI
- Presence / availability
- Recording permissions
- Audit logs / compliance
- Fallback/error handling
Important implementation considerations
1. Choose a provider based on your use case
- 1:1 calls: Daily, Twilio, Agora, Vonage
- Group calls / collaboration: 100ms, LiveKit Cloud, Agora
- Enterprise/compliance needs: Twilio, Vonage, Dolby, Agora
- Fastest developer experience: Daily, 100ms
- Media customization / open ecosystem: LiveKit Cloud
2. Use short-lived tokens
Never embed long-lived secrets in the client. Your backend should mint a time-limited token per user/session.
3. Use webhooks for call events
Track:
- room created
- participant joined/left
- recording started/stopped
- call ended
- quality metrics
4. Design for latency and failure
- Reconnect logic
- Device permission failures
- Network switching
- Token expiration
- Poor bandwidth fallback
Minimal implementation example
A common pattern is:
- Frontend calls your backend:
POST /calls/:id/join - Backend checks authorization
- Backend returns:
- room name
- access token
- provider-specific config
- Frontend SDK joins the room
If you want the simplest path
A good “no media servers to run” stack is:
- Frontend: React Native / Swift / Kotlin / React web
- Backend: Node.js / Python / Go
- Video: Daily or LiveKit Cloud
- Auth: Your existing auth system
- Notifications: FCM / APNs
- Webhooks: Provider events into your backend
When you might still need your own infrastructure
You may still choose self-hosting if you need:
- full control over media routing
- strict data residency with custom deployment
- lower costs at very high scale
- deep customization of SFU/MCU behavior
If you want, I can also give you:
- a provider comparison table, or
- a step-by-step integration plan for one provider (e.g. Daily, Twilio, Agora, or LiveKit Cloud).