Migrate from LiveKit

import { AccessToken } from 'livekit-server-sdk';
 
const at = new AccessToken(process.env.LIVEKIT_API_KEY, process.env.LIVEKIT_API_SECRET, {
  identity: user.id,
  ttl: '10m',
});
at.addGrant({ roomJoin: true, room: roomName, canPublish: true, canSubscribe: true, canPublishData: true });
res.json({ token: await at.toJwt(), url: process.env.LIVEKIT_URL });

from livekit import api
 
token = (
    api.AccessToken(os.environ["LIVEKIT_API_KEY"], os.environ["LIVEKIT_API_SECRET"])
    .with_identity(user_id)
    .with_grants(api.VideoGrants(room_join=True, room=room_name))
    .to_jwt()
)

at := auth.NewAccessToken(os.Getenv("LIVEKIT_API_KEY"), os.Getenv("LIVEKIT_API_SECRET"))
at.SetVideoGrant(&auth.VideoGrant{RoomJoin: true, Room: roomName}).
	SetIdentity(userID).
	SetValidFor(time.Hour)
token, err := at.ToJWT()

import { Livqeno } from '@livqeno/server';
 
const livqeno = new Livqeno({ apiKey: process.env.LIVQENO_API_KEY, baseUrl: process.env.LIVQENO_API_URL });
 
const room = await livqeno.rooms.create({ name: roomName, getOrCreate: true });
 
const grant = await livqeno.tokens.create({
  room: room.id, // the id, not the name
  identity: user.id,
  permissions: { join: true, subscribe: true, publish: true, publishData: true },
  expiresIn: 600,
});
res.json(grant); // token, endpoint and iceServers: no separate URL to send

import os
from livqeno import Livqeno, CreateTokenParams, TokenPermissions
 
livqeno = Livqeno(api_key=os.environ["LIVQENO_API_KEY"], base_url=os.environ["LIVQENO_API_URL"])
 
room = livqeno.rooms.create(room_name, get_or_create=True)
grant = livqeno.tokens.create(
    CreateTokenParams(
        room=room["id"],
        identity=user_id,
        permissions=TokenPermissions(join=True, subscribe=True, publish=True, publish_data=True),
        expires_in=600,
    )
)

client := livqeno.New(os.Getenv("LIVQENO_API_KEY"), livqeno.WithBaseURL(os.Getenv("LIVQENO_API_URL")))
 
room, err := client.Rooms.Create(ctx, livqeno.CreateRoomParams{Name: roomName, GetOrCreate: true})
if err != nil {
	return err
}
grant, err := client.Tokens.Create(ctx, livqeno.CreateTokenParams{
	Room:     room.ID,
	Identity: userID,
	Permissions: &livqeno.TokenPermissions{
		Join: livqeno.Bool(true), Subscribe: livqeno.Bool(true),
		Publish: livqeno.Bool(true), PublishData: livqeno.Bool(true),
	},
	ExpiresIn: 600,
})

import com.livqeno.server.model.*;
 
Room room = livqeno.rooms().create(CreateRoomParams.builder().name(roomName).getOrCreate(true).build());
 
IssuedToken grant = livqeno.tokens().create(CreateTokenParams.builder()
        .room(room.id())
        .identity(userId)
        .permissions(TokenPermissions.builder().join(true).subscribe(true).publish(true).publishData(true).build())
        .expiresIn(600)
        .build());

$room = $client->rooms->create(['name' => $roomName, 'getOrCreate' => true]);
 
$grant = $client->tokens->create([
    'room' => $room->id,
    'identity' => $userId,
    'permissions' => ['join' => true, 'subscribe' => true, 'publish' => true, 'publishData' => true],
    'expiresIn' => 600,
]);

import { Room, RoomEvent } from 'livekit-client';
 
const room = new Room({ adaptiveStream: true, dynacast: true });
 
room.on(RoomEvent.TrackSubscribed, (track, publication, participant) => {
  grid.appendChild(track.attach());
});
room.on(RoomEvent.TrackUnsubscribed, (track) => track.detach().forEach((el) => el.remove()));
 
