Voor apps

Een WebSocket-API zonder server om te draaien

Een realtime API op gehoste WebSockets, voor Next.js, Laravel, Django en elke andere stack. Je server stuurt een gebeurtenis in één kort verzoek en elke pagina in de ruimte krijgt hem meteen. Wij houden de verbindingen open, dus je hoeft geen WebSocket-server te draaien, op te schalen of te herstarten.

Of probeer de livedemo: een kleine winkel, waar een bestelling in een ander venster op verzonden springt terwijl je klikt.

De beste prijzen voor WebSockets. Vanaf $11.99 per maand voor 1.000 gelijktijdige verbindingen, jaarlijks gefactureerd, of $14.99 maandelijks gefactureerd.

Je server

Next.js op de server en React op de pagina.

app/orders/actions.ts
'use server';

import { realtime } from '@/lib/realtime';

export async function markShipped( id: string ) {
    await saveStatus( id, 'shipped' );
    await realtime.to( `order:${ id }` )
        .emit( 'updated', { status: 'shipped' } );
}
Je app

Hooks en componenten voor elke React-app, op elk van de servers hierboven.

components/Status.jsx
'use client';   // in Next.js

import { useState } from 'react';
import { useRoom } from '@wordplus/realtime/react';

// Inside <RealtimeProvider>, once for the whole app.
export function Status( { id, initial } ) {
    const [ status, setStatus ] = useState( initial );
    useRoom( `order:${ id }`, {
        updated: ( data ) => setStatus( data.status ),
    } );
    return <p>{ status }</p>;
}
Een bestelling die naar Verzonden gaat, op de winkelpagina en live op de pagina van de klant

Gehost

Het deel dat je niet meer draait

Een WebSocket-server werkt op je laptop. In productie moet hij elke verbinding uren openhouden, elke gebeurtenis tussen machines delen en je deploys overleven, en een serverless host kan helemaal geen verbinding vasthouden. Hier blijven de verbindingen bij ons en blijft je server zoals hij is.

Geen websocketservers te onderhouden

Je eigen websocketserver moet elke verbinding vasthouden, groeien voorbij één machine en blijven draaien tijdens deploys. De cloud doet dat, met extra servers als je verkeer groeit, en een pagina gaat zonder onderbreking naar een andere server.

Elke host voor je server

Je server ondertekent en stuurt alleen, dus hij draait overal, ook serverless en edge-functies, die zelf geen verbinding open kunnen houden.

Je inlog blijft van jou

Een gebruiker is het id waaronder je app hem kent, gelezen op je eigen server, zodat je sessie en cookies blijven werken zoals nu.

Je server beslist

Stuur naar wie je wilt, zie wie er online is en beheer je ruimtes

Een ruimte is alleen een naam, zoals chat:7, zonder iets aan te maken in de cloud. Je database bepaalt welke ruimtes er zijn en wie erin zit, één regel op je server leest dat, en de cloud houdt elke pagina aan het antwoord. Hier is een teamchat, van begin tot eind.

Je server

Next.js op de server en React op de pagina.

Een ruimte maken

Sla hem op in je database en schrijf één regel die hem leest. De regel draait wanneer iemand wil meedoen: false houdt diegene buiten, true laat hem binnen en readOnly laat hem alleen lezen en niets sturen. Hier is db je eigen database en me de ingelogde persoon.

app/rooms/actions.ts
// A room is a row of yours. Nothing is created in the cloud.
const room = await db.room.create( { data: { name: 'Team' } } );

await db.member.create( { data: { roomId: room.id, userId: me, role: 'member' } } );

// Its name is yours to choose: row 7 is the room chat:7.
lib/realtime.ts
// Once, for every chat. When someone asks to join chat:7, id is '7'.
realtime.room( 'chat:{id}', async ( user, { id } ) => {
    const room = await db.room.findUnique( { where: { id: Number( id ) } } );
    if ( !room || room.closed ) return false;       // no such room, or closed

    const member = await db.member.findFirst( { where: { roomId: room.id, userId: user } } );
    if ( !member || member.banned ) return false;   // not a member, or banned

    return member.role === 'reader' ? { readOnly: true } : true;
}, { presence: true, emit: [ 'message' ] } );

De teamchat hier is het begin van een chat: de chat-API voegt de kant-en-klare chat, de geschiedenis, leesvinkjes, bestanden en moderatie toe.

Ruimtes in elke stack, met de hele opzet:

Waarom websockets lastig worden in je eigen framework: Next.js, Laravel, Django en Flask, FastAPI.

Draai je een eigen WebSocket-server? Onze WebSocket-test controleert hem vanuit je browser.

Op elke verbinding

Meer dan een socket

Een socket draagt bytes. Alles wat een app eromheen bouwt, van herverbindingen tot wie er online is, is er al.

De browsers van Ann, Ben en Cara, die elk alle drie in de winkel tonen, met hun rollen

Niets kwijt bij herverbinden

Een ruimte kan haar laatste gebeurtenissen bewaren, en een pagina die terugkomt krijgt wat ze miste, op volgorde, vóór wat daarna komt.

Wie er online is

Een ruimte kan tonen wie erin zit, met wat je van elke persoon wilt laten zien. Een teller zegt hoeveel mensen een pagina bekijken, op elke schaal, en wie er online is, is in je hele app bekend.

Gebeurtenissen vanaf de pagina

