A Developer’s Guide To Video APIs (With Use Cases)

Adding live video to an application used to mean months of infrastructure work. STUN and TURN servers. WebRTC signaling logic. Bandwidth management that buckled the moment concurrent viewership spiked. Custom encoding pipelines that needed a dedicated team just to keep running.

That era is over. A video API abstracts away the encoding, hosting, and delivery layers so your engineering team can embed high-quality, low-latency video into your product in hours instead of quarters.

This guide covers the protocols you need to understand, the use cases developers are building today, and how to get a live video session running with real code.

The Two Protocols That Matter

Every video API is built on one of two protocol families. Which one the API uses determines your latency ceiling, your scalability limit, and the types of experiences you can build.

1. WebRTC (Web Real-Time Communication)

WebRTC establishes peer-to-peer connections between browsers. In ideal conditions, latency runs under 200 milliseconds, which makes it the protocol for any use case where delay kills the experience: live Q&A, telehealth consultations, breakout rooms, interactive workshops.

The catch is scaling. Raw peer-to-peer connections don’t work beyond a handful of participants because each new peer multiplies the number of media streams every device has to process.

A well-built video API solves this with an SFU (Selective Forwarding Unit) architecture that routes media streams through a server, reducing the CPU load on each client device. Without an SFU layer, your users’ laptops will start struggling at around 6 to 8 concurrent video feeds.

2. HLS and RTMP (Broadcasting)

For one-to-many broadcasts where interaction latency is less critical, the standard pattern is RTMP ingest (the video feed from the presenter’s device to the server) combined with HLS delivery (small video chunks distributed to viewers over a CDN). Latency typically lands between 10 and 30 seconds, which is fine for keynote addresses, product announcements, or any broadcast where the audience is watching rather than participating in real time.

The best video APIs handle both protocols and switch between them automatically. You use WebRTC when presenters and attendees need to interact in real time, and HLS when you’re broadcasting to a large passive audience. The developer shouldn’t have to manage that transition manually.

What Developers Are Building With Video APIs

Embedded Video in SaaS Products

The most common use case: building a native video experience directly into your application so users never have to leave for a third-party tool. Instead of linking out to Zoom or asking users to download a desktop app, your product handles the entire video session in-browser.

BMC, an enterprise IT software company, used Sequel’s embed API to build webinar functionality directly into their customer portal. Their developer team dropped the embed code into their existing CMS, connected it to their authentication system, and had a working video experience without building any video infrastructure from scratch.

Their engineering lead described the approach: “We would just embed this portion. All of this would be something that somebody inputs on our site. So it’s like both.”

PowerSchool took a similar approach, embedding Sequel into their learning portal so customers could access product training sessions without leaving the platform they were already logged into.

Live Engagement Layers

Video alone isn’t enough. The sessions that drive real engagement pair the video stream with interactive components: live chat, Q&A queues, polls, emoji reactions. Building each of those from scratch is weeks of development work per component.

A video API with pre-built engagement components lets you drop in a chat widget with sub-50ms latency, moderated Q&A, and live polls alongside the video player. You style it with your own CSS. You control the data. But you skip the months of building real-time messaging infrastructure.

Video Content Management

A live session generates a recording. That recording needs to be transcoded, stored, and made available on-demand. Without an API, this is a manual workflow: download the file, transcode it, upload it to your hosting provider, generate a new embed link, update your site.

A video CMS API automates the full lifecycle. The live stream records automatically, the API transcodes the file, and an on-demand replay is available the moment the session ends. Sequel’s AI Studio takes this further by generating clips, blog posts, social content, and transcripts from every recording automatically.

Analytics and Webhook Data

Product teams need to understand what’s happening inside video sessions, not just whether someone attended. A good analytics API exposes minute-by-minute watch data, poll responses, chat activity, Q&A engagement, and drop-off points.

The real power is in the webhooks.

Rather than checking a dashboard, you configure the API to push engagement events directly into your own system, whether that’s a CRM, a data warehouse, or a custom analytics dashboard. Sequel’s Audience Insights tracks not just in-session behavior but also what attendees did on your website before and after the event, giving product and marketing teams a complete behavioral picture.

Getting Started: Real Code

One of the biggest advantages of a modern video API is how quickly you can go from zero to a working video session. Here’s what a real implementation looks like with the Sequel SDK.

Step 1: Install and authenticate

import { sequel } from "@sequel.io/api";

const sdk = sequel.configure({
  clientId: process.env.SEQUEL_API_CLIENT_ID,
  clientSecret: process.env.SEQUEL_API_SECRET_ID
});

Step 2: Create an event programmatically

// Create a new live session
const event = await sdk.event.addEvent({
  title: "Q3 Product Launch",
  startDate: "2026-10-15T14:00:00Z",
  settings: {
    chat: true,
    qna: true,
    recording: true
  }
});

Step 3: Generate a secure viewer token

Sequel uses JWT-based authentication. Your backend generates a short-lived token for each user, which controls their permissions (attendee vs. presenter vs. organizer).

