Hi @steel heart. I'm kapa.ai, your friendly support bot. I will try to answer your question by searching through the knowledge base. :wave:
#WebRTC signaling server
mental widgetBOT
Yes, it is possible to use Convex as a signaling server for WebRTC. Convex provides real-time data synchronization and reactivity via WebSockets, which are essential for exchanging signaling messages (like SDP offers/answers and ICE candidates) between peers during the WebRTC connection setup.
There is community discussion confirming that people have built audio and video call apps using Convex as the backend, and there is even mention of working examples and plans for npm packages to facilitate this use case. While there isn’t an official, detailed guide or example in the knowledge sources, the community feedback suggests that Convex can handle the signaling aspect for WebRTC apps, especially when paired with a frontend like Next.js hosted on Vercel. However, you may need to implement the signaling logic yourself using Convex’s real-time queries and mutations to relay messages between clientsWebRTC with convex? (Discord).
Regarding overhead, Convex is designed for real-time collaboration and can handle a few thousand concurrent sessions without much issue, even on the free or self-hosted tiers, as long as your server has sufficient resources (e.g., a couple of GB of RAM)Number of concurrent client subscriptions (Discord). The main consideration is that Convex is optimized for real-time data sync and not for high-throughput, low-latency message relaying at the scale of a dedicated signaling server, but for most typical WebRTC use cases (such as video calls in web apps), it should be sufficient.
In summary: Yes, you can set up a WebRTC signaling server on Convex, and the platform is suitable for this use case for most web applications. If you expect extremely high signaling message throughput or need ultra-low latency, you may want to benchmark Convex for your specific needs.
Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:
steel heart
@mental widget what about for video calls
mental widgetBOT
Let me check the knowledge base for you again. One moment! :books:
Convex can be used as the signaling server for setting up video calls (e.g., exchanging SDP offers/answers and ICE candidates) in a WebRTC-based application. There is confirmation from the Convex community that people have built audio and video call apps using Convex as the backend, including with a Next.js frontend hosted on Vercel. However, there are no official guides or detailed performance benchmarks in the knowledge sources regarding large-scale or production-grade video call signaling with Convex.
For the actual media (video/audio) streaming, Convex is not involved—WebRTC handles peer-to-peer media transfer directly between clients. Convex’s role is limited to the signaling phase, which it is capable of supporting for typical web app use cases. If you expect a very high volume of concurrent calls or need extremely low signaling latency, you may want to test Convex for your specific requirements, as the knowledge sources do not provide detailed performance data for this scenarioWebRTC with convex? (Discord).
In summary: Convex is suitable for handling the signaling part of video calls in WebRTC applications, but you should evaluate its performance for your scale if you have demanding requirements.
Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:
steel heart
@mental widget How about for 1:1 video calls
mental widgetBOT
Let me check the knowledge base for you again. One moment! :books:
For 1:1 video calls, using Convex as a signaling server is a reasonable and supported use case. The knowledge sources include community discussions where developers have built audio and video call apps with Convex as the backend, specifically mentioning setups with Next.js frontends. While there are no official guides or detailed performance metrics, there is no indication of technical barriers for 1:1 video call signaling using Convex. The actual media stream (video/audio) is handled peer-to-peer by WebRTC, so Convex’s role is limited to exchanging signaling messages, which it is well-suited for in typical web app scenariosWebRTC with convex? (Discord).
If your use case is standard 1:1 video calls, Convex should be sufficient for the signaling phase. If you plan to scale beyond that or have very high performance requirements, you may want to test and monitor your specific implementation.
Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:
steel heart
@mental widget Help you help me set up a concept for 1:1 signaling using convex
mental widgetBOT
Let me check the knowledge base for you again. One moment! :books:
Certainly! Here’s a conceptual outline for setting up 1:1 WebRTC signaling using Convex, based on the available knowledge sources:
1. Use Convex for Signaling Data Exchange
Convex can act as the intermediary for exchanging signaling messages (SDP offers/answers, ICE candidates) between two users. You would use Convex mutations to send signaling data and queries (with reactivity) to receive updates in real time.
2. Basic Data Model
You might create a Convex table (e.g., signals) to store signaling messages. Each message could include:
- A unique call/session ID
- Sender and receiver user IDs
- Message type (offer, answer, candidate)
- The signaling payload (SDP or ICE data)
- Timestamp
3. Example Convex Functions
While the knowledge sources do not provide a full code example, they do show how to set up queries and mutations for real-time data exchange. For instance, you could have:
// convex/signaling.ts
import { query, mutation } from "./_generated/server";
// List all signaling messages for a session
export const list = query(async (ctx, { sessionId }) => {
return await ctx.db
.query("signals")
.withIndex("by_session", (q) => q.eq("sessionId", sessionId))
.collect();
});
// Send a signaling message
export const send = mutation(async (ctx, { sessionId, from, to, type, payload }) => {
await ctx.db.insert("signals", {
sessionId,
from,
to,
type,
payload,
timestamp: Date.now(),
});
});
(This code structure is based on the messaging example in the knowledge sources, adapted for signaling data.)
See the messaging example for reference.
4. Frontend Integration
- Use a reactive query (e.g.,
useQuery(api.signaling.list, { sessionId })) to subscribe to new signaling messages for the session. - Use a mutation (e.g.,
useMutation(api.signaling.send)) to send signaling messages to the other peer.
5. Real-Time Updates
Convex’s reactivity ensures that when one user sends a signaling message, the other user’s client will receive it in real time without polling, thanks to Convex’s built-in WebSocket reactivity and cache invalidationHow Convex makes it easy.