Blog

Een API voor videogesprekken kiezen: wat je vergelijkt voordat je bouwt

· Andrij Tkachenko · 13 min leestijd

Een vergrootglas boven het venster van een videogesprek met twee mensen erin, tussen een wereldbol met lijnen die punten erop verbinden en een hangslot

Kies een API voor videogesprekken op wat die doet met de moeilijke gesprekken en op wat die telt: of een gesprek tot stand komt door een strenge firewall, hoe dicht de servers bij je gebruikers staan, wie de media kan zien, en of de rekening groeit met minuten, mensen of resolutie. HD-video, scherm delen en een belscherm staan op elke functielijst, dus het zijn die antwoorden die diensten van elkaar onderscheiden.

Dit artikel loopt tien vragen door die je aan elke API voor videogesprekken, SDK voor videogesprekken of API voor videovergaderingen stelt, met waarom elke vraag ertoe doet en hoe je het antwoord zelf controleert. Het noemt geen enkele dienst. Aan het eind beantwoordt het elke vraag voor WordPlus Cloud, met wat het aan jou overlaat.

Een vergadering die je insluit, of gesprekken in je eigen app

Onder deze woorden worden twee verschillende soorten diensten verkocht.

Een vergaderdienst geeft je een ruimte op een eigen pagina, die mensen openen via een link of die je in een frame op je site zet. Een API voor gesprekken geeft je de onderdelen: een SDK voor elk platform, vaak met een kant-en-klaar belscherm, en de gesprekken vinden plaats in je eigen app, tussen je eigen gebruikers.

Ingesloten vergadering API en SDK voor gesprekken
Het gesprek loopt Op de pagina van de dienst, in een frame In je eigen schermen
Wie mag deelnemen Wie de link heeft Wie je server toelaat
Je schrijft Een link Een route voor tokens en een scherm

Er is een derde weg, opensource-mediaservers op eigen servers, en daarbij moet je het meeste zelf draaien. Hoe groepsvideogesprekken werken laat zien wat dat vraagt. De tien vragen hieronder gaan over de eerste twee.

1. Komt elk gesprek tot stand?

Een videogesprek gaat rechtstreeks tussen de twee apparaten als hun netwerken dat toelaten, en veel netwerken doen dat niet. Thuisrouters, mobiele netwerken en kantoorfirewalls verbergen elk op hun eigen manier de apparaten erachter, dus een deel van de gesprekken komt alleen tot stand via een relay, een TURN-server, die beide kanten kunnen bereiken. Ons artikel over STUN- en TURN-servers legt uit waarom.

Waar die relay luistert, doet er net zoveel toe. TURN gebruikt standaard poort 3478, en 5349 via TLS, en de standaard ervan laat het ook via TCP lopen, omdat sommige firewalls UDP helemaal blokkeren. Een hotel- of kantoornetwerk dat alleen de poorten van het web naar buiten laat, blokkeert die allemaal, dus dan komt alleen een relay op poort 443 erdoor.

Vraag na:

  • Zijn relays inbegrepen, en op welke poorten, 443 daaronder?
  • Wat gebeurt er als zelfs een relay er niet doorkomt: mislukt het gesprek, of gaat het naar een server die er wel doorkomt?
  • Als een telefoon van wifi naar mobiele data overstapt, gaat het gesprek dan door, of wordt er opgehangen?

Komt een gesprek niet tot stand, dan laat ons artikel over mislukte WebRTC-verbindingen zien hoe je uitzoekt waarom.

2. Hoe dicht staan de servers bij je gebruikers?

Elke relay en mediaserver voegt de reis ernaartoe en terug toe. De aanbeveling van de ITU over vertraging in gesprekken, G.114, merkt op dat de meeste toepassingen er weinig last van hebben zolang de vertraging in één richting onder 150 ms blijft. Twee mensen in dezelfde stad die via een server op een ander continent praten, horen elkaar laat, ook al wonen ze een paar straten van elkaar.