// Generate a JWT token for a specific user
const token = await sdk.event.getEmbed({
  eventId: event.id,
  user: {
    email: "viewer@example.com",
    firstName: "Alex"
  }
});

Step 4: Render the video player

On the frontend, you drop the embed URL (with the token) into an iframe or use Sequel’s React quickstart to render the full video experience.

<iframe
  src="https://event.sequel.io/embed/{eventId}?token={jwt}"
  allow="camera; microphone; display-capture"
  style="width: 100%; height: 600px; border: none;"
></iframe>

That’s it. Four steps from zero to a working, authenticated video session with chat, Q&A, and recording. The full developer documentation walks through authentication flows, webhook configuration, and advanced customization.

Choosing the Right Video API

Not every video API is built the same way. Here’s what to evaluate before you commit.

• Protocol flexibility: Can the API handle both WebRTC for interactive sessions and HLS for large-scale broadcasts? If you have to choose one, you’ll hit a wall the moment your use case changes.
• Embed architecture: Does the API let you embed video natively in your product, or does it redirect users to the provider’s domain? If your users leave your app to join a video session, you lose control of the experience and the data.
• Pre-built components vs. raw primitives: Building chat, Q&A, and polls from scratch is expensive. APIs that include pre-built, customizable engagement components save months of development time without sacrificing design control.
• Authentication integration: If your product already has a login system, the video API should support JWT-based authentication so users don’t have to sign in twice. Sequel’s authentication integration guide covers this in detail.
• Data access: Can you pull engagement data out via API and webhooks, or are you locked into the provider’s dashboard? If your product team needs session data in your own analytics stack, webhook support is non-negotiable.
• Scalability ceiling: What happens when you go from 50 concurrent viewers to 50,000? The API should handle that without you rearchitecting anything. Sequel scales to 2 million concurrent viewers across 16 global data centers.

Why Developers Build on Sequel

Sequel’s API was designed for teams that want to own the video experience inside their product without building video infrastructure from scratch.

The pre-built components (virtual stage, chat, Q&A, polls, networking hubs) get you to a working prototype in minutes. The SDK (@sequel.io/api) gives you programmatic control over event creation, user authentication, and analytics. And the embed architecture means the video session lives inside your application, on your domain, styled with your CSS.

Companies like Apollo.io run 8 embedded webinars per week on Sequel. Sentry embeds developer workshops directly into their community experience.

M-Files migrated their entire webinar infrastructure from ON24 to Sequel’s embedded platform and described it as “a huge step in the right direction” that saved them “hours per week” in manual processes.

If you’re evaluating video APIs for your product, create a free developer account to test the SDK, or book a technical demo to walk through your specific architecture with the team.

Frequently Asked Questions

What is a video API?

A video API is a set of programmatic endpoints that let developers create, process, store, and deliver video inside their own applications without building the underlying infrastructure from scratch. Instead of writing custom encoding pipelines, managing STUN/TURN servers, and configuring CDN delivery, developers call API endpoints that handle the heavy lifting and focus their time on the user experience.

What is the difference between WebRTC and HLS?

WebRTC is a real-time protocol designed for interactive video with latency under 200 milliseconds. It’s the right choice for live Q&A, telehealth, breakout rooms, and any session where participants need to communicate in real time. HLS (HTTP Live Streaming) delivers video in small chunks over a CDN with 10 to 30 seconds of latency, which makes it better suited for large-scale one-to-many broadcasts like keynotes or product announcements. The best video APIs support both protocols and switch between them automatically based on the session type.

How do I embed live video into my own application?

Most modern video APIs generate an iframe embed URL or provide a frontend SDK that renders the video player inside your application. With Sequel’s API, for example, you authenticate via JWT, create an event programmatically, generate a secure token for each viewer, and render the session in an iframe or React component. The entire flow takes four steps and keeps the video experience on your domain.

Do I need to build chat, Q&A, and polls separately?

Not if your video API includes pre-built engagement components. Some APIs only provide the raw video stream and leave everything else to you. Others, like Sequel, include customizable chat (with sub-50ms latency), moderated Q&A, polls, and emoji reactions as pre-built components you can drop in alongside the video player and style with your own CSS.

How does authentication work with a video API?

The standard approach is JWT-based authentication. Your backend server calls the video API to generate a short-lived token for each user. That token controls the user’s permissions (attendee, presenter, or organizer) and is passed to the frontend embed. If your application already has its own login system, the video API should integrate with it so users don’t have to authenticate twice.

Can a video API handle large-scale events?

Yes, but scalability varies significantly between providers. Raw WebRTC peer-to-peer connections start struggling at around 6 to 8 concurrent video feeds without an SFU (Selective Forwarding Unit) layer. A well-architected video API uses SFU routing to support hundreds of active video participants and HLS broadcasting to scale passive viewership into the hundreds of thousands. Sequel’s infrastructure supports up to 2 million concurrent viewers across 16 global data centers.