Whether it's a company logo, presentation slide, floor plan, status board, or periodically updated camera snapshot, Image Sources make it easy to bring visual content into a meeting alongside participants. If you've already worked with the Playback API, you'll feel right at home - the concept is very similar, but designed for images instead of videos.

Example​

Image Sources can be created from either a public URL or an uploaded image file. URL-based images may also be refreshed automatically at a configurable interval, making them ideal for dynamically generated content.

curl -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "url":"https://example.com/dashboard.png",
    "name":"Live Dashboard",
    "object_fit":"contain",
    "refresh_interval":30
  }' \
  "https://api.eyeson.team/rooms/$ACCESS_KEY/image_sources"

curl -X POST \
  -F "file=@floorplan.png" \
  -F "name=Floor Plan" \
  -F "object_fit=contain" \
  "https://api.eyeson.team/rooms/$ACCESS_KEY/image_sources"

Once created, an image source remains part of the meeting until it's removed via the API.

Image Sources can optionally be assigned an image_source_id, allowing them to be updated in place or referenced from Meeting Layouts to keep images at fixed positions.

For a complete overview of all parameters and examples, see the Image Sources documentation.

Stay in Sync​

Applications using the Meeting Observer API can listen for the new image_source_update event. Whenever image sources are added, updated, or removed, the observer receives the complete list of active image sources, making it easy to keep clients synchronized with the meeting state.

We'd Love Your Feedback​

We're excited to see how you'll use Image Sources in your applications. If you have ideas, questions, or feedback, let us know on our GitHub issue board:

https://github.com/eyeson-team/api/issues

Thanks for building with Eyeson!

Why the Change?​

The insert parameter was originally introduced to make it easy to display simple overlays by automatically generating a grey, translucent background with the provided text inside. It was a convenient shortcut, requiring no design work or external assets.

However, as developer needs evolved, so did our API. The insert parameter is now being retired in favor of a much more powerful and flexible alternative: SVG overlays.

Your Best Option Going Forward: SVG Overlays​

With SVG, you can easily replicate the same translucent text box style that insert used - but you're not limited to it:

• Position the overlay anywhere in the video frame
• Adjust size, and colors to match your brand or UI needs
• Add icons, shapes, or even dynamic data if needed
• SVGs are lightweight, scalable, and rendered server-side by Eyeson - just like the old insert

Whether you're sending an SVG via file or referencing one hosted via url, the setup is straightforward. And because SVG is just XML, it's easy to generate dynamically from backend code or templates.

Check out our dedicated blog post on SVG support and how to implement it here: Using SVG with Eyeson Layers

Example: Recreating the Old "insert" Style with SVG​

With the @eyeson/node-svg-layer Node.js plugin, you can easily generate a styled SVG overlay that mimics the default insert look:

import Eyeson from '@eyeson/node';
import EyesonSvgLayer from '@eyeson/node-svg-layer';

const eyeson = new Eyeson();
const layer = new EyesonSvgLayer();

const text = '...';
const fontSize = 16;
const bold = false;
const fontColor = 'black';
const x = 240;
const y = 450;
const width = 800;
const maxHeight = 250;
const padding = 15;
const lineHeight = 21;
const radius = 5;
const color = 'white 80%';

layer.addMultilineTextBox(text, fontSize, bold, fontColor, x, y, width, maxHeight, padding, lineHeight, radius, color);

const user = await eyeson.getUser(accessKey);
await user.sendLayer(layer);

This creates:

• A centered text box
• Black text on a grey translucent background
• Padding and border radius to match the legacy style

For more customization tips and advanced dynamic overlays, check out the full documentation.

Final Note​

We're committed to providing a developer-friendly, future-ready platform. SVG gives you the flexibility that insert never could - and we're confident your overlays will look better and work more reliably with this update.

As always, if you need help migrating or want to share feedback, don’t hesitate to reach out via GitHub.

Thanks for building with Eyeson!

This utility enables developers to stream an ongoing eyeson meeting directly to any Chromecast-enabled TV or compatible device, such as a smart TV or external monitor. The goal? To provide a distraction-free, video-only experience that's perfect for demos, presentations, or team meetings where visual clarity matters most.