Vraag na:

  • Waar staan de relays en mediaservers, en bereikt iedereen vanzelf de dichtstbijzijnde?
  • Gaat in een groepsgesprek met mensen op twee continenten iedereen naar één server, of maakt ieder verbinding met een server in de buurt?

Hoe je gebruikers in verschillende regio’s verbindt loopt na wat elk antwoord betekent voor een gesprek.

3. Werken een gesprek met twee en een groepsgesprek hetzelfde?

Een gesprek tussen twee mensen kan rechtstreeks tussen de apparaten gaan. Een groepsgesprek kan dat niet meer zodra er meer dan een handvol mensen in zitten, want elk apparaat zou dan zijn camerabeeld naar elk ander moeten sturen. Daarom draaien groepsgesprekken op mediaservers die elk camerabeeld één keer ontvangen en naar de rest doorsturen, en veel diensten verkopen ze als een tweede product, met een eigen SDK en een eigen prijs.

Vraag na:

  • Als een derde persoon bij een gesprek met twee komt, moeten die twee dan ophangen en opnieuw beginnen?
  • Hoeveel mensen mogen er tegelijk met video zijn, en hoeveel in één gesprek?
  • Kunnen sommige mensen alleen luisteren, en spreken zodra een host dat toestaat?

4. Wat telt de rekening?

De meeste API’s voor videogesprekken tellen deelnemersminuten, een minuut van één persoon in een gesprek. Een les met 30 mensen van een uur is er 1.800, dus de omvang van je gesprekken doet er meer toe dan hoeveel het er zijn. Wat videogesprekken per minuut kosten rekent een hele maand door.

Kijk daarna wat er nog meer wordt geteld. Sommige prijzen stijgen met de resolutie, sommige tellen de minuten via een relay apart, en opnames, bandbreedte en gesprekken tussen twee mensen kunnen elk apart op de rekening staan.

Vraag na:

  • Telt een minuut in HD net als een minuut met audio?
  • Worden gesprekken tussen twee mensen geteld, en die via een relay?
  • Wat gebeurt er boven het abonnement: wordt een gesprek afgebroken, of wordt het extra gebruik gefactureerd?

5. Wie kan het gesprek zien en horen?

Elk WebRTC-gesprek is onderweg versleuteld. De beveiligingsarchitectuur van WebRTC eist dat: alle media worden beveiligd met SRTP, met sleutels die via DTLS worden afgesproken. Dat houdt iedereen buiten die op het netwerk tussen de twee uiteinden zit. De vraag is waar de uiteinden zijn. In een gesprek rechtstreeks tussen twee apparaten zijn dat de apparaten. In een gesprek via een mediaserver is de server een van de uiteinden, en die kan elk frame zien.

Een groepsgesprek blijft alleen verborgen voor zijn mediaservers als elk frame wordt versleuteld voordat het het apparaat verlaat, met sleutels die de servers nooit hebben. SFrame is de IETF-standaard daarvoor, en sommige diensten doen hetzelfde op hun eigen manier.

Vraag na:

  • Wie heeft de sleutels van een groepsgesprek: de dienst, mijn server, of alleen de mensen die erin zitten?
  • Is een gesprek dat uitwijkt naar een relay of een mediaserver nog steeds end-to-end versleuteld?
  • Moet de dienst de media kunnen zien om een gesprek op te nemen?

6. Wie bepaalt wie mag bellen en deelnemen?

Een gesprek hoort alleen te beginnen waar je app ja zegt. Bij de meeste API’s ondertekent je server een token voor elk gesprek of elke ruimte, en het verschil zit in hoeveel het token zegt. Een token dat een gebruiker alleen binnenlaat, laat de rollen over aan de instellingen van de dienst. Een token dat zegt wie spreekt, wie alleen luistert en wie host is, houdt die beslissingen in je eigen code.

