Para apps

Una API WebSocket sin servidor que mantener

Una API de tiempo real sobre WebSockets alojados, para Next.js, Laravel, Django y cualquier otro stack. Tu servidor envía un evento en una petición corta y cada página de la sala lo recibe al instante. Nosotros mantenemos las conexiones abiertas, así que no hay ningún servidor WebSocket que ejecutar, escalar o reiniciar.

O prueba la demo en vivo: una tienda pequeña, donde un pedido pasa a enviado en otra ventana a medida que haces clic.

Los mejores precios para WebSockets. Desde $11.99 al mes por 1000 conexiones simultáneas, con facturación anual, o $14.99 con facturación mensual.

Tu servidor

Next.js en el servidor y React en la página.

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' } );
}
Tu app

Hooks y componentes para cualquier app de React, con cualquiera de los servidores de arriba.

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>;
}
Un pedido que pasa a Enviado, en la página de la tienda y en directo en la del cliente

Alojado

La parte que ya no tienes que mantener

Un servidor WebSocket funciona en tu portátil. En producción tiene que mantener cada conexión abierta durante horas, compartir cada evento entre máquinas y sobrevivir a tus despliegues, y un host serverless no puede mantener ninguna conexión. Aquí las conexiones se quedan con nosotros y tu servidor sigue como está.

Sin servidores de websockets que mantener

Tu propio servidor de websockets tiene que mantener cada conexión, crecer más allá de una máquina y seguir en pie durante los despliegues. La nube lo hace, sumando servidores a medida que crece tu tráfico, y una página pasa a otro servidor sin cortes.

Cualquier host para tu servidor

Tu servidor solo firma y envía, así que funciona en cualquier sitio, también en funciones serverless y edge, que por sí mismas no pueden mantener una conexión abierta.

Tu inicio de sesión sigue siendo tuyo

Un usuario es el id con el que tu app lo conoce, leído en tu propio servidor, así que tu sesión y tus cookies funcionan como ahora.

Tu servidor decide

Envía a quien quieras, mira quién está en línea y gestiona tus salas

Una sala es solo un nombre, como chat:7, sin nada que crear en la nube. Tu base de datos dice qué salas existen y quién está en ellas, una regla de tu servidor la lee y la nube obliga a cada página a respetar la respuesta. Aquí tienes un chat de equipo, de principio a fin.

Tu servidor

Next.js en el servidor y React en la página.

Crear una sala

Guárdala en tu base de datos y escribe una regla que la lea. La regla se ejecuta cuando alguien pide unirse: false lo deja fuera, true lo deja entrar y readOnly le permite leer pero no enviar nada. Aquí db es tu propia base de datos y me es la persona que ha iniciado sesión.

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' ] } );

El chat de equipo de aquí es el comienzo de uno: la API de chat añade el chat listo para usar, el historial, las marcas de lectura, los archivos y la moderación.

Salas en cada stack, con toda la configuración:

Por qué los WebSockets se complican en tu propio framework: Next.js, Laravel, Django y Flask, FastAPI.

¿Tienes un servidor WebSocket propio? Nuestra prueba de WebSocket lo comprueba desde tu navegador.

En cada conexión

Más que un socket

Un socket transporta bytes. Todo lo que una app construye a su alrededor, desde las reconexiones hasta quién está en línea, ya está hecho.

Los navegadores de Ann, Ben y Cara, cada uno con los tres en la tienda ahora, con sus roles

Nada se pierde al reconectar

Una sala puede guardar sus últimos eventos, y una página que vuelve recibe lo que se perdió, en orden, antes de lo que venga después.

Quién está en línea

Una sala puede mostrar quién está en ella, con lo que elijas mostrar de cada persona. Un contador dice cuántos están viendo una página, a cualquier escala, y quién está en línea se sabe en toda tu app.

Eventos desde la página

Las páginas envían a las salas en las que están, sin ninguna petición a tu servidor: mensajes de chat, escritura, un cursor. La regla dice qué eventos se pueden enviar y un webhook entrega a tu servidor los que debe guardar.

A una persona, en todas partes

Envía a un usuario y le llega en cada pestaña y dispositivo que tenga abierto, sin crear ninguna sala.

Cifrado, con claves que nunca tenemos

Los eventos, la presencia y el historial viajan sellados con claves que guarda tu servidor, y las llamadas entre dos personas están cifradas de extremo a extremo. La nube los transporta sin poder leerlos.

Una conexión para todas las pestañas

