Amazon Interactive Video Service Real-Time Streaming (Amazon IVS Real-Time) is a WebRTC-based service for low-latency interactive video applications like video conferencing and live collaboration. Unlike traditional CPaaS platforms that abstract away media handling with higher-level APIs, IVS Real-Time gives developers direct access to WebRTC primitives like MediaStreamTrack objects while still providing managed infrastructure for signaling, TURN/STUN servers, and media routing.
We got hands-on with Amazon IVS Real-Time when we migrated a client’s app off a prior Amazon Chime SDK implementation, and were impressed with how it turned out. As WebRTC specialists and certified Amazon Partners, we found the platform well-suited for production video conferencing applications. This post explains what Amazon IVS Real-Time is and how it works, how it differs from CPaaS style APIs and from IVS Low-Latency Streaming, and how it compares to Amazon Chime SDK based on our hands-on experience.
Understanding Amazon IVS: Real-Time vs Low-Latency
Amazon IVS has two main video services, and it’s easy to confuse them.
- IVS Real-Time Streaming: WebRTC-based and designed for interactive, multi party experiences like video conferencing or live collaboration. It supports real time interaction.
- IVS Low-Latency Streaming: Designed for large scale viewing with limited interaction. It is optimized for low latency broadcasts.
Amazon IVS Real-Time is the correct solution for real time video calling applications. Amazon IVS Low-Latency is the separate broadcast path when the audience is mostly passive.
Core Amazon IVS Real-Time Components
IVS Real-Time uses the following building blocks for real time sessions. These are the components we worked with directly during the integration:
- Stage: The real time space where participants exchange audio and video.
- Stage sessions: The runtime instance of a stage where participants connect and media flows.
- Participant: A user connected to a stage with permissions to publish or subscribe.
- Ingest: Inputs like WHIP, RTMP or RTMPS, and the
amazon-ivs-web-broadcastlibrary.
IVS Real-Time also offers the following features and functionality to go along with these core components:
- Compositions: Server side mixing or rendering of stage media for downstream use.
- Participant recordings: Record individual publishers or a composite output to S3 for playback, review, or post processing.
- Chat: Managed live chat that can run alongside the live video experience.
Your backend creates stages, issues tokens, and manages ingest and session lifecycle. Your clients join the stage and publish or subscribe. This was the same operational shape we used in the client’s production flows.
Amazon IVS Real-Time as Part of AWS Ecosystem
Being a part of the larger ecosystem of AWS cloud computing services brings many benefits, from IAM authentication to S3 storage. Two of the most important in this scenario were ease of infrastructure integration and powerful console tools.
Fits into existing AWS infrastructure
It was very straightforward to integrate with the client’s existing AWS stack. We reused their auth, storage, and analytics wiring without introducing a separate operational model.
IVS Web Console Features
The IVS console has a clean layout, clear navigation, and a breakdown of key components that makes it easy to see what is running. We used the console a lot during QA and production validation. Its ability to subscribe to the stage session made debugging and testing easier, and it gave product, QA, and other stakeholders a simple way to monitor live video without needing engineering support.
Amazon IVS Real-Time vs CPaaS Style APIs
Most CPaaS platforms provide higher level APIs with more built in workflows. That can speed up integration, but it also means more wrappers and more opinionated control surfaces. In our migration from the Amazon Chime SDK, those wrappers were a real maintenance burden, especially because this product had to support multiple SFUs behind a shared adapter pattern. The more low level access to MediaStreamTrack objects made integration easier and reduced the amount of glue code we needed, which also simplified debugging.
Compared to the Amazon Chime SDK, IVS Real-Time is less prescriptive about the meeting model and more flexible about how you compose publishing and subscribing. In our Chime-based implementation, that extra abstraction made the adapter pattern heavier and introduced bugs that were hard to track down. With IVS, we still orchestrate more in our own code, but that trade-off has been easier to maintain in production.
Code Example: IVS Real-Time vs. Amazon Chime SDK Publishing Comparison
Here is a short illustration of the difference in web publishing flow:
IVS Real-Time (MediaStreamTrack based publishing):
const stream = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
const streamsToPublish = stream.getTracks().map(track => new LocalStageStream(track));
const strategy = { stageStreamsToPublish: () => streamsToPublish };Amazon Chime SDK (meeting session audioVideo pipeline):
await meetingSession.audioVideo.startVideoInput(videoTransformDevice);
meetingSession.audioVideo.start();
meetingSession.audioVideo.startLocalVideoTile();As you can see, the Amazon Chime SDK uses more abstraction around publishing, and this is without even showing the code for videoTransformDevice. We liked the IVS approach because it was clear what was happening and made it easier to keep control in our own code, which aligns with the broader point that IVS Real Time applies less abstraction and leaves more of the meeting experience in your application layer, while CPaaS platforms typically package more of that behavior into their APIs.
Flexible Ingest Options: WHIP, RTMP, and the Web Broadcast SDK
IVS Real-Time supports multiple inputs. These options are useful for many different use cases:
- WHIP for standards based WebRTC ingest
- RTMP or RTMPS for pro tools like OBS
amazon-ivs-web-broadcastfor WebRTC publishing in the browser
This means you can mix sources on the same stage. A typical pattern:
- A host publishes from OBS over RTMP
- Participants join from a React web client using the Web Broadcast SDK
- A moderator promotes guests to the stage live
This blend of WebRTC and RTMP inputs is convenient for streaming video in during testing and debugging. It also works well as a product feature for more polished live experiences.
Getting Started with Amazon IVS Real-Time: Example Repos from AWS
These example repos are helpful for getting started and also show interesting use cases and ideas for working with IVS:
- Minimal browser demo for joining a stage, publishing, and subscribing
- Web SDK sample with fuller stage controls and UI patterns
- React based sample showing how to wire stages and UI state
- Collaboration focused demo with multi participant layouts and controls
- Example of a virtual participant pipeline that joins a stage programmatically
Ready to Build with IVS Real-Time?
At WebRTC.ventures, we work with teams building interactive video applications and help turn early evaluations into production-ready systems. If you are exploring IVS Real Time for conferencing, collaboration, or hybrid live experiences, we can help you design the right architecture and ship quickly.
Not sure if Amazon IVS Real-Time is the right fit for your project? We offer technical assessments to evaluate your requirements and recommend the best platform and architecture for your use case.
Contact WebRTC.ventures today to talk through your use case and plan next steps.