await room.connect(url, token);
await room.localParticipant.enableCameraAndMicrophone();

import { createRTCClient } from '@livqeno/rtc';
 
const grant = await fetch('/join-room', { method: 'POST' }).then((r) => r.json());
const client = createRTCClient(grant); // adaptiveStream is on by default
const room = await client.join(); // the room comes from the token
 
room.on('trackSubscribed', (track, participant) => {
  const el = track.attach();
  el.dataset.identity = participant.identity;
  grid.appendChild(el);
});
room.on('trackUnsubscribed', (track) => track.detach().forEach((el) => el.remove()));
 
await room.enableCamera();
await room.enableMicrophone();

await room.localParticipant.setMicrophoneEnabled(false);
await room.localParticipant.setMicrophoneEnabled(true);

const mic = await room.enableMicrophone();
await mic?.mute(); // stays published; others get trackMuted
await mic?.unmute();
 
await room.disableMicrophone(); // or unpublish and release the device

await room.localParticipant.setScreenShareEnabled(true);
await room.localParticipant.setScreenShareEnabled(false);

await room.enableScreenShare();
await room.disableScreenShare();

const payload = new TextEncoder().encode(JSON.stringify({ type: 'raise-hand' }));
await room.localParticipant.publishData(payload, { reliable: true, topic: 'hands' });
 
room.on(RoomEvent.DataReceived, (payload, participant, kind, topic) => {
  console.log(participant?.identity, topic, new TextDecoder().decode(payload));
});

await room.sendData(JSON.stringify({ type: 'raise-hand' }), { reliable: true, topic: 'hands' });
 
room.on('dataReceived', (payload, participant, topic) => {
  console.log(participant?.identity, topic, new TextDecoder().decode(payload));
});

import { RoomServiceClient } from 'livekit-server-sdk';
 
const svc = new RoomServiceClient(host, apiKey, apiSecret);
await svc.mutePublishedTrack(roomName, identity, trackSid, true);
await svc.updateParticipant(roomName, identity, undefined, { canPublish: false });
await svc.removeParticipant(roomName, identity);
await svc.deleteRoom(roomName);

# Mute every audio track of one participant
curl -X POST "$LIVQENO_API_URL/v1/rooms/$ROOM_ID/participants/alice/mute" \
  -H "Authorization: Bearer $LIVQENO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"kind": "audio", "muted": true}'
 
# Take away publishing mid-call
curl -X PATCH "$LIVQENO_API_URL/v1/rooms/$ROOM_ID/participants/alice/permissions" \
  -H "Authorization: Bearer $LIVQENO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"publish": false}'
 
# Disconnect one person, then close the room
curl -X POST "$LIVQENO_API_URL/v1/rooms/$ROOM_ID/participants/alice/remove" \
  -H "Authorization: Bearer $LIVQENO_API_KEY"
curl -X DELETE "$LIVQENO_API_URL/v1/rooms/$ROOM_ID" \
  -H "Authorization: Bearer $LIVQENO_API_KEY"

import { EgressClient, EncodedFileOutput, StreamOutput, StreamProtocol } from 'livekit-server-sdk';
 
const egress = new EgressClient(host, apiKey, apiSecret);
 
// Record the room to a file
const rec = await egress.startRoomCompositeEgress(roomName, {
  file: new EncodedFileOutput({ filepath: 'recordings/{room_name}.mp4' }),
});
await egress.stopEgress(rec.egressId);
 
// Push the room to YouTube
await egress.startRoomCompositeEgress(roomName, {
  stream: new StreamOutput({ protocol: StreamProtocol.RTMP, urls: [`rtmps://a.rtmp.youtube.com/live2/${key}`] }),
});

// RTMP out and recording belong to live streams, which own their own room.
const stream = await livqeno.liveStreams.create({
  title: 'Launch',
  hostIdentity: 'host-1',
  deliveryMode: 'BROADCAST', // HLS for viewers, and an HLS replay when it ends
});
const hostGrant = await livqeno.liveStreams.addHost(stream.id, { identity: 'host-1' });
await livqeno.liveStreams.start(stream.id);
 