Whether you're showcasing a product, joining a town hall, or presenting to a mix of in-room and remote participants, the Casting Manager simplifies getting your meeting session onto the big screen - with just a few lines of code.

Why Cast?​

Sometimes, less is more. By casting only the meeting video to an external screen, your audience stays focused on the speaker and shared visuals - without UI overlays or local controls getting in the way. This is ideal for:

• Presentations with both in-room and remote participants
• Displaying meetings on a screen in a conference room
• Passive viewing for team members who just need to watch
• Streaming remote demos to a TV or external monitor

Available in Prebuilt UI​

If you're using the eyeson Prebuilt UI, you're all set - Cast to Device is built in and ready to use. Simply open the three-dot menu during a meeting, select "Cast to Device", and click the Start button in the popup to begin casting to a compatible screen.

Browser and Device Support​

The Cast to Device feature is supported in Chromium-based browsers such as Google Chrome, Microsoft Edge, and Opera on desktop platforms.

Casting works with any connected display and supports wireless streaming to Chromecast or Cast-enabled devices, including:

• Google Chromecast
• Chromecast built-in devices
• Devices with a Google Cast receiver

Android TV and some smart TVs have built-in Cast functionality, but support and performance may vary depending on the device manufacturer and software implementation.

Getting Started​

Here's a quick example of how you can use the new casting feature:

<button type="button" id="button-cast" disabled>Start</button>

<script type="module">
import eyeson, { FeatureDetector } from '@eyeson/js';

const { castingManager } = eyeson;
const buttonCast = document.getElementById('button-cast');

if (FeatureDetector.canCast() === true) {
  buttonCast.disabled = castingManager.blocked;
  
  castingManager.onUpdate((event) => {
    const { type } = event;
    if (type === 'connected') {
      buttonCast.textContent = 'Stop';
    }
    else if (type === 'terminated') {
      buttonCast.textContent = 'Start';
    }
    else if (type === 'error') {
      alert(event.error.toString());
    }
    else if (type === 'change_blocked') {
      buttonCast.disabled = castingManager.blocked;
    }
  });

  buttonCast.addEventListener('click', () => {
    if (castingManager.connected) {
      castingManager.stop();
    }
    else {
      castingManager.start();
    }
  });
}
</script>

Once start() is called, the browser will display a popup with a list of available casting devices. As soon as a device is selected, the meeting video will begin streaming to it.

Calling stop() will end the casting session.

Read more about all available functions in EyesonJS in the documentation.

Final Thoughts​

The new Cast to Device feature adds a whole new dimension to presenting and participating in eyeson meetings. Whether you're embedding EyesonJS into your app or using our prebuilt UI, you can now extend your video stream to any Chromecast-enabled display with ease.

Try it out today and let us know what you think - we'd love to hear from you! If you have any questions or feedback, don’t hesitate to create a ticket on GitHub.

Happy casting!

What Is WHIP?​

WHIP is a straightforward signaling protocol that uses standard HTTP methods (like POST and DELETE) to establish and manage a WebRTC media session between a client and a media server.

By standardizing the signaling process, WHIP simplifies media ingestion—making it easier to integrate into workflows where audio or video streams are forwarded for processing, such as AI pipelines.

Benefits for AI Streaming​

• Low latency: WHIP leverages WebRTC for real-time media transport, ensuring minimal delay.
• Scalability: Efficient HTTP-based signaling makes it easy to manage thousands of sessions.
• Compatibility: WebRTC peer connections integrate seamlessly with AI pipelines like GStreamer, FFmpeg, or custom ML models.

Forwarding Streams with Eyeson​

Eyeson offers a powerful API Forward Stream feature that enables you to forward video and audio streams from a room to a specified destination.

You can forward streams from individual participants, the full MCU One View stream, or playback streams to external endpoints — all through the API.

Streams are delivered in their native format without any transcoding. This preserves the original quality and ensures seamless integration with various processing pipelines, minimizing latency and maintaining high fidelity.

Forwarding is automatically stopped when a source disconnects, simplifying stream management. Developers can also leverage Eyeson's Observer API to monitor participant and playback updates, enabling quick and efficient responses to connection changes.