Vraag na:

  • Kan een token dat aan de ene persoon is gegeven, door een ander worden gebruikt, of voor een ander gesprek?
  • Kan mijn server iemand dempen, eruit halen of een gesprek beëindigen zonder dat er een pagina open is?
  • Kan een host hetzelfde doen vanuit het belscherm, en alleen een host?

7. Hoe bereikt een gesprek wie gebeld wordt?

Een gesprek dat overgaat in een tabblad waar niemand naar kijkt, is een gemist gesprek. Vraag na waar het overgaat: in elk tabblad dat de persoon open heeft, op de telefoon, en op een telefoon waarop de app dicht is. Bij een gesloten app gaat een gesprek alleen over via de systeemoproepen van de telefoon, CallKit op iOS en het Telecom-framework op Android, en de SDK moet die ondersteunen.

Vraag na:

  • Gaat een gesprek op elk apparaat tegelijk over, en houdt het overal op met overgaan zodra het op één ervan is opgenomen?
  • Gaat het over op een vergrendelde telefoon, en komt het in de lijst met recente oproepen?
  • Hoe lang gaat het over, en wat hoort elke kant als niemand opneemt?

8. Is er een kant-en-klaar belscherm, en kun je het aanpassen?

Een belscherm is meer werk dan het lijkt: het overgaan, de keuze van camera en microfoon, het raster dat zich herschikt, wie er spreekt, het gedeelde scherm, en geluid dat een browser stil houdt tot iemand klikt. Een kant-en-klaar belscherm bespaart weken. Het moet er ook uitzien als de rest van je app.

Vraag na:

  • Welke platforms hebben er een: het web, React, iOS, Android?
  • Kan ik de kleuren en teksten aanpassen, en één onderdeel ervan vervangen door een eigen?
  • Is de rest van de SDK er voor een eigen scherm, tot op elke persoon in een groepsgesprek?
  • Is er een serverbibliotheek in de taal waarin ik schrijf, of een HTTP-API?

9. Wat gebeurt er op een zwak netwerk?

Gesprekken gaan op kleine manieren mis, lang voordat ze mislukken. Elke browser moet VP8 en H.264 aankunnen, zoals RFC 7742 eist, en wat een gesprek doet op een slechte verbinding, bepaalt de dienst: de beeldkwaliteit verlagen, een andere codec kiezen, geluidspakketten twee keer versturen, of de camera opgeven om de stem te houden.

Vraag na:

  • Wijkt op een zwakke verbinding het beeld eerder dan het geluid?
  • Hoort mijn scherm hoe goed elke verbinding is, zodat het de persoon dat kan laten weten?
  • Als een verbinding even wegvalt, hoe lang wacht het gesprek er dan op?

Een telefoon met één streepje mobiele data beantwoordt deze vragen beter dan welke pagina met specificaties ook.

10. Wat hoort je server terug, en wat zijn de limieten?

Je app moet weten wat er gebeurd is: wie wie belde, hoe lang ze praatten en waarom een gesprek eindigde. Dat is nodig om een lijst met recente gesprekken te tonen, een bericht aan te bieden als niemand opnam, of je eigen gebruikers per minuut te factureren. Webhooks brengen het, en omdat een webhook twee keer kan komen, heeft elk een id nodig.

Lees dan de pagina met limieten: hoe lang een gesprek mag overgaan en duren, hoeveel mensen erin mogen, en hoe lang een token geldig is. En stel je de dag voor waarop je vertrekt. Een gesprek laat minder achter dan een chat. Wat blijft, is wat je van elk gesprek hebt vastgelegd, en dat hoort in je eigen database.

Test het een middag lang