Las pestañas de un navegador comparten una sola conexión, así que una persona con tres pestañas abiertas cuenta una vez.

Casos de uso

Lo que se construye con WebSockets

Cada uno es una app completa en la documentación, con su servidor en Node.js, PHP y Python.

Actualizaciones en vivo y notificaciones

Un pedido que avanza en su página, un panel, el progreso de una tarea y un aviso a un usuario en todas sus pestañas y apps.

Chat

Conversaciones entre dos personas y en grupo, con indicador de escritura, confirmaciones de lectura y reacciones, guardadas en tu propia base de datos.

Quién está en línea y quién está aquí

Un punto en cada avatar, las personas de una sala con sus roles y cuántas miran una página.

Edición conjunta

Quién está en un documento, sus cursores y los cambios, enviados en binario y guardados para una reconexión.

Encuestas, cuestionarios y preguntas

Votos y preguntas que llegan solo a tu servidor, resultados enviados a todos y una puntuación para cada jugador.

Subastas en vivo

Pujas que tu servidor decide una a una, el nuevo precio para todos y un reloj que se alarga con una puja de última hora.

Precios

Precio por conexiones, nunca por mensajes

Desde $11.99 al mes por 1000 conexiones simultáneas, con facturación anual, o $14.99 con facturación mensual.

El precio depende de las conexiones simultáneas, a partir de 1000, con facturación mensual o anual. Los mensajes y el ancho de banda nunca se cobran, y lo que envía tu servidor no usa ninguna de tus conexiones.

El mismo plan y el mismo SDK incluyen videollamadas y retransmisión en vivo, sobre la misma conexión.

Dudas

Preguntas frecuentes

¿Necesito mi propio servidor WebSocket?

No. Los navegadores y las apps mantienen sus conexiones abiertas con nuestros servidores, y se inician más a medida que tu app crece. Tu servidor solo dice quién puede unirse a qué y envía cada evento en una petición HTTP corta.

¿Funciona en un alojamiento serverless?

Sí. Una función serverless no puede mantener una conexión abierta y aquí no hace falta: envía cada evento en una petición corta y las conexiones se quedan con nosotros. Las funciones edge y cualquier otro host funcionan igual.

¿Qué stacks pueden usar la API WebSocket?

Next.js y Express, Laravel y PHP puro, Django, FastAPI y Flask, Capacitor, iOS y Android, cada uno con su guía. Las apps de React Native y Flutter también tienen salas y presencia. Un servidor en cualquier otro lenguaje usa la API HTTP.

¿Tengo que escribir yo el código WebSocket?

No. El SDK abre la conexión, se reconecta por sí solo y vuelve a unirse a tus salas, y tú escuchas los eventos por su nombre. En Laravel es un driver de broadcasting, así que broadcast() y tu archivo de canales siguen igual.

¿Qué cuenta como conexión?

Un navegador o un dispositivo conectado a la nube en ese momento. Las pestañas de un navegador comparten una conexión cuando tu app sirve el worker del SDK, y lo que tu servidor envía por la API no cuenta.

¿Qué pasa al llegar a mi límite de conexiones?

Hasta un 20 % más siguen conectándose, y el titular de la cuenta recibe un correo al llegar al 80 % y al 100 %, a tiempo para pasar a un plan mayor.

¿Qué pasa cuando una página pierde la conexión?

Se reconecta por sí sola. Una sala que guarda historial le entrega lo que se perdió, en orden, hasta 5 minutos, y a una página que falta más tiempo se le avisa, para que pueda volver a leer de tu servidor. El historial es solo para reconexiones: tu propia base de datos guarda tus registros.

¿Quién decide quién entra en una sala?

Tu servidor, con una regla para cada tipo de sala: quién entra, qué puede enviar y quién solo lee. La nube hace cumplir cada respuesta, y tu servidor puede sacar a alguien de una sala en cualquier momento.

¿Podéis leer lo que envía mi app?

No en una sala privada o de presencia. Sus eventos, su historial y quién está en ella viajan sellados con claves que crea tu servidor, y la nube los transporta sin poder leerlos. Una sala pública, a la que puede unirse cualquiera, va sin cifrar.

¿Dónde están vuestros servidores?

Los servidores de tiempo real que transportan tus eventos están en Alemania. Los relés y servidores de medios para las llamadas están en más países.

¿Preguntas sobre tu integración? Escríbenos: te ayudamos con los SDK, la pantalla de llamada y tu stack.