WHIP + AI Processing: System Overview​

Here's the high-level flow for using WHIP to forward audio/video streams to an AI pipeline:

1. Eyeson API forward stream sends a POST request with an SDP offer to the WHIP Server.

2. The WHIP Server creates a WebRTC peer connection using this offer and returns an SDP answer.

3. Once the WebRTC negotiation completes, the media stream flows directly into a PeerConnection.

4. Streams are managed and transformed on the AI Pipeline to ensure full AI compatibility.

5. When the session is done, a DELETE request tears down the connection gracefully.

Code Examples: WHIP server setup​

Here are some starter snippets for creating a WHIP-compatible server.

#!/usr/bin/env python3

import asyncio
import logging
import traceback
import uuid
from aiohttp import web
from aiortc import RTCPeerConnection, RTCSessionDescription, RTCConfiguration, RTCIceServer

logger = logging.getLogger(__name__)

HOST = '0.0.0.0'
PORT = 8889

# Simplified WHIP server
class SimpleWhipServer:
    """A simplified WHIP server"""
    
    def __init__(self):
        self.sessions = {}
    
    async def handle_whip_options(self, request):
        """Handle OPTIONS request for CORS preflight."""
        headers = {
            "Access-Control-Allow-Origin": "*",
            "Access-Control-Allow-Methods": "OPTIONS, POST, GET, DELETE",
            "Access-Control-Allow-Headers": "Content-Type",
        }
        return web.Response(status=204, headers=headers)
    
    async def handle_whip_request(self, request):
        """Handle WHIP POST request with SDP offer."""
        try:
            logger.debug(f"Received request: {request.method} {request.url}")
            logger.debug(f"Headers: {dict(request.headers)}")
            
            session_id = str(uuid.uuid4())
            
            headers = {
                "Access-Control-Allow-Origin": "*",
                "Access-Control-Allow-Methods": "OPTIONS, POST, GET, DELETE",
                "Access-Control-Allow-Headers": "Content-Type",
                "Access-Control-Expose-Headers": "Location",
                "Content-Type": "application/sdp",
                "Location": f"{request.url}/{session_id}"
            }
            
            content_type = request.headers.get("Content-Type", "")
            if "application/sdp" not in content_type:
                return web.Response(
                    status=400,
                    text="Content-Type must be application/sdp",
                    headers=headers
                )
            
            sdp = await request.text()
            logger.warning(f"Received SDP: {sdp}")
            
            config = RTCConfiguration(iceServers=[RTCIceServer(urls="stun:stun.l.google.com:19302")])
            pc = RTCPeerConnection(configuration=config)
            
            self.sessions[session_id] = pc
            
            @pc.on("track")
            async def on_track(track):
                logger.warning(f"Received {track.kind} track")
                if track.kind == "video":
                    while track.readyState == "live":
                        try:
                            frame = await track.recv()
                            logger.warning(f"Video frame: {frame.width}x{frame.height} @ {frame.time}")
                            # You can add additional processing here
                        except Exception as e:
                            logger.error(f"Error receiving video frame: {e}")
                            break

                elif track.kind == "audio":
                    while track.readyState == "live":
                        try:
                            frame = await track.recv()
                            logger.warning(f"Audio frame: {frame.samples} samples @ {frame.sample_rate} Hz")
                            # You can add audio processing here
                        except Exception as e:
                            logger.error(f"Error receiving audio frame: {e}")
                            break

            @pc.on("connectionstatechange")
            async def on_connectionstatechange():
                logger.warning(f"Connection state changed: {pc.connectionState}")
                if pc.connectionState in ("failed", "closed", "disconnected"):
                    logger.warning(f"Peer connection {session_id} ended with state: {pc.connectionState}")
                    await self._cleanup_session(session_id)

            offer = RTCSessionDescription(sdp=sdp, type="offer")
            await pc.setRemoteDescription(offer)
            answer = await pc.createAnswer()
            await pc.setLocalDescription(answer)
            
            return web.Response(
                text=pc.localDescription.sdp,
                headers=headers,
                status=201
            )
            
        except Exception as e:
            logger.error(f"Error processing WHIP request: {e}")
            logger.error(traceback.format_exc())
            headers = {
                "Access-Control-Allow-Origin": "*",
                "Content-Type": "text/plain"
            }
            return web.Response(
                status=500,
                text=f"Server error: {str(e)}",
                headers=headers
            )
        
    async def handle_whip_delete(self, request):
        """Handle DELETE /whip/{session_id} to stop the peer connection."""
        headers = {
            "Access-Control-Allow-Origin": "*",
        }
        session_id = request.match_info.get('session_id')
        if session_id not in self.sessions:
            return web.Response(status=404, text=f"No active session with ID {session_id}", headers=headers)

        try:
            logger.info(f"Stopping session {session_id} via DELETE")
            await self._cleanup_session(session_id)
            return web.Response(status=200, text=f"Session {session_id} terminated", headers=headers)
        except Exception as e:
            logger.error(f"Error stopping session {session_id}: {e}")
            return web.Response(status=500, text=f"Error stopping session: {str(e)}", headers=headers)
    
    async def _cleanup_session(self, session_id):
        """Helper function to close peer connection for a session."""
        pc = self.sessions.get(session_id)
        if not pc:
            logger.warning(f"No session found with ID {session_id} for cleanup")
            return

        try:
            if pc and pc.connectionState != "closed":
                await pc.close()
                logger.info(f"PeerConnection closed for session {session_id}")
        except Exception as e:
            logger.error(f"Error closing PeerConnection for session {session_id}: {e}")

        self.sessions.pop(session_id, None)
    