Een prijslijst en een functietabel beantwoorden er maar weinig van. Een kleine test beantwoordt de meeste. Bouw op elke dienst die je overweegt het kleinste gesprek dat je kunt maken, en doorloop deze zeven stappen:

  1. Bel tussen twee browsers op verschillende netwerken, de ene op wifi en de andere op een telefoon met mobiele data.
  2. Bel vanaf een netwerk dat alleen het web naar buiten laat, zoals de strenge wifi van een kantoor of hotel. Onze WebRTC-test laat vooraf zien wat dat netwerk doorlaat.
  3. Zet tijdens een gesprek één telefoon over van wifi naar mobiele data. Kijk of het gesprek doorgaat.
  4. Voeg een derde persoon toe aan een gesprek met twee. Kijk of de twee eerst moeten ophangen.
  5. Open de app als wie gebeld wordt in twee tabbladen en op een telefoon waarop de app dicht is, en bel die persoon. Kijk waar het overgaat, en of de rest ophoudt zodra er op één wordt opgenomen.
  6. Probeer vanuit de console van de browser deel te nemen met een token dat je server aan iemand anders gaf, of voor een ander gesprek.
  7. Open de pagina met het gebruik bij de dienst, en lees wat er voor deze middag is geteld.

Hoe WordPlus Cloud ze beantwoordt

WordPlus Cloud is van de tweede soort: een API voor gesprekken, met SDK’s en een kant-en-klaar belscherm, op relays en mediaservers die we zelf draaien. Dezelfde tien vragen, op volgorde:

  1. Gesprekken tussen twee mensen komen tot stand via drie wegen, die om de beurt worden geprobeerd: rechtstreeks tussen de twee apparaten, via onze relays op 443 en 80, de poorten van het web, en via onze mediaservers als zelfs de relays er niet doorkomen. Een gesprek wisselt vanzelf van de ene weg naar de andere, zonder op te hangen.
  2. Onze relays en mediaservers draaien in meerdere regio’s, en elk apparaat bereikt vanzelf de dichtstbijzijnde. In een groepsgesprek maakt iedereen verbinding met een server in de eigen regio, en onze servers geven elke track over privéverbindingen tussen regio’s door. De netwerkpagina toont ze op een kaart.
  3. Een gesprek met twee wordt een groepsgesprek als een van beide kanten iemand toevoegt, zonder dat iemand ophangt. Groepsgesprekken draaien op onze mediaservers, zonder limiet op het aantal mensen in een gesprek, en je server zegt wie spreekt, wie alleen luistert en wie host is.
  4. De rekening telt gelijktijdige verbindingen, vanaf 1.000: $11.99 per maand, jaarlijks gefactureerd, of $14.99 maandelijks gefactureerd. Gesprekken tussen twee mensen zijn op elke weg inbegrepen, via een relay of niet. Met 1.000 verbindingen kosten groepsgesprekken geen credits tot 32 mensen met video tegelijk, waarbij iemand met audio half telt, en elke 1.000 verbindingen extra voegen er 12 toe. Daarboven kosten ze $0.20 per 1.000 minuten van een persoon met video, $0.10 met audio, en je abonnement voegt 5.000 credits per maand toe voor elke 1.000 verbindingen. Eén prijs bij elke resolutie, en bandbreedte en relays worden nooit in rekening gebracht.
  5. Gesprekken tussen twee mensen zijn op elke weg end-to-end versleuteld, ook via onze relays en mediaservers. Een groepsgesprek is end-to-end versleuteld wanneer je server dat zegt: elk frame wordt versleuteld voordat het het apparaat verlaat, met een sleutel die alleen je server uitgeeft, en onze mediaservers sturen door wat ze niet kunnen lezen.
  6. Je server bepaalt. Die geeft de pagina een token voor elk gesprek dat hij toestaat, en voor elke persoon die aan een groepsgesprek deelneemt, met daarin wie spreekt, wie alleen luistert en wie host is. Hosts zetten een microfoon uit, laten iemand spreken en verwijderen iemand, en je server kan hetzelfde doen zonder dat er een pagina open is, en op elk moment de toegang weer intrekken.
  7. Een gesprek gaat over in elk tabblad en elke app die wie gebeld wordt open heeft, 45 seconden lang, en houdt overal op met overgaan zodra die persoon op één ervan opneemt. De SDK’s voor iOS en Android laten een vergrendelde telefoon en een gesloten app overgaan als een telefoongesprek, via CallKit en de oproepmeldingen van Android. Elk gesprek zegt waarom het eindigde, ook als niemand opnam.
  8. Een kant-en-klaar belscherm op het web, iOS en Android: belknoppen, het overgaan en het gespreksvenster, in negen talen. Pas de kleuren en teksten aan, vervang een onderdeel ervan door een eigen, of teken je eigen interface op dezelfde SDK. Serverbibliotheken voor Node.js, PHP en Python, handleidingen voor Next.js, Express, Laravel, gewoon PHP, Django, FastAPI en Flask, en een HTTP-API voor elke andere taal.
  9. In een gesprek tussen twee mensen wordt de verbinding van de andere kant gemeld als uitstekend, goed, slecht of verbroken, met de weg die het gesprek nam, zodat je scherm dat kan laten zien. Een gesprek kiest vanzelf een andere weg als een netwerk verandert, en de verbinding van één kant mag tot 45 seconden wegvallen en terugkomen.
  10. Je server hoort elk gesprek via een webhook: wie wie belde, wanneer er werd opgenomen, hoeveel seconden ze praatten en waarom het eindigde, en wanneer elke persoon aan een groepsgesprek deelnam en het verliet, geteld op onze servers. Een gesprek houdt zijn id, hoe vaak de webhook ervan ook wordt verstuurd, dus een herhaling wordt één keer bewaard. De limieten zijn openbaar: een gesprek gaat 45 seconden over, een token voor een gesprek is tot 6 uur geldig, en een kant waarvan de verbinding wegvalt, heeft 45 seconden om terug te komen.