const destination = await livqeno.liveStreams.restreams.create(stream.id, {
  url: 'rtmps://a.rtmp.youtube.com/live2', // URL and key are separate fields
  streamKey: process.env.YOUTUBE_STREAM_KEY!,
  label: 'YouTube',
});
await livqeno.liveStreams.restreams.delete(stream.id, destination.id); // stop that destination
 
await livqeno.liveStreams.end(stream.id); // → live_stream.recording_ready webhook with recordingUrl

stream, err := client.LiveStreams.Create(ctx, livqeno.CreateLiveStreamParams{
	Title:        "Launch",
	HostIdentity: "host-1",
})
if err != nil {
	return err
}
if _, err := client.LiveStreams.Start(ctx, stream.ID); err != nil {
	return err
}
_, err = client.LiveStreams.Restreams.Create(ctx, stream.ID, livqeno.CreateRestreamParams{
	URL:       "rtmps://a.rtmp.youtube.com/live2",
	StreamKey: os.Getenv("YOUTUBE_STREAM_KEY"),
	Label:     "YouTube",
})

import { IngressClient, IngressInput } from 'livekit-server-sdk';
 
const ingressClient = new IngressClient(host, apiKey, apiSecret);
const ingress = await ingressClient.createIngress(IngressInput.RTMP_INPUT, {
  roomName,
  participantIdentity: 'obs',
  participantName: 'OBS',
});
console.log(ingress.url, ingress.streamKey);

// One ingest per live stream. 'RTMP' (rtmp:// and rtmps://) or 'WHIP'.
const ingress = await livqeno.liveStreams.ingress.create(stream.id, { protocol: 'RTMP' });
console.log(ingress.rtmpsUrl, ingress.streamKey); // the key is shown only now

import { ExternalE2EEKeyProvider, Room } from 'livekit-client';
 
const keyProvider = new ExternalE2EEKeyProvider();
await keyProvider.setKey(passphrase);
const room = new Room({
  e2ee: { keyProvider, worker: new Worker(new URL('livekit-client/e2ee-worker', import.meta.url)) },
});
await room.setE2EEEnabled(true);

import { createRTCClient, createSharedKeyProvider } from '@livqeno/rtc';
 
// Backend: livqeno.rooms.create({ name, e2ee: true }), fixed for the room's life.
const client = createRTCClient({ ...grant, e2ee: { keyProvider: createSharedKeyProvider(passphrase) } });
const room = await client.join();

import { WebhookReceiver } from 'livekit-server-sdk';
 
const receiver = new WebhookReceiver(apiKey, apiSecret);
const event = await receiver.receive(rawBody, req.get('Authorization'));
if (event.event === 'participant_joined') {
  // event.room, event.participant
}

import { verifyWebhook } from '@livqeno/server';
 
// rawBody: the bytes as received (express.raw()), not a parsed object
const event = verifyWebhook(rawBody, req.get('Swalvo-Signature'), process.env.LIVQENO_WEBHOOK_SECRET!); // throws if invalid
if (event.type === 'room.participant_joined') {
  // event.data: { roomId, identity, connectionId, at }
}

event, err := livqeno.VerifyWebhookRequest(r, os.Getenv("LIVQENO_WEBHOOK_SECRET"))
if err != nil {
	http.Error(w, "invalid signature", http.StatusBadRequest)
	return
}
// event.ID (dedupe on it), event.Type, event.Data

import hashlib, hmac, time
 
def verify(raw_body: bytes, header: str, secret: str) -> bool:
    parts = dict(p.strip().split("=", 1) for p in header.split(",") if "=" in p)
    t = parts.get("t", "")
    if not t.isdigit() or abs(time.time() - int(t)) > 300:
        return False
    expected = hmac.new(secret.encode(), t.encode() + b"." + raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(parts.get("v1", ""), expected)