async def init_app():
    """Initialize the application."""
    whip_server = SimpleWhipServer()
    
    @web.middleware
    async def error_middleware(request, handler):
        try:
            return await handler(request)
        except web.HTTPException as ex:
            logger.warning(f"HTTP Exception: {ex.status} - {ex.reason}")
            raise
        except Exception as e:
            logger.error(f"Unhandled exception: {e}")
            logger.error(traceback.format_exc())
            return web.Response(status=500, text=str(e))
    
    app = web.Application(middlewares=[error_middleware])
    app.router.add_post('/whip', whip_server.handle_whip_request)
    app.router.add_options('/whip', whip_server.handle_whip_options)
    app.router.add_delete('/whip/{session_id}', whip_server.handle_whip_delete)
    app.router.add_options('/whip/{session_id}', whip_server.handle_whip_options)
    return app

async def main():
    """Main application entry point."""
    app = await init_app()
    
    runner = web.AppRunner(app)
    await runner.setup()
    site = web.TCPSite(runner, HOST, PORT)
    
    logger.info(f"Starting WHIP server on {HOST}:{PORT}")
    await site.start()
    
    print(f"WHIP server listening on :8889\n")
    
    try:
        while True:
            await asyncio.sleep(3600)
    except asyncio.CancelledError:
        logger.info("Server shutdown initiated")
    finally:
        await runner.cleanup()
        logger.info("Server stopped")

if __name__ == '__main__':
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        logger.info("Server stopped by user")

package main

import (
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "io"
    "log"
    "net/http"
    "strings"
    "sync"
    "errors"

    "github.com/pion/webrtc/v4"
)

var (
    sessionStore = sync.Map{} // map[string]*webrtc.PeerConnection
)

// Generates a random session ID
func generateSessionID() string {
    b := make([]byte, 16)
    if _, err := rand.Read(b); err != nil {
        panic(err)
    }
    return hex.EncodeToString(b)
}

// Ends a WHIP session: closes PeerConnection and removes from session store
// Also stops the video recording if active by closing the stdin pipe
func endSession(sessionID string) {
    val, ok := sessionStore.Load(sessionID)
    if !ok {
        return
    }

    pc := val.(*webrtc.PeerConnection)

    // Close PeerConnection
    if err := pc.Close(); err != nil {
        log.Printf("Error closing PeerConnection for session %s: %v", sessionID, err)
    }

    sessionStore.Delete(sessionID)
    log.Printf("Session %s ended", sessionID)
}