Pagina's sturen naar de ruimtes waarin ze zitten, zonder verzoek aan je server: chatberichten, typen, een cursor. De regel bepaalt welke gebeurtenissen mogen worden gestuurd, en een webhook geeft je server de gebeurtenissen die ze moet bewaren.

Naar één persoon, overal

Stuur naar een gebruiker en het bereikt elk tabblad en elk apparaat dat open staat, zonder ruimte in te richten.

Versleuteld, met sleutels die wij nooit hebben

Gebeurtenissen, aanwezigheid en geschiedenis reizen verzegeld met sleutels die je server heeft, en bel- en videogesprekken tussen twee mensen zijn end-to-end versleuteld. De cloud vervoert ze zonder ze te kunnen lezen.

Eén verbinding voor elk tabblad

De tabbladen van een browser delen één verbinding, dus iemand met drie tabbladen open telt één keer.

Toepassingen

Wat mensen bouwen op WebSockets

Elk is een complete app in de documentatie, met de server in Node.js, PHP en Python.

Live updates en meldingen

Een bestelling die op haar pagina verder gaat, een dashboard, de voortgang van een taak en een melding aan één gebruiker in elk tabblad en elke app.

Chat

Gesprekken tussen twee personen en in groepen, met typindicatie, leesvinkjes en reacties, bewaard in je eigen database.

Wie online is en wie er is

Een stip op elke avatar, de mensen in een ruimte met hun rollen en hoeveel er naar een pagina kijken.

Samen bewerken

Wie er in een document zit, hun cursors en de wijzigingen, binair verstuurd en bewaard voor een herverbinding.

Polls, quizzen en vragen

Stemmen en vragen die alleen je server bereiken, uitslagen die naar iedereen gaan en een score per speler.

Live veilingen

Biedingen die je server een voor een beoordeelt, de nieuwe prijs naar iedereen en een klok die opschuift bij een late bieding.

Prijzen

Geprijsd op verbindingen, nooit op berichten

Vanaf $11.99 per maand voor 1.000 gelijktijdige verbindingen, jaarlijks gefactureerd, of $14.99 maandelijks gefactureerd.

Geprijsd op gelijktijdige verbindingen, vanaf 1.000, maandelijks of jaarlijks gefactureerd. Berichten en bandbreedte worden nooit in rekening gebracht, en wat je server stuurt gebruikt geen van je verbindingen.

Hetzelfde abonnement en dezelfde SDK brengen videogesprekken en livestreaming, op dezelfde verbinding.

Vragen

Veelgestelde vragen

Heb ik een eigen WebSocket-server nodig?

Nee. Browsers en apps houden hun verbindingen open naar onze servers, en er komen er meer bij naarmate je app groeit. Je server bepaalt alleen wie waaraan mag meedoen en stuurt elke gebeurtenis in één kort HTTP-verzoek.

Werkt het op serverless hosting?

Ja. Een serverless functie kan geen verbinding openhouden, en hier hoeft dat ook niet: ze stuurt elke gebeurtenis in één kort verzoek en de verbindingen blijven bij ons. Edge-functies en elke andere host werken op dezelfde manier.

Welke stacks kunnen de WebSocket-API gebruiken?

Next.js en Express, Laravel en gewone PHP, Django, FastAPI en Flask, Capacitor, iOS en Android, elk met een handleiding. React Native- en Flutter-apps hebben ook ruimtes en aanwezigheid. Een server in een andere taal gebruikt de HTTP-API.

Schrijf ik de WebSocket-code zelf?

Nee. De SDK opent de verbinding, verbindt zelf opnieuw en doet weer mee met je ruimtes, en jij luistert naar gebeurtenissen op naam. In Laravel is het een broadcasting-driver, dus broadcast() en je kanalenbestand blijven zoals ze zijn.

Wat telt als een verbinding?

Een browser of een apparaat dat op dat moment met de cloud verbonden is. De tabbladen van één browser delen een verbinding als je app de SDK-worker serveert, en wat je server via de API verstuurt, telt niet mee.

Wat gebeurt er bij mijn verbindingslimiet?

Tot 20% meer maakt nog steeds verbinding, en de accounteigenaar krijgt een e-mail bij 80% en bij 100%, op tijd om over te stappen op een groter abonnement.

Wat gebeurt er als een pagina haar verbinding verliest?

Ze verbindt vanzelf opnieuw. Een ruimte die geschiedenis bewaart geeft haar wat ze miste, op volgorde, tot 5 minuten lang, en een pagina die langer weg was krijgt dat te horen, zodat ze je server opnieuw kan lezen. Geschiedenis is er alleen voor herverbindingen: je eigen database bewaart je gegevens.

Wie bepaalt wie een ruimte betreedt?

Je server, met een regel voor elk soort ruimte: wie meedoet, wat diegene mag sturen en wie alleen leest. De cloud dwingt elk antwoord af, en je server kan op elk moment iemand uit een ruimte halen.

Kunnen jullie lezen wat mijn app stuurt?

Niet in een privé- of presence-ruimte. De gebeurtenissen, de geschiedenis en wie erin zit reizen verzegeld met sleutels die je server maakt, en de cloud vervoert ze zonder ze te kunnen lezen. Een openbare ruimte, waaraan iedereen mag meedoen, gaat onversleuteld.

Waar staan jullie servers?

De realtime servers die je gebeurtenissen vervoeren draaien in Duitsland. De relays en mediaservers voor gesprekken draaien in meer landen.

Vragen over je integratie? Schrijf ons: we helpen met de SDK’s, het belscherm en je stack.