De handleiding voor gesprekken heeft de code van elk onderdeel in elke stack. Videogesprekken in Next.js bouwt stap voor stap een hele app, en in de live demo open je die in twee browsers en bel je van de ene naar de andere.

Wat het aan jou overlaat

  • Een route die de tokens uitgeeft. Wie wie mag bellen, is je eigen logica, dus het is code die je zelf schrijft, en dat geldt ook voor wat je webhook van elk gesprek vastlegt.
  • Iemand laten weten dat die een gesprek heeft gemist. Een gesprek gaat 45 seconden over, overal waar de persoon een pagina of een app open heeft. Daarna hoort je server dat niemand opnam, en de e-mail of het bericht verstuur je zelf.
  • Opnemen. De SDK’s voor apps nemen vandaag geen gesprekken op.
  • Telefoonnummers. Gesprekken zijn tussen de gebruikers van je app, via internet, zonder telefoonnummers en zonder telefoonnet.

Wil je een vergadering waar iedereen via een link aan deelneemt, zonder app van jezelf eromheen, dan past een vergaderdienst die je insluit beter bij je. Dat geldt ook als je gesprekken telefoonnummers moeten bereiken.

Begin met de handleiding voor gesprekken

WordPlus Cloud for Apps is geprijsd op gelijktijdige verbindingen, vanaf 1.000, maandelijks of jaarlijks gefactureerd. Gesprekken tussen twee mensen zijn inbegrepen, en hetzelfde abonnement en dezelfde SDK brengen groepsgesprekken, livestreaming en chat op dezelfde verbinding. Bekijk de API en SDK voor videogesprekken met elke taak in elke stack, wat de cloud doet voor apps, of de prijzen voor apps. Zoek je ook iets voor chat? Een chat-API kiezen stelt dezelfde vragen over berichten. Stream je ook naar een publiek? Een API voor livestreaming kiezen stelt dezelfde vragen over een stream. Vragen over je integratie? Schrijf ons.