// Handles POST /whip
func whipPostHandler(w http.ResponseWriter, r *http.Request) {
    // CORS
    w.Header().Set("Access-Control-Allow-Origin", "*")
    w.Header().Set("Access-Control-Allow-Methods", "POST, DELETE, OPTIONS, GET")
    w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
    w.Header().Set("Access-Control-Expose-Headers", "Location")

    if r.Method == http.MethodOptions {
        w.WriteHeader(http.StatusOK)
        return
    }

    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    if r.Header.Get("Content-Type") != "application/sdp" {
        http.Error(w, "Unsupported Media Type", http.StatusUnsupportedMediaType)
        return
    }

    body, err := io.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "Failed to read SDP body", http.StatusBadRequest)
        return
    }

    log.Printf("SDP Offer: %s", body)

    // Create PeerConnection with STUN server
    config := webrtc.Configuration{
        ICEServers: []webrtc.ICEServer{
            {
                URLs: []string{"stun:stun.l.google.com:19302"},
            },
        },
    }

    peerConnection, err := webrtc.NewPeerConnection(config)
    if err != nil {
        http.Error(w, "Failed to create PeerConnection", http.StatusInternalServerError)
        return
    }

    sessionID := generateSessionID()

    // Connection state cleanup handler
    peerConnection.OnConnectionStateChange(func(state webrtc.PeerConnectionState) {
        log.Printf("Session %s connection state: %s", sessionID, state.String())
        if state == webrtc.PeerConnectionStateDisconnected ||
            state == webrtc.PeerConnectionStateFailed ||
            state == webrtc.PeerConnectionStateClosed {
            endSession(sessionID)
        }
    })

    // Track handling
    peerConnection.OnTrack(func(track *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
        log.Printf("Incoming track: %s", track.Codec().MimeType)
    
        go func() {
            for {
                pkt, _, err := track.ReadRTP()
                if err != nil {
                    if errors.Is(err, io.EOF) || strings.Contains(err.Error(), "closed") {
                        log.Printf("Track %s ended: %v", track.ID(), err)
                    } else {
                        log.Printf("Error reading RTP packet from track %s: %v", track.ID(), err)
                    }
                    return
                }
    
                switch {
                case strings.HasPrefix(track.Codec().MimeType, "video/"):
                    log.Printf("Video packet received: SSRC=%d, Timestamp=%d, PayloadType=%d, PayloadSize=%d",
                        pkt.SSRC, pkt.Timestamp, pkt.PayloadType, len(pkt.Payload))
                    // You can add additional video processing here
    
                case strings.HasPrefix(track.Codec().MimeType, "audio/"):
                    log.Printf("Audio packet received: SSRC=%d, Timestamp=%d, PayloadType=%d, PayloadSize=%d",
                        pkt.SSRC, pkt.Timestamp, pkt.PayloadType, len(pkt.Payload))
                    // You can add additional audio processing here
                }
            }
        }()
    })

    // Set remote offer
    offer := webrtc.SessionDescription{
        Type: webrtc.SDPTypeOffer,
        SDP:  string(body),
    }

    if err := peerConnection.SetRemoteDescription(offer); err != nil {
        http.Error(w, "SetRemoteDescription failed", http.StatusInternalServerError)
        return
    }

    // Create and set local answer
    answer, err := peerConnection.CreateAnswer(nil)
    if err != nil {
        http.Error(w, "CreateAnswer failed", http.StatusInternalServerError)
        return
    }

    if err := peerConnection.SetLocalDescription(answer); err != nil {
        http.Error(w, "SetLocalDescription failed", http.StatusInternalServerError)
        return
    }

    // Wait for ICE gathering
    <-webrtc.GatheringCompletePromise(peerConnection)

    // Store session
    sessionStore.Store(sessionID, peerConnection)

    scheme := "http"
	if r.TLS != nil {
		scheme = "https"
	}
    // Respond with SDP answer and session location
    location := fmt.Sprintf("%s://%s%s/%s", scheme, r.Host, r.RequestURI, sessionID)
    w.Header().Set("Location", location)
    w.Header().Set("Content-Type", "application/sdp")
    w.WriteHeader(http.StatusCreated)
    w.Write([]byte(peerConnection.LocalDescription().SDP))
}

// Handles DELETE /whip/{session-id}
func whipDeleteHandler(w http.ResponseWriter, r *http.Request) {
    // CORS
    w.Header().Set("Access-Control-Allow-Origin", "*")
    w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
    w.Header().Set("Access-Control-Allow-Methods", "POST, DELETE, OPTIONS, GET")

    if r.Method == http.MethodOptions {
        w.WriteHeader(http.StatusOK)
        return
    }

    if r.Method != http.MethodDelete {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    pathParts := strings.Split(r.URL.Path, "/")
    if len(pathParts) < 3 || pathParts[1] != "whip" {
        http.Error(w, "Invalid session path", http.StatusBadRequest)
        return
    }

    sessionID := pathParts[2]
    _, ok := sessionStore.Load(sessionID)
    if !ok {
        http.NotFound(w, r)
        return
    }

    endSession(sessionID)
    w.WriteHeader(http.StatusOK)
}

func main() {
    http.HandleFunc("/whip", whipPostHandler)    // POST /whip
    http.HandleFunc("/whip/", whipDeleteHandler) // DELETE /whip/<id>

    fmt.Println("WHIP server listening on :8889")
    if err := http.ListenAndServe(":8889", nil); err != nil {
        log.Fatal(err)
    }
}

import express from 'express';
import wrtc from '@roamhq/wrtc';

const app = express();
const port = 8889;
// Store active peer connections keyed by session ID
const sessions = {};

app.use(express.text({ type: '*/*' }));

// Enable CORS for all routes
app.use((_req, res, next) => {
    res.header('Access-Control-Allow-Origin', '*'); // Or restrict to specific origin
    res.header('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
    res.header('Access-Control-Allow-Headers', 'Content-Type');
    res.header('Access-Control-Expose-Headers', 'Location');
    next();
});

// Handle preflight OPTIONS requests
app.options('/{*splat}', (_req, res) => {
    res.sendStatus(204); // No Content
});

app.post('/whip', async (req, res) => {
    if (!req.is('application/sdp')) {
        return res.status(415).send('Unsupported Media Type: expected application/sdp');
    }
    const sessionId = generateSessionId();

    const offerSDP = req.body;

    const pc = new wrtc.RTCPeerConnection({
        iceServers: [
            { urls: 'stun:stun.l.google.com:19302' }
        ]
    });

    pc.ontrack = ({ track }) => {
        console.log('Received track:', track.kind);
        if (track.kind === 'audio') {
            const audioSink = new wrtc.nonstandard.RTCAudioSink(track);
            audioSink.ondata = ({ bitsPerSample, sampleRate, samples }) => {
                // process audio data
                console.log(bitsPerSample, sampleRate, samples.length);
            };
        }
        else if (track.kind === 'video') {
            const videoSink = new wrtc.nonstandard.RTCVideoSink(track);
            videoSink.onframe = ({ frame: { width, height, data } }) => {
                // process video frames
                console.log(`${width}x${height}, ${data.length} bytes`);
            };
        }
    };

    pc.onconnectionstatechange = () => {
        console.log('Connection state changed to:', pc.connectionState);
        if (pc.connectionState === 'disconnected' || pc.connectionState === 'failed') {
            if (sessions[sessionId]) {
                terminateSession(sessionId);
            }
        }
    };

    try {
        await pc.setRemoteDescription({ type: 'offer', sdp: offerSDP });
        const answer = await pc.createAnswer();
        await pc.setLocalDescription(answer);
        await waitForIceGathering(pc, 1000);
    
        const answerSDP = pc.localDescription.sdp;
    
        // Save the session
        sessions[sessionId] = pc;
    
        const location = `${req.protocol}://${req.get('host')}${req.originalUrl}`;
        res.setHeader('Location', `${location}/${sessionId}`);
        res.setHeader('Content-Type', 'application/sdp');
        res.status(201).send(answerSDP);
    } catch (error) {
        return res.status(500).send(error.toString());
    }
});

// DELETE route to end session
app.delete('/whip/:id', (req, res) => {
    const sessionId = req.params.id;
    try {
        terminateSession(sessionId);
        res.status(200).send('Session terminated');
    } catch (error) {
        res.status(404).send(error.message);
    }
});

function terminateSession(sessionId) {
    console.log('DELETE', sessionId);
    if (!sessions[sessionId]) {
        throw new Error('Session not found');
    }
    const pc = sessions[sessionId];
    // Close peer connection and clean up
    pc.close();
    Reflect.deleteProperty(sessions, sessionId);
    console.log(`Session ${sessionId} terminated.`);
}

// Helper: wait for ICE gathering to finish
function waitForIceGathering(pc, maxTime) {
    return new Promise((resolve) => {
        const timer = setTimeout(() => resolve(), maxTime);
        pc.onicecandidate = ({ candidate }) => {
            if (!candidate) {
                clearTimeout(timer);
                resolve();
            }
        };
    });
}

function generateSessionId() {
    return Math.random().toString(36).substring(2, 10);
}

app.listen(port, (err) => {
    if (err) {
        console.log(err);
        return;
    }
    console.log(`WHIP server is listening on http://localhost:${port}/whip`);
});

The WHIP URL of all examples is:

https://<ip-of-whip-server>:8889/whip

WHIP-Compatible Tools as Alternatives and for Prototyping​

If you're exploring alternatives to building your own WHIP server or want to prototype quickly without diving into low-level implementation, there are several open-source tools that support WHIP and can feed WebRTC streams directly into your pipeline. Here are two solid options:

GStreamer: whipserversrc Element​

GStreamer is a powerful multimedia framework used across applications ranging from media playback to real-time AI inference. It now features a whipserversrc element that acts as a WHIP endpoint, making it easy to receive and process WebRTC media.

https://gstreamer.freedesktop.org/documentation/rswebrtc/whipserversrc.html

Here's an example of a simple GStreamer pipeline to receive and play a WHIP stream:

gst-launch-1.0 whipserversrc \
  signaller::host-addr=http://0.0.0.0:8889 \
  stun-server="stun://stun.l.google.com:19302" \
  ! decodebin ! videoconvert ! autovideosink

gst-launch-1.0 whipserversrc \
  signaller::host-addr=http://0.0.0.0:8889 \
  stun-server="stun://stun.l.google.com:19302" \
  ! decodebin ! audioconvert ! autoaudiosink

The WHIP URL will look like this:

https://<ip-of-gstreamer-server>:8889/whip/endpoint

You can also connect it directly to AI pipelines:

gst-launch-1.0 whipserversrc name=whip \
    whip. ! decodebin ! videoconvert ! videoscale ! \
    your_ai_inference_element_here

• Pros: A solid WHIP-compatible alternative for building prototypes.
• Easy integration with AI tools like TensorFlow or OpenCV.
• Ideal for developers already using GStreamer.

MediaMTX: WHIP-Ingest Server with RTSP/RTMP/UDP Output​

MediaMTX (formerly rtsp-simple-server) is a robust media server that supports WHIP as a native ingestion method. It can convert incoming WebRTC streams into RTSP, RTMP, HLS, SRT, and more — making it extremely flexible for AI and media applications.

https://github.com/bluenviron/mediamtx

For a basic setup, clone and run MediaMTX:

git clone https://github.com/bluenviron/mediamtx
cd mediamtx
./mediamtx

It has the following default WHIP URL:

https://<ip-of-mediamtx-server>:8889/mystream/whip

• Converts WebRTC to RTSP, HLS, SRT, MPEG-TS, etc.
• WHIP server built in — great for rapid prototyping or format bridging.
• Perfect for AI systems that prefer non-WebRTC formats.

Contact​

We'd love to hear from you!

If you're building real-time AI video pipelines and need help setting up WHIP or peer connection forwarding, feel free to reach out. We'd love to collaborate or support your development.

What's Changing?​

Previously, our packages were named like this:

• eyeson
• eyeson-node

Now, they'll be published like this:

• @eyeson/js
• @eyeson/node

This change only affects the package names — all functionality remains the same, and you can continue using our libraries as usual with a small update to your package.json.

Why We're Making This Change​

We made this update for a few important reasons — all of which benefit you as much as they do us:

• Better Clarity and Trust
  Scoped packages make it immediately clear that a package comes from our team. It adds confidence, especially when working with multiple dependencies.

• Easier Maintenance and Discovery
  All our packages are now grouped under the @eyeson scope, making it easier to discover and manage them as a set — whether you're browsing npm or searching within your project.

• Reduced Risk of Name Conflicts
  Scoped naming helps avoid accidental conflicts with similarly named public packages, providing a safer and more predictable developer experience.

• Streamlined Permissions and Security
  Using npm organizations allows us to better manage access, publishing rights, and versioning — which translates to more reliable and secure packages for you.

Deprecation Notice: Old Package Names​

To make this transition smooth for everyone:

• The old packages (e.g. eyeson-node) will remain available until July 1st, 2025.
• After that date, they will no longer receive updates and may be removed from npm entirely.

We strongly encourage you to migrate to the new scoped packages before that deadline.

What You Need to Do​

If you’re using one of our packages, simply update the package name in your package.json.

For example:

"dependencies": {
  "eyeson-node": "^1.4.0"
}

"dependencies": {
  "@eyeson/node": "^1.4.0"
}

• eyeson => @eyeson/js
• eyeson-node => @eyeson/node
• eyeson-node-layer => @eyeson/node-layer
• eyeson-node-svg-layer => @eyeson/node-svg-layer

Then run your usual install command:

npm install
# or
yarn install
# or
pnpm install

Thanks for Your Support​

We're committed to improving your experience as a developer and believe this change will lead to a cleaner, safer, and more scalable ecosystem for everyone using our tools.

If you have any questions or run into issues during the transition, don't hesitate to reach out to us!

This feature forms the backbone of the Eyeson AI Adatpter.

For full API documentation, visit https://docs.eyeson.com/docs/rest/references/forward.

Structure​

Eyeson Video Meetings are built on MCU (Multipoint Control Unit) technology. In this system, a media server aggregates, processes, and combines multiple audio and video streams into one or a few unified streams. To learn more about MCU, read Understanding SFU, MCU & Eyeson’s MCU+.

The Eyeson API allows you to forward the incoming media stream directly, before it even reaches the media server.

You can also forward the generated MCU+ One View media stream.

Setup​

To make sure only authorized people can forward a stream, authentication with an API key is required.

You will need a compatible WHIP (WebRTC-HTTP Ingestion Protocol) server as the destination endpoint.

While the same source can be forwarded to multiple destinations, each forward request must have its unique forward-id.

When the source is disconnected, the forward will automatically stop. To detect disconnections, you can use the Eyeson Meeting Observer's participant_update and playback_update. These provide insights when a source drops out or reconnects.

Application​

This feature is the foundation of the Eyeson AI Adatpter which allows a customer-implemented AI module to process streams and return instructions, such as layout changes or enhanced audio/video content. Since the AI module runs on the customer’s side, this setup is flexible and supports many use cases.

In its simplest form, you might want to capture important streams for processing or recording in their original quality, even if they are not visible on the MCU media stream.

API Usage​

The full API documentation is available at /docs/rest/references/forward.

To make integration easier, we've provided SDKs for quick implementation in Node.js, Go, and PHP.

Start a Source Forward​

The following example demonstrates how to forward a video source. For more examples, refer to the API documentation.

curl -X POST \
-H "Authorization: $API_KEY" \
-d "forward_id=$FORWARD_ID" \
-d "user_id=$USER_ID" \
-d "type=video" \
-d "url=${https://example.com/whip}" \
"https://api.eyeson.team/rooms/$ROOM_ID/forward/source"

const eyeson = new Eyeson({ apiKey: '<API_KEY>' });
const room_id = '<ROOM_ID>';
const forward = eyeson.createRoomForward(room_id);
await forward.source('<FORWARD_ID>', '<USER_ID>', 'video', 'https://example.com/whip...');

room_id := "<ROOM_ID>"
client, _ := eyeson.NewClient("<API_KEY>")
client.Rooms.ForwardSource(room_id, "<FORWARD_ID>", "<USER_ID>",
  []eyeson.MediaType{eyeson.Video}, "https://example.com/whip...")

$eyeson = new Eyeson('<API_KEY>');
$room_id = '<ROOM_ID>';
$forward = $eyeson->forward($room_id);
$forward->source('<FORWARD_ID>', '<USER_ID>', 'video', 'https://example.com/whip...');