Normal

thumbnail_Arushi_.webp

Arushi_.webp

Arushi Gupta

large_api-video-blog-video-trends.png

medium_api-video-blog-video-trends.png

small_api-video-blog-video-trends.png

thumbnail_api-video-blog-video-trends.png

api-video-blog-video-trends.png

Video trends

When dealing with video content, choosing the right format (MKV or MP4) can make a significant difference in performance, compatibility, and user experience. For developers working on video applications, selecting between video containers is crucial as each format comes with its own strengths and trade-offs. 

&nbsp;

Two of the most popular container formats today are MKV and MP4. While both serve to encapsulate video, audio, subtitles, and other metadata, their differences can greatly affect how you manage video content.

## Understanding video containers
Before we move on to understand the difference between the two containers, MKV and MP4, let's see what containers are. 

### What is a video container?

A video container is essentially a digital wrapper that encapsulates different types of data: video, audio, subtitles, and metadata. [Containers](https://api.video/blog/product-updates/every-video-format-codec-and-container-explained/) allow developers to package multiple streams into a single file, making the management and playback of complex multimedia easier. Inside a container, video and audio data are compressed using codecs—algorithms that encode or decode the data for storage and playback.

### Container vs. codec

While containers hold the video, audio, and other elements, codecs manage how these elements are compressed and decompressed. For instance, [H.264, H.265](https://api.video/blog/video-trends/H264-vs-H265/) and AV1 are popular video codecs, whereas AAC is a common audio codec. The container (like MKV or MP4) and the codecs work together, but they serve different purposes—containers organize data, while [codecs compress](https://api.video/blog/video-trends/guide-to-video-encoding-video-codec/) and decompress it.

## MKV vs. MP4: What do they mean?
Now, let's dive into the differences between the two container formats.

### What is MKV?

MKV, short for Matroska Video, is an open-source container format that was developed with flexibility and extensibility in mind. Unlike proprietary formats, MKV allows developers to freely use it without licensing fees, making it popular in open-source projects and media preservation.

### Key features of MKV

- **Supports any codec**: MKV can handle virtually any video, audio, and subtitle codec, giving it unparalleled flexibility.
- **Multiple audio and subtitle tracks**: It supports an unlimited number of audio and subtitle tracks, making it ideal for multilingual content and accessibility.
- **Handles corrupt files**: MKV is robust in handling errors; even if part of the file gets corrupted, it can still play the rest of the video.
- **Advanced streaming features**: MKV allows for streaming capabilities with features like chapters, tagging, and support for multiple tracks.

### When to use MKV

MKV excels in scenarios requiring media preservation, lossless video quality, or handling complex content like Blu-ray rips with multiple audio/subtitle tracks. Developers working with media archives or those who need advanced chapter navigation and rich metadata should lean toward MKV.

&nbsp;

Additionally, when **using streaming software like [OBS](https://api.video/blog/no-code/start-and-record-a-live-stream-with-obs/) or Wirecast** to record live streams for future use (such as post-production editing), selecting the MKV format offers significant advantages. For instance, MKV allows you to record multiple audio tracks, which can be extremely useful in editing. Imagine you’re streaming a podcast with multiple guests speaking at the same time; with MKV, you can edit each person’s voice separately. Moreover, if you used copyrighted music during the stream but want to remove it for future use, MKV makes this possible by isolating audio tracks.

&nbsp;

Another major benefit is **file corruption prevention**. If you're exporting a large project and the render fails halfway through, MKV allows you to keep the portion that was successfully rendered. This means you only need to re-render the part that failed, saving time and avoiding the need to restart the entire process.

### What is MP4?

MP4, short for MPEG-4 Part 14, is one of the most widely adopted video container formats, developed based on the QuickTime File Format. It is the industry-standard container for video, particularly for web streaming and distribution due to its widespread support across devices, platforms, and browsers.

### Key features of MP4

- **Broad compatibility**: MP4 files can be played on virtually any device or media player, making it the go-to format for developers focused on user accessibility.
- **Efficient compression**: MP4 supports advanced compression techniques, such as H.264 for video and AAC for audio which leads to smaller file sizes without sacrificing video quality, ideal for web streaming.
- **Metadata and subtitles**: While it supports subtitles and basic metadata, MP4 lacks the advanced subtitle features that MKV offers.

### When to Use MP4

MP4 is ideal for use cases where compatibility and efficiency are priorities, such as online streaming, mobile device playback, and video distribution across multiple platforms. Developers working on web apps, APIs, and mobile applications will find MP4’s ease of use and widespread support advantageous.

## Technical comparison of MKV vs. MP4
Let's see how MKV and MP4 are different from each other and where they can be used. 

### 1. Codec compatibility

- **MKV**: Supports almost any codec, making it flexible for a wide range of video/audio formats.
- **MP4**: Optimized for a smaller, standardized set of codecs like H.264 and H.265 for video and AAC for audio, ensuring compatibility across platforms but limiting flexibility.

### 2. File size & compression

- **MKV**: Larger file sizes due to its focus on preserving quality, especially with high-bitrate video and audio.
- **MP4**: Smaller file sizes due to efficient compression, which makes it ideal for streaming and mobile device storage.

### 3. Subtitles and multi-track support

- **MKV**: Supports multiple audio and subtitle tracks, offering more options for multilingual content and closed captions.
- **MP4**: Limited to fewer tracks, making it less suitable for complex media with multiple audio or subtitle options.

### 4. Editing and metadata handling

- **MKV**: Rich metadata support, including chapters and tags, making it better for detailed video organization and content navigation.
- **MP4**: Offers basic metadata but lacks advanced options like chapter breaks.

### 5. Error resilience

- **MKV**: Can recover from file corruption and still play partial content, making it more resilient in the face of errors.
- **MP4**: Struggles with file corruption, often making the entire video unplayable.

## When does the need to convert MKV to MP4 arise?

MKV is a powerful container format, supporting multiple audio tracks, subtitles, and codecs, making it popular for high-quality video content like Blu-ray rips. However, it isn't always the most compatible option. Many platforms, mobile devices, web browsers and softwares have limited or no support for MKV files, whereas [MP4](https://api.video/what-is/mp4/) is widely accepted due to its standardized codecs (H.264 for video, AAC for audio). Converting MKV to MP4 ensures smooth playback across devices, especially for streaming, mobile use, or uploading content to video platforms.

### Tools to convert MKV to MP4

There are various tools available to convert MKV to MP4:

1. **HandBrake**: A free, open-source video converter that offers advanced settings to fine-tune the conversion.
2. **FFmpeg**: A powerful command-line tool for developers that can handle a wide range of conversions, including MKV to MP4.
3. **VLC Media Player**: More than just a media player, VLC can also convert files between different formats, including MKV to MP4.
4. **Online Converters**: Services like CloudConvert allow you to convert MKV to MP4 without installing any software, though file size limits may apply.

### Points to keep in mind when you convert MKV to MP4

- **File size**: MP4 files are typically smaller due to better compression, but be mindful of any loss in quality during the conversion process.
- **Metadata and subtitles**: MKV files often include multiple subtitle tracks or embedded metadata (like chapters) that may not be fully supported in MP4. If these are important, make sure your converter preserves them, or consider extracting them separately.
- **Codec compatibility**: While MP4 uses standardized codecs like H.264, make sure your converted file is optimized for your target platform.

&nbsp;

Choosing between MKV and MP4 ultimately depends on your project’s specific requirements. MKV shines in scenarios where quality and flexibility are paramount, such as media preservation and advanced video editing. On the other hand, MP4 is the industry standard for developers focused on cross-platform compatibility, efficient streaming, and mobile delivery. Understanding the strengths and limitations of each format will help you make informed decisions about which container best suits your video needs.

&nbsp;

_api.video enables you to quickly and securely deliver on-demand and live-stream videos directly from your website, software, or app. [Sign-up](https://dashboard.api.video/register) for a free sandbox account to try out api.video’s video API, or talk to our team to get a demo._

MKV vs. MP4: Understanding the differences

small_MKV vs MP4.png

thumbnail_MKV vs MP4.png

MKV-vs-MP4.png

api-video-blog-product-updates.png

Product updates

[Video encoding](https://api.video/what-is/video-encoding/) is the process of exporting digital video into a format and specification suitable for playback by a user. 

Each video file contains two elements: 
* Codecs, or “compression-decompression“ algorithms which compress the video
* Formats, the type of file the data is compressed to. 

Imagine a shipping container filled with packages of many types. In this analogy the shipping container is the format, and the codec is the tool that creates the packages and places them in the container.

## Video Codecs


videocontainer-format.png

Video codecs used today include H.264, HEVC, VP9, and AV1. Common formats includes MKV, AVCHD, MP4, and WebM. 
There are pros and cons to each video codec and file format. There is no silver bullet when it comes to streaming content on the web. Certain video codecs and video formats are open source, meaning the source code is available to the user, who is given the rights to study, change, and distribute software to anyone for any purpose. VP9 and AV1 are both open source codecs types. MKV and WebM are also both open source, developed by nonprofit organizations and allowed to be used without a license.

## Video Formats

Video formats are often equated to a file’s extension, for example the .mp4 in Video. mp4. Video formats are much more than that and include a whole package of files, including a files video stream, the audio stream, and any metadata included with the file. All of the data put together, both of the streams and the metadata, is read by a video player to stream video content for playback. A file’s video stream includes the data necessary for motion video playback, while the audio stream includes any data related to sound. Metadata is any data outside of audio and sound, including bitrate, resolution, subtitles, device type, and date of creation.

## Bitrate
Bitrate or bit rate, is the rate at which bits are processed or computed over time. The higher the bitrate, the more data there is, which generally means a higher quality video file. When choosing a bitrate it is important to consider the device your videos will be played on. High bitrate file streams need lots of processing power to encode, and a fast internet connection to download for playback. If you’re having trouble choosing the right bitrate, file format, video codec, and video resolution, maybe it’s time to consider api.video.

With the api.video you can easily and quickly transcode video for your audience no matter the quality, format or bitrate. We wrote this article to help you sort through the hundreds of codecs and formats, and help you take the guesswork out of streaming video content on your site, application, or platform.

## The Most Popular Codec: H.264


h-264.jpg

First let’s talk about H.264, also known as AVC. 

H.264 is the most widely used video codec. Sure, the H.264 codec may be a bit outdated by now, but this type of compression technology is present everywhere, with decoders available for pretty much every platform and mobile device. H.264 likely won’t be the standard for long. 
HEVC, short for High Efficiency Video Coding, or H.265 is slowly becoming ubiquitous thanks to the proliferation of 4K content. If AVC or H.264 was the codec of 1080p content, then HEVC and H.265 is the codec for the 4K era. H.265 compresseses videos far more efficiently (hence the “high efficiency”) when compared to H.264. This means H.265 4K content that is easier to stream and at a higher quality than 4K content compressed using H.264.

## New Codecs: H.265 and VP9


h265.jpeg

H.265 is a licensed codec, meaning you have to pay to use it. Its main competitor, VP9 is a royalty free and open source codec developed by Google. This means that anyone can use the codec to compress their videos license free. Generally, VP9 produces more consistent or more reliable streams, whereas H.265 (HEVC) produces videos of higher quality. 

The differences between the two codecs are due to the strengths and weaknesses of their compression algorithms. VP9 was developed to produce videos with a smaller file size and therefore ones that are easier to stream. H.265 compresses videos using a large variety of processing techniques which ultimately create a compressed video that retains a very high level of detail.

In addition to VP9, there is another open source codec still under development called AV1. AOMedia Video 1 (AV1) is an open source, royalty-free video coding format specifically designed for streaming video content over the internet. AV1 was developed to succeed the VP9 codec and compete directly with HEVC codec on both video quality and file size. AV1 is still a highly experimental codec, but is supported by Firefox, Google Chrome, VLC media player, FFmpeg among others.

## The Most Popular Video Formats
We mentioned this before, but formats are the entire set of storage rules that package a video file’s container, codecs, and metadata. File formats are used so that a variety of devices, platforms, and players can process and playback any number of codecs. Formats are developed to improve image quality, decrease file sizes, allow for universal playback on a variety of devices, and provide special features such as subtitles. Since there are new formats getting developed every day it’s difficult to cover each and everyone. Instead, we’re going to focus on video formats used specifically for online distribution or content streaming.

The most popular video format is MP4, also known as MPEG 4. MP4 is a multimedia container for video, audio, and data, including things like subtitles and still images. Make sure you don’t confuse MPEG 4 and MPEG 4 Audio. MPEG 4 has the file extension .MP4, while MPEG 4 Audio has the file extension .M4A and can only contain audio files. So, why exactly is MP4 so popular? Well it mainly has to do with how ubiquitous it is across a range of devices. Both mobile and desktop devices can playback MP4 video files, so it makes sense that it would be used by most content producers.

## Playback Techniques for Video and Livestreaming
MP4 files are played at a constant bit rate (CBR), meaning the quality of your video stream will remain at the same bitrate no matter the variance in your internet bandwidth. There are other file formats that support adaptive bitrate (ABR), which will adapt the quality of your stream to match the internet speed of your player. One of the most popular formats that supports ABR is HLS..

HLS or HTTP [Live Streaming](https://api.video/product/live-stream/) use adaptive bitrate streaming techniques to enable high quality streaming with small HTTP-based file segments. The key to this format’s popularity is the use of HTTP. HTTP is the universal language protocol for the internet, and allows for reduced infrastructure costs, greater reach, and simple HTML5 player implementation. Another great feature for the HLS format is the M3U8 file descriptor. This file allows the client or device to automatically select the best quality stream at any time, to prevent playback buffering regardless of bandwidth or CPU power.

Now that you know how file formats and codecs work it’s time to get streaming. Visit [this page](https://dashboard.api.video/register) to create a free account, so that you can quickly and easily integrate streaming video content into your application, site, or workflow. Our API can accept pretty much any type of broadcast (even 4K native content), and can quickly transcode and adapt the stream for any type of network, including EDGE. No matter the screen, size, quality, or bitrate, api.video can manage it for you. Our web service is built to answer the most demanding video and streaming needs. If you want to learn more check out our website at [api.video](https://api.video/) or join our [community forum](https://community.api.video/). Good luck and happy streaming!

## You May Also Like...
If you liked this article, you may also be interested in:

* [Create a Live Stream](https://api.video/blog/tutorials/live-stream-tutorial/) - Create your first live stream!
* [Videostreaming with a Raspberry Pi](https://api.video/blog/tutorials/video-streaming-with-a-raspberry-pi/) - Now that you've got a live stream working, have some fun adding one using a Raspberry Pi. 
* [Video Upload](https://api.video/blog/tutorials/video-upload-tutorial/) - Upload your first video. 

Every video format, codec, and container explained

large_FormatsCodecsContainers.png

medium_FormatsCodecsContainers.png

small_FormatsCodecsContainers.png

thumbnail_FormatsCodecsContainers.png

FormatsCodecsContainers.png

Before we dive in, this beginner's manual will contain some general purpose information and then some information that's specific to Mac users and Python users. 
Ffmpeg is an amazing set of tools, but it's also available in a variety of flavors. If the sections for Mac and then Python don't apply to you, you may need to supplement this beginner's primer with other online content.

The guide is to help ease you into using ffmpeg by explaining some basics about how scripts are structured, provide resources that will help you, walk you through some popular commands, and describe some common pitfalls you might encounter.

## What is FFmpeg?
If you work with video, you've heard of [ffmpeg](https://api.video/what-is/ffmpeg). You may even have heard of it before you know exactly what it does, but it's used everywhere in video projects. Ffmpeg stands for Fast Forward MPEG. It's an opensource software project for working with audio and video. It is command-line based and lets you handle video, audio, multimedia files, and streams. You'll find it used for transcoding, simple editing, video scaling, video post-production effects and standards compliance. 


## What is the FFmpeg Project? 

The ffmpeg project has four major applications: 
* FFmpeg - command-line interface that lets you work with your video, audio, or other media.
* FFplay - a media player.
* FFserver - a streaming media web server.
* FFprobe - a stream analysis tool. 

In addition to there being four major applications, there's tons of libraries for each application that help you accomplish tasks in different languages and environments. We can't cover everything here, so we'll focus on ffmpeg for now, and some of the basics you'll want in order to start understanding this tool. 


## Getting Started 

Ffmpeg CLI can be a pain to install. There's an easy way to install with homebrew though, and we detail that in the start of the [Live Stream to the Browser with FFMPEG CLI and Python](https://api.video/blog/tutorials/live-stream-to-the-browser-with-ffmpeg-cli-and-python). 

After you have it installed, test it works by checking the version: 

```ffmpeg -version```

## FFMPEG Command Structure

Commands in ffmpeg have two basic structures. (We'll put the commands we use for examples again in the Popular FFMPEG Commands section.) One is like the command you just ran in the Getting Started section, where you're trying to find something out about ffmpeg itself. And the other more common one has this structure: 

```ffmpeg input output```

Here's an example command to show you what this structure might look like in action: 

```ffmpeg -i video1.avi -s 320x240 -vcodec msmpeg4v2 video2.avi```

Here you're saying: Let's use the ffmpeg CLI (ffmpeg). There's nothing you need to know about the file's format, but the input file (-i) is video1.avi. Next, you start describing the output. For the output you want to have a file that has a frame size (-s) of 320x240 pixels. You want to transcode using the video codec msmpeg4v2 (-vcodec msmpeg4v2) and output to a file that will be called video2.avi.

ffmpeg commands will usually follow this structure. Written generally, it looks like: 

```ffmpeg [format details for the input][input file or device] [format details for the output][output file or device]```

The structure is important to get right - a common mistake is to put format details for the input after the **-i** which won't work. What's meant by format details is things like what file format or framework you want to use, the frame rate, screen size, and any other flags you may find that you want to try. After the **-i** usually all you add for input is the devices or the file you'll be using. 

## Popular FFMPEG Commands
These are some useful commands you can try with your video projects. There's lots more out there, these are just to help you get started.

### Get File Info
```ffmpeg -i video.flv ```

This command lets you get information about a video file. Note how it follows the structure we talked about - you put the file you want details about after the -i. You don't have to worry about input/output for this command. 

### Play a Video from the Terminal 
```ffplay video.mp4```

This is a great command because you can test your work. After you edit a file in some way, you can play the new file you create in the terminal to see if everything went okay.

### Split a Video Into Images
```ffmpeg -i video.flv image%d.jpg```

In this command, you split a video into individual images. The original copy of the file will be retained, and then it will also be split into every single frame. Every image will be named using the pattern you specify with the part of the script ```image%d.jpg```. 

### Convert Images Into a Video
```ffmpeg -i image%d.jpg output.mp4```

In this command you put the name of the last image from your sequence of images in place of ```image%d.jpg```. You can start from a lower number to create a video with less images out of the total number you have if you like. Photos need to be named uniformly to be merged, for example image3.jpg, image2.jpg, image1.jpg.

### Change Container Formats Without Re-Encoding
```ffmpeg -i input.mp4 -c:v copy -c:a copy output.mov```

Some tools require a specific video format and re-encoding can take awhile. In certain situations, you can save yourself time by changing the container format without doing any re-encoding. Not all containers are compatible with all video types, so you may need to try out a few things before finding something that works. This script is the basic command. You're saying for input (-i) take the file input.mp4 and its video codec (-c:v) and copy it. Then take input.mp4's audio codec (-c:a) and copy it. Place all these changes into a new file called output.mov. This file has all the same codecs, but it now has the container .mov.

### Convert a Video Into an Animated GIF
```ffmpeg -i video.flv animated.gif```

Turn a video into a gif! The command for this one is pretty simple too.

### Live Stream to api.video From Your Mac's Camera
```ffmpeg -f avfoundation -framerate 25 -i "0:0" -f flv rtmp://broadcast.api.video/s/streamKeyHere```

We have a whole tutorial using this command here - [Live Stream to the Browser with FFMPEG CLI and Python](https://api.video/blog/tutorials/live-stream-to-the-browser-with-ffmpeg-cli-and-python). 

If you're wondering what the "0:0" means we explain that in the tutorial! 

### Edit a File Without Re-Encoding
```ffmpeg -ss 00:00:05 -i input.mp4 -t 00:00:10 -c:v copy -c:a copy excerpt.mp4```

Use this command to make simple edits to your video without re-encoding. 

In this command you are saying use the ffmpeg CLI (ffmpeg) and seek forward five seconds into the video clip (--s 00:00:05) called input.mp4. From there, move forward 10 seconds (-t 00:00:10) and extract the video from the start to endpoint. If you don't put the endpoint with the -t flag, then the video before the start point is cut off, and the rest of the video is included. The rest of the script looks familiar by now - it's just like the changing the container script. You're going to copy the video and audio codecs from the input video to your video excerpt, then output your new video into a file called excerpt.mp4. You can do light editing this way. 

### Crop a Video
```ffmpeg -i input.mp4 -filter:v "crop=w:h:x:y" output.mp4```

Crop a video to a size you want using the crop filter. The filter part of the script is ```-filter:v "crop=w:h:x:y"```. The x and y specifies the coordinate of the rectangle that you want to crop from the source video, and then w and h represent the height and width of the rectangle you will crop. The outcome of the crop lowers the quality of your video, so use this sparingly or when you don't need amazing quality at the end.

### Change Playback Speed
```ffmpeg -i video.mpg -vf "setpts=0.5*PTS" highspeed.mpg```

PTS stands for presentation timestamp. This is the time at which the frames in your video should be presented by default. When you multiply by a fraction, you're basically dividing the timestamp, so it's going to run through the video more slowly. If you multiply by a number, it's going to go faster. In this use of the script, the output file will run at half the speed of the original. 



startrek.gif

### Convert Video to Audio 
```ffmpeg -i input.mp4 -vn output.mp3```

If you just wanted the audio from a video file, you can use this command to create an audio only file. 

### Change the Volume on an Audio File
```fffmpeg -i input.mp3 -af 'volume=0.5' output.mp3```




volume.gif

Take an audio file, then cut the volume in half and output it to a new file. Similar to the playback script, you're multiplying the original volume by a value to get the new value for the volume.

### Change Resolution for Video File
```ffmpeg -i input.mp4 -filter:v scale=1280:720 -c:a copy output.mp4```

You can change the video resolution for a video file with this script. Use a filter on the video with -filter:v and then choose your resolution, in this case scale=1280:720. Then you copy the audio codec because you aren't changing it, and output your changes to the new file output.mp4. 

These are just a few interesting commands you can do with ffmpeg!

We hope they give you a sense of what's possible with the tool, and make you feel more confident about building and tweaking your own scripts. Let us know in [our community forum](https://community.api.video/). 
You can create a [free account](https://dashboard.api.video/register) to try it out now.



FFMPEG for beginners: processing, converting and streaming

large_ffmpegforbeginners.jpg

medium_ffmpegforbeginners.jpg

small_ffmpegforbeginners.jpg

thumbnail_ffmpegforbeginners.jpg

ffmpegforbeginners.jpg

FFMPEG for beginners: scripts for processing, converting, and streaming video

api-video-blog-tutorials.png

Tutorials

Metadata, within the context of api.video, is like a Swiss Army knife - it gives you a simple set of tools to solve countless complex problems. It can help you integrate video-on-demand (VOD) into your platform or application, all the while supporting and even enhancing the way you build your product.

## What is metadata?

Metadata enables you to add an extra layer of data to the videos that you or your users upload. You can define an array of custom key-value pairs and use the values to enhance your application or website. Each video can have multiple key-value pairs in a `metadata` array, and you can use them to filter for specific content when listing videos, and to integrate video content into your app or website. You can add, edit, or remove metadata from video using both the [api.video API](https://docs.api.video/vod/tags-metadata) and the [Dashboard](https://dashboard.api.video/overview).

&nbsp;

Now, let’s dive into some use cases where video metadata can be a game changer!

## Video metadata for e-learning use cases

In this use case, we will look at how using metadata can help you solve some common problems that you might encounter when creating an e-learning platform.

&nbsp;

Let’s say you want to offer video lessons for your users, and that you want to enable teachers to create courses (a series of lessons) on different topics, and varying levels of difficulty. For the sake of this example, let’s propose these courses:

&nbsp;

- Basic Node.js - 5 lessons
- Advanced Node.js - 10 lessons
- Advanced Sushi Making - 8 lessons
&nbsp;

These courses already imply a very large amount of background information that you’ll need to handle. Think about questions like:

&nbsp;

- How do you know the order of lessons?
- What if you want to show all lessons on a certain difficulty level, regardless of the course?
- What if multiple teachers create lessons in the same course and you want to give them extra payments based on how popular their lessons are?
- What if you want to enable students to rate lessons on a scale of 1 to 10?
- Better yet, what if you want to enable teachers to grade video-based homework for your students using your platform?

&nbsp;

All of this fits neatly into `metadata`. Here’s an example set of key-value pairs that could belong to any lesson’s video:

&nbsp;


Now let’s see how a student’s own video submission can be enhanced with `metadata` by giving them a few fields that they can fill out:

&nbsp;

### How to add video metadata to your e-learning solution

Let’s dive into the endpoints can help you solve the above problems.

&nbsp;

- First, you [create a video object](https://docs.api.video/reference/api/Videos#create-a-video-object). This is the step where you can define the `metadata` attributes for each video object. Then, you [upload a video](https://docs.api.video/reference/api/Videos#upload-a-video) into that video container object.
- You can surface some of the relevant fields for your teachers who would upload their videos: `course_id`, `lesson_number`, `difficulty_level`, and so on.
- For students, you can surface the `uploader_notes` field on your platform.
- For listing and filtering by `metadata` on your frontend, use the [list all videos](https://docs.api.video/reference/api/Videos#list-all-video-objects) endpoint. You can use the `metadata` keys and values in your request as query parameters to filter specific content. For example you can list all homeworks with this simple request query:

- For video ratings, use the [update a video](https://docs.api.video/reference/api/Videos#update-a-video-object) endpoint. Make sure you track the different users who already rated a specific video based on their user ID and the `videoID`. Store their ratings and simply calculate an average rating, then use that result to edit the video metadata in the `metadata.value` field where `metadata.key` is `rating`.
- For grading homeworks, you can also use the [update a video](https://docs.api.video/reference/api/Videos#update-a-video-object) endpoint. Just update the `metadata.value` field where `metadata.key` is `grade`. You can make excellent use of the `video.encoding.quality.completed` webhook to create notifications for teachers whenever a video with `metadata.key = type` and `metadata.value = homework` is uploaded. Learn more about [webhooks in the developer documentation](https://docs.api.video/reference/create-and-manage-webhooks)!

&nbsp;

_Remember, you can use any of these key-value pairs to list videos - use them to create a nice filtering & ordering functionality on your platform for a better user experience._

## Video metadata for sports-themed video sharing use case

In this use case, we will look at how metadata can help you offer a platform where people can share their adventures through videos. You can also make things a bit more exciting by offering them the functionality to display their videos’ locations on a map. 

&nbsp;

For the sake of this example, we will enable users to vote with 👍 / 👎 on specific videos, and store the results in `metadata` for accurate tracking. 

&nbsp;

In such a case, when users upload a video, you can use the `metadata` field to define key-value pairs like these:

### How to add video metadata to your video sharing platform

Now, let's see the endpoints that can help you solve the above problem.

&nbsp;

- The first few steps are the same as with the e-learning use case:
    - First, you **[create a video object](https://docs.api.video/reference/api/Videos#create-a-video-object)** and define the `metadata` attributes. Then, you **[upload a video](https://docs.api.video/reference/api/Videos#upload-a-video)** into that video container object.
- For listing and filtering by `metadata` on your frontend, use the [**list all videos**](https://docs.api.video/reference/api/Videos#list-all-video-objects) endpoint. Here’s an example request query that filters the mountain cycling videos:

- You can use open-source tools to grab the geolocation tags from the uploaded video files. You can then feed these coordinates to any map API, and display them per user. There’s a host of interesting directions that you can take with this! You can even make this a full-fledged feature by accepting trek logs, or GPX files from your users and feeding them to a map API to display routes instead of single points of interest.
- For the 👍 / 👎 feature, you can implement a like & dislike button on your frontend, and store the number of likes and dislikes to calculate an overall score for each video.
- Make sure you track users who push these buttons to avoid duplicate votes!
- Read the value of `score` through the [**Retrieve video object**](https://docs.api.video/reference/api/Videos#retrieve-a-video-object) or [**List all video objects**](https://docs.api.video/reference/api/Videos#list-all-video-objects) endpoints when you load the videos on your frontend.
- When you update a score after a user voted, use the [**update a video**](https://docs.api.video/reference/api/Videos#update-a-video-object) endpoint to update the `metadata.value` field where `metadata.key` is `score`.

&nbsp;

There you go, that's it!

Appreciating the significance of video metadata is important when it comes to online videos. This essential element acts as the foundation for organizing video content, enhancing searchability, and customizing video experiences. Whether you're someone building an app or a content creator or a viewer, the use of metadata is sure to unlock fresh routes for engagement and discovery.

&nbsp;

Dive into the [developer documentation](https://docs.api.video/) to understand more.

&nbsp;

To start using api.video and see how all this works, [sign up](https://dashboard.api.video/register) for a free sandbox account now!

Video Metadata: Exploring advanced use cases and their benefits

large_Metadata.png

medium_Metadata.png

small_Metadata.png

thumbnail_Metadata.png

Metadata.png

Organization of your videos helps you deliver the correct videos to the correct page.

If you look closely in our API, we also offer a metadata tag with key:value pairs to be used as an additional organizational tool. In many ways, metadata and tags are functionally similar.

However, we also support the concept of dynamic metadata. Dynamic metadata is not directly related to the video - but is more related to how the video has been consumed. The values of dynamic metadata are variable and are added during playback, allowing you to further segment your audience analytics.


## Analytics

By default the api.video analytics engine can report both video stats and session specific data. There is a [tutorial](https://api.video/blog/tutorials/video-analytics-a-primer/) describing how to use the analytics endpoints.

Stats: Each video can be parsed to quantify views, time/date of view, browser and location, and more. You can read more on the [Video Analytics](https://docs.api.video/analytics/overview) endpoint.  
[Session]: Each video session has a unique ID.  For each session, several events are recorded in the player. Currently, this list is: ```ready, play, pause, resume, seek.backward, seek.forward, end```. 

By default, you gain a lot of insight as to how your audience views and consumes your video. We can use dynamic metadata to segment your audiences for deeper insights.

## Segmenting your video audience

Imagine that you have two segments of users on your website: dog lovers and cat lovers. You want to know which videos are more appreciated by each segment of your population.

For these videos you can add a dynamic metadata key:value where the value changes depending on the viewer.  For example:

```
[
{"key" : "dogcat", "value", "__dogcat__"}
]
```

The double underscore before and after the value tells the API that this is a dynamic attribute, and the value of the dogcat attribute will be measured on each session of the video.

## Using the segmentation

Now that you have added the dog/cat segmentation to the video, each view of the video can be segmented.  To do this, we append a url parameter.

For example, dog lovers would receive this video:

https://embed.api.video/vod/vi2WbMm8rUWIQSzMS53aculW?metadata[dogcat]=dog



and cat lovers would receive this video:

https://embed.api.video/vod/vi2WbMm8rUWIQSzMS53aculW?metadata[dogcat]=cat

The video is my dog Malla, who is named after Chewbacca’s wife (from the infamous Star Wars Holiday Special). You have to admit, she sounds a bit like a Wookie.

These urls can be built dynamically based on user profiles on the website. When the video is watched, this metadata is added to the analytics session. Each video play will mark the viewer as either a dog lover or a cat lover.

Now, since the viewer's cat/dog preference is added to the video statistics, you can learn how your two audiences interact with each video on your site, and which videos are preferred by dog or cat people.

Using the video stats endpoint, I have found that my team is:
* 50% dog
* 37.5% cat

and, well:
* 12.5% "know-it-all":

```
						"key": "dogcat",
						"value": "dog"

						"key": "dogcat",
						"value": "dog"

						"key": "dogcat",
						"value": "cat"

						"key": "dogcat",
						"value": "cat"

						"key": "dogcat",
						"value": "dog"

						"key": "dogcat",
						"value": "cat"

						"key": "dogcat",
						"value": "dog"
						
						"key":"dogcat",
						"value":"rhinoceros"

```

If you have unique IDs for each user, you could also track video watching per user (how often they view each video, or if they are watching the entire video).  This could be very useful for online training compliance, classes, or even to check on credential sharing.  The possibilities are endless!

### Conclusion

Using dynamic metadata and url parameters, you can segment your video analytics into different populations, and better understand how your users are using your videos. How are you using dynamic metadata in your app's videos? Leave a note on our [community forum](https://community.api.video). If you don't have an api.video account yet, you can create one in just a few moments by following [this link](https://dashboard.api.video/register). Happy building! 




Use variables in the metadata tag to segment your audience

dogcat.jpg

Dynamic metadata: use variables in the metadata tag to segment your audience

This script is part of a collection of scripts from Hervé Pita that help with bulk video uploads. Everything is available in our [Helpful PHP Scripts](https://github.com/apivideo/helpful-scripts) repository on Github. In each part of this series, we'll walk through how to set up one of the scripts. What you'll find includes:

* [Ingest Videos from Google Drive](https://api.video/blog/tutorials/helpful-php-scripts-upload-videos-from-google-drive-to-api-video/) - You can transfer all your videos from a folder in Google Drive to your api.video account with this CLI script.
* [Ingest Videos from an FTP Server](https://api.video/blog/tutorials/helpful-php-scripts-pt-2-upload-videos-from-an-ftp-server/) - Transfer all your videos from the FTP server of your choice to your api.video account.
* [Export All Your Video Data to .csv](https://api.video/blog/tutorials/helpful-php-scripts-pt-3-export-all-your-video-details-to-a-csv/) - With this script you can grab details about each video in your api.video account and gather it in one .csv spreadsheet.
* [Update Metadata for api.video Videos Using CSV](https://api.video/blog/tutorials/helpful-php-scripts-pt-4-update-metadata-for-api-video-videos-using-csv/) - You can update your metadata in bulk with this script.
* [Update Video Settings in Bulk Without a CSV File](https://api.video/blog/tutorials/helpful-php-scripts-pt-5-bulk-update-without-a-csv-file/) - Update videos to all be public or private or offer an mp4 download or disable an mp4 download.

Today we're going to learn how to use the script for updating custom you choose using a CSV file. This will allow you to make updates in bulk, so be careful! With great power comes great responsibility. 

## Prerequisities

For this project you'll need:
* PHP 5.4 or greater with the command-line interface (CLI) and JSON extension installed
* The [Composer](https://getcomposer.org) dependency management tool (or another way to manage your dependency management). See the Composer website for installation options.
* A GitHub account
* An api.video [account](https://dashboard.api.video/)
* Your API key for either production or sandbox (the script will update video metadata based on your API key - if you choose production your production videos are updated, if you choose sandbox, your sandbox videos are updated)

## Installation

1. Navigate to the Helpful PHP Scripts repository.
2. Click **Code** and from the ddrop-down click **Download ZIP**. (You can also install from the CLI if you prefer.)
3. Put the contents of your new .zip file in a folder you want to work from.
4. Navigate to the folder containing the contents of your zip file in the terminal.
5. In the terminal, type: ```composer require api-video/php-sdk```

## Prepare Your .csv File 
You're going to need a .csv file containing the information you want to update. The script is designed to be flexible, so you can include any three fields for the columns after the first column, which you must label **id**. In this column you place your videoId. The script can handle legacy video IDs beginning 'vi' or the new ones beginning 'video_'. The next three columns can be the parameters you decide on. In this walkthrough, I picked **title**, **description**, and **public**. I can use these to set the title of my video, provide a description of the video, and choose whether it will be public or private. 

Make sure the top of your file has the field headings, and they correspond to exactly how they are presented in the api.video API. If you need a refresher, check out [docs.api.video](https://docs.api.video/reference) to make sure you're setting up your file correctly. 

Set up all the files you want to edit, one row per video file. Then save your file as **.csv** or **.tsv**. Hervé's script will accept either ending, but be aware that you MUST set up your file so that the separator is a tab, or the script won't run. The easiest way to do this is to save it as **.tsv**.

After you set up your file, place it in the same folder that you run your script from. The script will expect to be able to retrieve your file from this location. 

NOTE: Double and triple check your rows! You don't want to accidentally upload mistake updates if you don't have to. 

## Try the Script

1. In the terminal, type ```php update_metadata.php``` 
2. You're asked what environment you want to use, prod or sandbox. For our walkthrough, choose **prod**.
3. Provide your API key when prompted. You can get this by navigating to [your dashboard](https://dashboard.api.video/) and copying the appropriate key.
4. You're asked to provide the name of the file you want to use. Provide the full name of the file, including the ending. 
5. You're asked if you're ready to have your file checked to make sure it has the right headings. Put **y**.
6. If all goes well, the metadata you provided is added! Go check your videos to see if they list the information you wanted to provide. 

Thanks for checking out the latest installment of helpful PHP scripts for bulk video uploads! 

PHP Scripts: Update Metadata for api.video Videos Using CSV

pexels-negative-space-34600.jpg

Helpful PHP Scripts Pt 4: Update Metadata for api.video Videos Using CSV

Having a reliable way to filter videos based on specific criteria is a must for most video apps.

For example:
* An e-learning site may want to display different videos to each user, depending on their class list.
* An animal adoption center may choose to display only videos of cats to cat-lovers.
* A site that allows users to upload videos may not want those videos displayed until they get approved by an admin. 
* A fan site may have different levels of membership, where each level gets granted access to additional videos.

Generally, implementing something like this involves much work, takes lots of development time, clutters up your codebase, and can easily lead to bugs and data loss.
It is true that api.video is an API for video. However, we are also an API **for developers**! That is why we decided to include a video tagging and filtering system right into our API.

**Tags to the Rescue!**
api.video’s tagging feature allows you to add tags to each video. Tags can be applied to a video when it is initially created and updated at any point after that.

You can manage your tags using api.video’s web interface as well as directly through the API.

The web interface is useful for learning about tags and for managing them if you have a small number of videos.

If you are dealing with a large number of videos or need tags to be assigned automatically, then you should use the API. Don’t worry. It’s a piece of cake!

The easiest way to understand tags is to begin using them, so let’s get started.

Let’s begin with the web UI and then move on to the API.

**Tagging Videos (Web UI)**
Visit your video [dashboard](https://dashboard.api.video/). If you do not yet have an account, create one when prompted.

Once you are on your dashboard, you can see your video thumbnails with your most recent uploads first. 

My dash looks like this:


Let’s say I’m the founder and lead developer of petvids.com, the hottest new start-up out of Silicon Valley. I want to provide pet-lovers with the option of choosing whether they would rather see dog videos or cat videos.

Using the web UI, I can easily click on each video, select “edit video” in the “actions” section, and add the appropriate tag.

I can demonstrate that the tags are working using the web UI.

This is what I get if I filter for videos with the tag “cat”:

I think you get the basic idea. Let’s look at how to implement this in the backend of your app using our API.

**API and Additional Queries**
Using our API, you can request a list of all videos with the /videos endpoint:

and if you want to see the videos that you uploaded in “sandbox” mode:

Make sure you have authenticated and are making the request with your “auth” token in the header. More on that [here](https://api.video/blog/tutorials/authentication-tutorial/).

You can see what this request looks like in different frameworks and libraries [here](https://docs.api.video/reference/api/Videos#list-all-video-objects).

You can try out this request directly from our documentation! Just be sure to authenticate first and then to copy your token into the authorization header.

**Filtering by Tags**
To filter by tags you need only add a ‘tags’ query param with a comma-separated list of values, like so:

In response, I get a list of the following videos:

Take note that videos can contain additional tags that are not in the query string. In this case, each video has an additional tag of either cat or dog.

Let’s see another example.

What if I want to allow the user to choose to see only videos of brown dogs?

That does the trick!

A word of caution. A video must have ALL the tags that you are filtering for to be returned to you.

Searching for “dog” and “cat” does not return videos with “either” tag. It returns videos with “both” tags, in this case, none. To get all videos tagged “cat” or “dog,” you need to make two separate queries.

I hope that clarifies how you can set and update tags using our web UI and how to filter videos by tag(s) with our web UI and API.

**Setting, Updating, and Deleting Tags via the API**
Setting, updating, and deleting tags via the API is pretty straightforward.

When creating the video, you can include tags in the request body like so:

To update or delete tags later, use the [video update endpoint](https://docs.api.video/reference/api/Videos#update-a-video-object).

**Something to be aware of:**
If you include a tags list when updating your video, the list of the existing tags gets overwritten by the new list. If you want only to add new tags and not lose or change existing ones, you need to include the old ones in the update request. To get the current tags, use the [“Get video” endpoint](https://docs.api.video/reference/api/Videos#retrieve-a-video-object).

I hope you feel ready to get started! If you have any questions, don’t hesitate to ask our friendly community of users and experts at [community.api.video](https://community.api.video). Thanks for reading!

Video tags can make your app awesome

tags.png

Ever found yourself biting your nails during a live football match, only to have the stream lag right at the crucial moment? Or maybe you've been following a global tech conference, hanging on every word, but the feed stutters just as the big reveal is about to drop? In a time where we crave real-time interaction and instant access to content, there's one unsung hero that makes or breaks these experiences: latency. 

&nbsp;

Whether you're cheering on your favorite team, catching the latest industry insights, or trying to snag a deal in a live online auction, the smoothness of the experience comes down to this one factor. So, how much does latency really matter? 

&nbsp;

A lot!

### What is latency?

In the context of live streaming, latency refers to the delay between the event happening in real-time and when it reaches your screen. This lag can range from a few seconds to over a minute. High latency can result in viewers receiving information late, which can lessen the real-time excitement and engagement that makes live streaming so appealing. 

&nbsp;

In this blog, we will understand why low latency is crucial across various use cases.

### 1. Real-time engagement in sports events

When it comes to live sports, every millisecond counts. Fans across the globe tune in to watch their favorite teams compete in real-time, and any delay can diminish the thrill of the game. Imagine the frustration of receiving a push notification about a goal before seeing it happen on your screen. This is where low latency becomes vital.

&nbsp;

Broadcasters like ESPN invest heavily in low latency streaming technology to minimize delays, ensuring that viewers experience the game as it unfolds. This real-time engagement is especially crucial for live betting, where odds can change in an instant. 

&nbsp;

For example, during the FIFA World Cup, millions of viewers rely on low latency streams to place bets and react to the game in real-time. Without it, the entire experience would lose its immediacy and excitement.

large_Screenshot 2024-08-23 at 4.41.58 PM.png

medium_Screenshot 2024-08-23 at 4.41.58 PM.png

small_Screenshot 2024-08-23 at 4.41.58 PM.png

thumbnail_Screenshot 2024-08-23 at 4.41.58 PM.png

paris-2024-olympics-live-streaming.png

### 2. Providing a competitive edge in gaming tournaments

Low latency becomes  non-negotiable in the world of online gaming, where precision and timing are everything. Players and viewers alike depend on streams that keep up with the fast pace of competitive gaming. Platforms like Twitch have set the standard for low latency streaming during major tournaments such as The International (Dota 2) or the Fortnite World Cup.

&nbsp;

For gamers, even a slight delay can be the difference between victory and defeat. As online gaming involves a lot of interaction via live chat, it is where streamers get instant feedback and a direct line to their audience. This allows them to adjust their gameplay, commentary, or even the direction of the stream in real time based on viewer reactions and suggestions.

&nbsp;

For viewers, low latency ensures they are in sync with the action, sharing the highs and lows of the game in real-time. The immersive experience is what keeps audiences engaged and coming back for more.

Screenshot of Twitch, a live streaming platform

large_Screenshot 2024-08-23 at 3.04.43 PM.png

medium_Screenshot 2024-08-23 at 3.04.43 PM.png

small_Screenshot 2024-08-23 at 3.04.43 PM.png

thumbnail_Screenshot 2024-08-23 at 3.04.43 PM.png

twitch-streaming-platform-screenshot.png

### 3. Bridging global barriers with virtual events

Covid-19 brought a massive shift to world of events. Events that were mostly held in-person at locations, have now mandatorily starting streaming online as well. Which again brings us to the point of low latency being extremely important. 

&nbsp;

Whether it's a global tech conference like [Apple’s WWDC](https://www.youtube.com/watch?v=RXeOiIDNNek) or Microsoft’s Ignite, low latency ensures that participants of the event can engage in real-time discussions, Q&A sessions, and get networking opportunities.

&nbsp;

In the setting of a virtually streamed event, a delay can lead to missed opportunities to interact with speakers and other attendees. The goal of these events is always to make the live streamed event almost as engaging as their in-person counterparts – which is why streaming it with minimal latency becomes important. 

&nbsp;

Take a look at how beautifully Apple’s WWDC event of 2024 was streamed on their YouTube channel.

### 4. Bringing the stage to your screen with live concerts

Live concerts and performances have long been a staple of entertainment, and their transition to virtual platforms has only increased their reach. Low-latency streaming is crucial in these scenarios to preserve the energy and immediacy of a live show.

&nbsp;

During the pandemic, global virtual concerts, such as BTS's Bang Bang Con and Billie Eilish’s ‘Where Do We Go? The Livestream’ clearly told us that live streams were the way to go - even with concerts. They were a spectacle of how a successfully live streamed concert can look like. relied on low latency to deliver an authentic experience to fans worldwide.

&nbsp;

_**Fun fact:** BTS's Bang Bang Con  achieved a new [Guinness World Records title](https://bts.fandom.com/wiki/Bang_Bang_Con_The_Live) for most viewers for a music concert live stream._

&nbsp;

This is how Billie Eilish’s live stream looked like. 

With low latency, viewers can enjoy the show in real-time, participate in live chats, and sometimes even interact with the performers, making the experience feel more personal and connected, despite the physical distance.

### 5. Delivering information via news broadcasting

In the realm of news broadcasting, low latency is essential for delivering accurate and timely information, especially during breaking news situations. Networks like CNN and BBC use low-latency streaming to provide up-to-the-second coverage of global events.

&nbsp;

This is especially important for live coverage of rapidly evolving stories, such as natural disasters, political events, or emergencies, where viewers need up-to-the-minute information.

&nbsp;

For viewers, this means access to the latest developments as they happen, rather than receiving outdated information. 

### 6. Offering financial market updates

In the financial world, where markets can fluctuate in a matter of seconds, low-latency streaming is crucial. Platforms like Bloomberg TV and CNBC rely on low latency to broadcast live financial news, market updates, and analysis during stock market openings and financial briefings.

&nbsp;

For those making split-second trading decisions, any delay in receiving this information can result in missed opportunities or significant financial losses.

&nbsp;

Low latency ensures that the market information, charts, and analysis presented during live streams are as close to real-time as possible, allowing viewers to act on the latest data without delay.

## Sometimes, latency is good too

Often, **some channels intentionally introduce a slight delay, or latency, to manage sensitive content.**

&nbsp;

This **allows moderators to intervene and censor inappropriate or offensive content**, such as profanity or sensitive information, before it reaches the audience. This practice is common in live sports broadcasts, news channels, and even gaming streams where unexpected comments or actions might occur.

&nbsp;

In scenarios where sensitive or confidential information might be accidentally shared, such as during live financial trading or high-profile interviews, **a controlled latency provides a buffer period**. This delay enables the team behind the stream to review and potentially cut out any sensitive details before they are broadcast to the public.

&nbsp;

## Last thoughts

Low latency live streaming is more than just a technical specification—it's a critical component that enhances the viewing experience. As live streaming continues to grow in importance across industries, prioritizing low latency will be key to delivering the seamless, engaging experiences that audiences demand.

&nbsp;

_If you haven’t live streamed with api.video yet and would like to start your journey with us, [sign-up](https://dashboard.api.video/register) for a free sandbox account NOW!_

Why low latency matters: Explained with 6 real-world examples

The Importance of Low Latency Live Streaming for Various Use Cases

small_The Importance of Low Latency Live Streaming for Various Use Cases.png

thumbnail_The Importance of Low Latency Live Streaming for Various Use Cases.png

importance-low-latency-live-streaming-various-use-cases.png

Customers are "divinely discontent" and their expectations are constantly on the rise. Thanks to services like YouTube & Netflix, we all expect blazingly fast load times and smooth video playback for streaming on-demand video. What might be less obvious is that, whether we're aware of it or not, that expectation is slowly transferring to real-time video communication and live streaming applications as well.  

&nbsp;  

At api.video, we're obsessed with delivering the best developer and viewer experience for our customers. So it's no surprise that we spend a lot of time thinking about and keeping up-to-date on video protocol development. Each video protocol has its strengths and weaknesses. Each is better suited for different applications.  

&nbsp;  

In this post, we outline four of the major low-latency protocols, talk about the pros and cons of each, and give our commentary on where we think the future of low latency streaming is going. We'll talk about the following protocols in depth in this post:

- WebRTC
- LL-HLS
- LL-DASH
- HESP

## WebRTC
The WebRTC protocol supports both audio and video streams for real-time bi-directional communication. It can be used for ingestion and distribution with an end-to-end latency between 300ms - 600ms depending on network quality and the distance between users. The protocol really took off in 2011 when Google bought Global IP Solutions, the company that originally developed the protocol, and gave the project significantly more human and financial resources.  

&nbsp;   

Ten years later, WebRTC has become the standard for real-time video communication on the web. The components that WebRTC is based on are accessible via a JavaScript API maintained by the W3C and the IETF, allowing users to live stream directly to a web browser without installation of any third-party tool.  

&nbsp;  

In theory, WebRTC allows the establishment of a video conference system between 2 browsers by connecting them to each other peer-to-peer. However, in practice the architecture of computer networks (internet, corporate, and domestic) can greatly complicate matters.

webrtcprotocolstack.png

### Finding your way through the internet labyrinth

In some cases, we are not directly connected to the internet and we are behind several network layers such as a NAT, a firewall, or a proxy. To get around these problems, WebRTC allows you to use the ICE (Interactive Connectivity Establishment) protocol. It allows you to find the most direct path to make two machines communicate and cross the different network layers. For this, a STUN / TURN server is necessary in order to obtain the external address of a user and relay the traffic if a direct connection is not possible.  

&nbsp;  

The WebRTC protocol requires, in addition to its own multimedia server infrastructure, a STUN / TURN server infrastructure to operate communications in a production environment with real massive use.

## To further confuse the issue

The protocol specification requires that all data exchanged between peers must be encrypted (video, audio, data application). Thus, the protocol embeds several security protocols to fill the gaps of the UDP protocol when it's used.  

&nbsp;   

WebRTC uses SDP (Session Description Protocol) to expose some properties of the peer-to-peer connection like the types of media to be exchanged and their associated codecs, the network transports, and some bandwidth information.  

&nbsp;  

Respectively DTLS (Datagram Transport Layer Security) is involved to generate Self-Signed certificates, for the negotiation of the secrets used for encrypting media data, and for secure transport of application data between peers. SRTP (Secure Real-Time Transport) is used for the transport of video and audio streams. The last security protocol involved is SCTP (Stream Control Transport Protocol), which is used for the exchange of application data.

### The challenges of WebRTC scalability

Several network architectures and topologies can be implemented to operate communications with the WebRTC protocol, each responding to a specific use case, with advantages and drawbacks specific to each topology. We will not dig into topology details in this article, but be aware that SFU (Selective Forwarding Unit) is perhaps the most popular architecture in modern WebRTC applications today.  

&nbsp;  

The main challenge with this protocol is the scalability on a planetary scale that is cost effective. We are not saying that WebRTC can't be scaled worldwide, it was true a few years ago at its early stage but it's not true anymore thanks to the great improvements and work bring by some great companies to improve topology.  

&nbsp;  

As WebRTC is a mashup of several protocols that each have to be learned and mastered by engineers rendering it very complex. It's difficult for most companies to implement it in their infrastructure at a global scale in a cost effective way. That's why only a few companies have succeeded at making it fully scalable today. They do so by mixing SFU and MCU (MultiPoint Conferencing Unit) topologies, then putting it on the edge.

## Low Latency HTTP ABR streaming protocols

In contrast to WebRTC, which is a peer to peer protocol that, in theory does not require a central server to establish communication between two machines, HTTP-based streaming protocols require the use of a server and communication over standard HTTP. They are based on the very foundations of the web.

### HLS/LL-HLS

The HTTP Live Streaming (HLS) protocol can be used to deliver live and on-demand content streams to global-scale audiences and was introduced by Apple in 2009 with scalability in mind rather than latency. While the average latency faced by users is around 15s, the HLS latency can reach between 30s and 1 minute. Even with performant infrastructure and optimized packaging and player configuration, one can expect latencies of around 6s, which is just too high for real-time live video use cases. However it's still the most popular ABR streaming protocol. Its success is mainly due to its great compatibility with a wide range of devices and browsers and supports advanced features like closed captions, ads, and content protection with AES encryption or [DRM](https://api.video/blog/video-trends/what-is-DRM/).  

&nbsp;  

Although the protocol can also be used to ingest video, it's normally only used for distribution and then paired with the RTMP protocol for ingestion. Below is a typical live streaming architecture involving both the RTMP and HLS protocol.

rtmp-hls-live-streaming-workflow.png

Without digging into the details of how HLS works (see our blog [articles](https://api.video/blog/video-trends/what-is-hls-video-streaming-and-how-does-it-work/) to learn more on this topic), below is a simple schema describing how playlists and media segmentation gives HLS the ability to do adaptive bitrate streaming (ABS).

Diagram of an HLS playlist and segmentation

hls-playlists-media-segmentation.png

So how did HLS evolve to support lower latencies? In the beginning, HLS only worked with MPEG-TS container formats associated with the H.264/AVC video codec. In 2016, support for fragmented MP4 (FMP4) was added and this led to support for the CMAF format and compatibility with DASH distribution. One year later, HLS added support for H.265/HEVC (FMP4 only), which then allowed for a significant reduction in bandwidth usage.  

&nbsp;  

Thus, Low-Latency HLS, an extension of the base HLS protocol, was finalized in April 2020 and enables low-latency video and live streaming by utilizing partial segments and on-the-fly transfer of those segments while maintaining HLS's inherent scalability. On the first draft of this extension, the protocol required the support of "HTTP/2 Push" which made it difficult to implement. Unsurprisingly, as major CDN vendors chose not to support this feature, killing the ability to scale LL-HLS, as none of the CDN players could cache the contents. Fortunately, Apple listened to community and industry concerns and came back with a new revision of the protocol extension, that removed the need for "HTTP/2 Push," but kept the need of relying on the "HTTP/2" protocol. They merged the spec into HLS making it fully backward compatible with the HLS specification and that also means that all features covered by HLS can be retrieved in LL-HLS.  

&nbsp;  

LL-HLS works practically the same way as HLS, but makes some important changes to reduce the latency in the packaging process. Below are the most important updates to the specification which make low-latency possible while preserving scalability and ability to do ABR streaming:

- **Partial Segments**: A segment is divided into Partial Segments or "Parts" of a few milliseconds which are referenced in the Media Playlist. These have a very short cache lifetime in contrast to the parent segment which can have a longer lifespan on the CDN. Once a complete segment is generated, its associated Partial Segments can be removed from the media playlist to reduce the bandwidth footprint.
- **Preload hints**: The media playlist can have a “Preload Hints” tag, which allows the player to know that new partial segments are coming so that the player can start to request them and the server will respond to this request as soon as the data is available.
- **Block Playlist Reload**: This feature avoids media playlist polling between the player and the server by adding query parameters to the request which inform the server that the player wants the response only when the playlist includes a new segment or partial segment.
- **Playlist Delta Updates**: Thanks to the new "EXT-X-SKIP" tag, a player can request just the updated part of the Media Playlist and save the transfer cost of the data that it already has.
- **Rendition Reports**: The "EXT-X-RENDITION-REPORT" tag added for each rendition line indexed in the Primary Manifest (aka: Master Manifest) provides some useful information for the Player to operate ABR such as the last sequence number and the last partial segment available for each rendition.

ll-hls-workflow-and-media-segmentation.png

With current public cloud providers you can expect to reach an end-to-end latency in the range of 2s with appropriate Group of Pictures , partial fragments, and reasonable buffer size. While this is still much slower than what WebRTC can achieve, it involves significantly less complexity and is easier to implement in your existing live streaming architecture. You can also push the protocol to its limits by changing some settings and achieve a latency of around 1s, but this comes at the expense of stability and the quality of the playback experience.

### DASH/LL-DASH

DASH stands for Dynamic Adaptive Streaming over HTTP and was born in April 2012 by the work of the Moving Picture Experts Group (MPEG) in order to create an industry-standard alternative to the HLS protocol owned by Apple. It works similar to HLS in that it's based on the preparation of content at different quality levels and divides each video quality into several chunks indexed in manifest files to enable ABR streaming.  

&nbsp;  

It also supports content protection with encryption through Common Encryption standard (CENC) which makes it compatible with all common DRM systems.  

&nbsp;  

The main difference between LL-HLS is that LL-DASH is completely agnostic of the codecs used for encoding video and audio streams. Unfortunately this codec freedom comes with the cost that LL-DASH is not compatible with Apple devices relying on iOS, including Apple TV.  

&nbsp;  

In 2017, LL-DASH provided the necessary changes to the standardized protocol to decrease latency to 2s. Behind the scenes, it relied on the Common Media Application Format (CMAF). CMAF offers the ability to play with some useful HTTP features that can be used to decrease latency a lot. The two features that allow Low Latency for DASH with CMAF are "Chunked Encoding" and "Chunked Transfer Encoding" — both part of the HTTP/1.1 spec (prohibited in HTTP/2) that respectively allow you to break a segment into smaller chunks of a few milliseconds that can be sent to the distribution layer once encoded and this is where the "Chunked Transfer Encoding" feature take the relay to allow to distribute encoded chunks on the fly. However to operate this kind of delivery process, the whole distribution stack has to support the chunked transfer encoding feature from the origin right through to the CDN.

Diagram of LL-HLS workflow and media segmentation

dashll-dash2.png

### HESP

The High Efficiency Stream Protocol (HESP) is another ABR HTTP based streaming protocol and is the most recent one of all. It was created by THEOPlayer through the HESP Alliance, whose main mission is to work on the standardization of the protocol and its promotion.  

&nbsp;  

HESP has been developed with the aim of solving several of the main constraints of other HTTP streaming protocols. It's goals are:

- To reach ultra low latency(<500ms) while preserving scalability (i.e. it can still work with major CDN vendors)
- To reduce the bandwidth required during the streaming
- To reduce zapping times (zapping is the time it takes to switch between streams, think of it as changing the channels on cable television)  

&nbsp;  

These three performance metrics have a direct impact on the user experience of the audience of a live stream. Given the extremely low latency, it can also be a viable alternative to WebRTC. The main drawback of HESP is that it's a proprietary commercial protocol and–for commercial use–it's quite expensive. Let's dig a bit into a technical overview of how it works.  

&nbsp;  

The main difference with HESP in comparison to other low-latency protocols is that it relies on two streams rather than one. Before we go into the details of how these streams allow us to reach sub-second of latency, let's talk a bit about the different types of frames that are required when streaming video:  

&nbsp;  

In video compression there are several types of frames:

- IDR-Frame (aka: Key Frame)
- I-Frame
- P-Frame
- B-Frame

Let's start with the I-Frame, you will better understand the others. An I-Frame contains the whole image and is coded without reference to any other frame except itself.  

&nbsp;  

The key frame (or IDR-Frame) is a special I-Frame where no frame after the IDR frame can reference any frame before it. That being said, all IDR-Frames are I-Frames but not the other way around. The key frame is used by any player to be able to start a playback.  

&nbsp;  

The P-Frame holds only the changes in the image from the previous one.  

&nbsp;  

The B-Frame holds the changes between the current frame and both the preceding and following frames.  

&nbsp;  

Now that you know the role of the different kinds of frames composing a video, we can go back to the streams that compose the HESP protocol:

- The first stream is called the "Initialization Stream" and contains only key frames.
- The second one is called the "Continuation Stream" and is like a normal encoded stream, meaning that it can contain all types of frames depending on the encoding parameters and defined profiles for maximum performance or maximum compatibility.  

&nbsp;  

The Initialization Stream is used only for the start of the playback or when you slide on the video timeline to change the position of the playback. Because this stream contains only key frames, the decoder behind the player is able to instantly decode the frame and so start(or restart) the playback of the live event. Once the first frame is pulled from the first stream and decoded, the player switches automatically to the second stream to continue video playback. This is because key frames are complete images, so they have a high cost in terms of bandwidth. By switching to the second stream, the player falls back to a regular live streaming bandwidth footprint and profits from the CDN capability for scaling the audience and reducing the load to the origin.  

&nbsp;  

As for DASH/LL-DASH, HESP works also with CMAF-CTE for packaging and distribution. It inherits from all the features such as encryption, DRM support, subtitles and captions, advertisements, and more.

hesp-workflow.png

This protocol sounds revolutionary on paper, right? It does respond to many issues, it's true. But as with other protocols–and everything else in life–nothing is perfect and therefore it brings its own set of drawbacks and limitations.  

&nbsp;  

The first drawback is that, as the protocol works with two streams which are encoded in sync, the encoding and storage cost is higher than the other HTTP based streaming protocols.  

&nbsp;  

The second drawback is that even if it relies on CMAF-CTE packaging and distribution, the packager has to be updated to handle the two streams instead of one in the encoding and distribution steps.  

&nbsp;  

Finally, as with the packager, the player must also be updated in order to be able to play with the HESP protocol and handle all of its subtleties.  

&nbsp;  

And finally, last but not least, you have to pay royalties for any commercial use which inherently limits its adoption.

### So which protocol is the best?

The quick answer is none. What a helpful answer for making a choice, right?  

&nbsp;  

The more complete answer is that it will depend heavily on the use case that you want to cover and the time and resources (both financial and human) you have at your disposal.  

&nbsp;  

If your needs is to offer to your customers and audience the ability to live stream with a reasonable amount of latency (6s-15s), while remaining cost effective , we recommend you use HLS and/or DASH protocols as they can scale easily to millions of viewers. You can find many open-source libraries and streaming platforms that have implemented them very well. Our preferred choice, is HLS, as it has the largest footprint in terms of adoption and support across browsers and devices. It can be played virtually anywhere. (If you want to test it, you can try our live streaming service for free just by creating an account [here](https://dashboard.api.video/register)).  

&nbsp;  

In the case that latency is critical for your business, you should look at low latency or even ultra low latency protocols. If you only needs mono-directional live streaming capability with a latency in the range of ~2s (e.g. for sport events, concerts, e-learning with students listening a teacher and can ask questions in a chat) and you don't have a big budget, you should look at LL-HLS and/or LL-DASH protocols.  

&nbsp;  

For the remaining use cases where more than 1s of latency is not acceptable, you don't have many options left. It's either going to be WebRTC or HESP.  

&nbsp;  

If you're a non-profit organization but need to serve a large audience or just don't want to have to build super complex infrastructure and don't have a lot of cash in your pocket, take a look at the HESP protocol.  

&nbsp;  

In case you need bi-directional video communication, WebRTC has proven its ability to do it well, but if building an in-house infrastructure isn't part of your core business, you'll probably want to rely on a provider who already successfully built such an infrastructure in a scalable fashion. Be aware that the likelihood of having to pay a high cost is quite high. Since HESP Alliance's royalty fees are client-based and offer different packages to meet the fees, if you have a reasonable audience this can also be a good option for limited budget.  

&nbsp;  

Finally, if money is not a concern, our choice would be HESP because it involves much less work compared to an implementation of WebRTC and is compatible with a wide range of devices and of browsers.  

&nbsp;  

At [api.video](https://dashboard.api.video/register) we deeply believe that HTTP-based Low or Ultra Low Latency streaming protocols will win this battle in the end. The reasons are quite simple, these protocols involve much less work to be implemented in a legacy infrastructure, profit from more support across devices and browsers, can scale more easily than WebRTC, and–as they don't have prohibitive licensing fees–they can be adopted by a larger number of companies.  

&nbsp;  

This is why we're building end-to-end Edge video infrastructure based on HLS. We're confident that, in the end, HLS will be the single streaming protocol that will meet all video streaming use cases in the near future.

The future of [ultra] low-latency video streaming

small_The future of [ultra] low-latency video streaming.png

thumbnail_The future of [ultra] low-latency video streaming.png

The future of [ultra] low-latency video streaming.png

After hearing from our customers about the need for low-latency live streaming, we at api.video have been relentlessly chasing seconds of latency everywhere, from ingest to delivery. Having already provided the best performance for on-demand delivery in terms of playback and [encoding](https://api.video/blog/product-updates/video-encoding-pricing-update/), we're excited to announce our latest upgrade: low-latency live streaming!

&nbsp;

Keeping true to our core belief of making video easy and manageable for you, we've rolled out our live streaming product with latency as low as 3 seconds in best conditions. Now, you can stream your videos with a latency of 3 seconds in ideal conditions, revolutionizing the way you connect with your audience.

## What does this mean for you?

With this latest upgrade, you can stream your videos live with a minimal delay of 3 seconds. This means that you can ensure better interaction with your viewers, lower bounce offs due to viewer frustration and a smoother viewing experience. 

&nbsp;

Additionally, you also get the flexibility to push a live stream using Real-Time Messaging Protocol (RTMP) or Secure Reliable Transport [(SRT)](https://api.video/blog/product-updates/SRT-livestreaming/) protocol based on your needs. 

&nbsp;

[*How do you choose between SRT or RTMP protocols? Read on!*](https://api.video/blog/video-trends/srt-vs-rtmp/)

## How can your business benefit from low latency?

Several use cases benefit significantly from low latency in live streaming:

### 1. Esport live streams
Low-latency live streaming is crucial for esports viewing as it ensures real-time action with minimal delay, providing a more immersive and engaging experience for fans. It allows viewers to stay in sync with live events, participate in interactive chats, and react instantly to game-changing moments. This immediacy becomes crucial to build the excitement and zeal of watching an esport live, making viewers feel as if they are right there in the arena.

&nbsp;

Additionally, top level games that are being broadcast all over the globe and possess official data feeds are where the issues of latency have the biggest impact. It can be unfair for punters who are watching and betting on the event as the stream does not reflect what is actually happening on the field. 

&nbsp;

As opposed to online gaming where latency as low as 25 miliseconds is ideal, esport broadcasting industry usually has a [latency of under 10 seconds](https://sbcnews.co.uk/features/2021/07/27/how-latency-stream-delay-work-esports/).

### 2. Live events and concerts

For virtual concerts, conferences, and other live events, low latency is crucial for delivering a seamless viewing experience to remote audiences. By minimizing delay, organizers can create a sense of presence and immersion, allowing viewers to feel like they're part of the action, even from afar.

### 3. Webinars and workshops

Low-latency live streaming can significantly enhance webinars and workshops by providing an  interactive experience for participants. With reduced delay between the presenter and the audience, feedback, questions, and discussions can take place with ease. The low latency here helps instructors or guest speakers of the webinar to adapt their content on the fly based on audience input. In case a webinar is being streamed live and is also happening in-person, the minimal delay for the virtual audience keeps the whole event synchronised.

### 4. Telehealth and live patient monitoring

A good usage of low-latency lives treaming in the healthcare industry is for remote patient monitoring and live consultations. These demand streaming capabilities with minimal delays to ensure the highest quality of care. For individual healthcare professionals and hospitals that offer this service, being able to monitor and interact with patients live is crucial for accurately assessing symptoms, providing diagnoses, and making treatment decisions within time. Delays or interruptions in the video feed in this scenario may hinder the communication between patients and providers, which shows the relevance low-latency live streaming holds in this space.

## How to live stream with api.video: Step-by-step guide

- In order to establish a video live stream, you must first create a live stream container at api.video.
- Then, you can begin streaming with the tool of your choice.
- For this guide, we’ll see how you can [create a live stream with OBS](https://api.video/blog/tutorials/live-stream-tutorial/) – free and open source software for video streaming. 

### **Step 1: Authenticate**

You need an access_token in order to create and upload a video.

&nbsp;

You will need your API key to obtain the access_token. You’ll find your API key in [your api.video dashboard](https://dashboard.api.video/overview).

&nbsp;

(This guide uses the sandbox endpoint. To upload your video in production, simply replace all `sandbox.api.video` instances with `ws.api.video`.)

&nbsp;

First, call the authentication endpoint and get your access token.
&nbsp;

**Example - Curl Request**

### **Step 2: Create the live stream**

Now we [create the live stream](https://docs.api.video/reference/api/Live-Streams#create-live-stream). In the JSON parameter, feel free to edit the name of the live stream from "Your Stream Name" to whatever you want to name your stream.

&nbsp;

**Example - Curl Request**

Now the server is ready to accept our live stream, and once broadcast begins (JSON above shows broadcasting:false), it will be viewable on the URLs listed in the JSON response.

### **Connecting live video**

The JSON response above lists your live stream's streamKey, which will be needed in OBS to connect your video to the server.

&nbsp;

Now in the OBS application,

1. Establish a source. In the sources section, choose a video feed to share. You could choose to share your screen, or to share your camera (on a Mac: Video Capture Device, and then in the "Device" dropdown choose the camera). You should now see the video source in the main OBS window.
2. Connect OBS to api.video. Under Settings, choose Stream. You'll see a choice for service - choose custom.
3. The server should be `rtmp://broadcast.api.video/s` and the `streamKey` is the value you received in the Json when you created the stream. Click OK to accept the changes.
4. Press ‘Start Streaming’.
5. Share the embed, iFrame, so that others can watch your stream!

## Player support for low-latency live streaming

We are pleased to announce that our low-latency live streaming feature has been thoroughly tested with several popular video players to ensure optimal performance and seamless integration. The players we have tested include:

&nbsp;

- api.video embed player
- THEOplayer 7.4.1
- Video.js 8.14.0
- hls.js 1.5.11
- JW Player 8.34.1

&nbsp;

These players have been verified to support low-latency streaming. However, if you encounter any issues with a specific player, please reach out to our support team through chat with detailed information about the problem.

&nbsp;

We highly value and appreciate any feedback you can provide to help us improve our services. Your insights and experiences are crucial to identifying potential issues, enhancing features, and ensuring the overall quality and performance of our product. 

&nbsp;

_To start live streaming with api.video, [sign-up](https://dashboard.api.video/register) now! For questions, [talk to our team](https://meetings.hubspot.com/apivideo/talk-to-us) and we’ll try to answer your queries._

Stream smarter, not slower: Introducing low-latency live streaming

Low-latency live streaming with api.video

low-latency-live-streaming-api-video.png

Boost your live streams with user engagement & real time data

Boost your live streams with user engagement 

Build your Flutter live streaming application with api.video

Delivering live video: Streaming vs. WebRTC

Create a Live Stream

If you're seeking to stream live video with minimal end-to-end latency, the options for transport protocols are relatively few. This is particularly evident if you’re utilizing the public internet as a transport medium, given its inherent challenges like packet loss and jitter. In this blog, we will analyze and assess the two widely used protocols, RTMP and SRT, to aid you in your decision-making process.

## Streaming with RTMP

[RTMP](https://api.video/what-is/rtmp-real-time-messaging-protocol/), a protocol established roughly 20 years ago, initially served as a closed system for streaming audio and video between Macromedia's Flash players. Originating from Flash, it eventually transitioned to an open format, extending its reach beyond the Flash ecosystem and emerging as a dominant ingest protocol in the streaming landscape.  

&nbsp;  

However, [RTMP](https://api.video/blog/video-trends/what-is-rtmp-and-why-do-we-use-it-for-live-streaming/) encounters a notable issue while streaming known as head-of-line blocking which can be attributed to its reliance on Transmission Control Protocol (TCP). While transmitting audio and video packets, when the data does not arrive in sequence or is lost due to the inherent unreliability of networks, TCP reorders the packets and requests re-transmissions to compensate loss. It insists on perfect delivery and reordering, which in turn can impede the realtime transmission of audio and video streams.  

&nbsp;  

This lack of time assurance in data transmission over TCP translates into unstable latency during RTMP streaming, as the protocol automatically adjusts to fluctuating network conditions without user intervention.  

&nbsp;  

What does it mean for an end user watching a livestream?

- A sudden increase in latency may prevent the server from streaming data in real-time, leading to buffering.
- If the latency decreases after that, allowing the server to catch up, the end-user may still lag behind the livestream due to previous buffering. While the player may attempt to accelerate playback to reach the edge, recurring latency peaks will result in buffering interruptions.  

&nbsp;  

This undesirable outcome underlines the importance of finding alternatives to RTMP for delivering uninterrupted live streams in fluctuating bandwidth conditions. 

## Streaming with SRT

Now let us see how SRT is different.  

&nbsp;  

SRT uses a different approach compared to RTMP. It relies on User Datagram Protocol (UDP) which does not enforce packet re-ordering and does not manage packet losses, and so is not subject to head of line blocking that happens in TCP. However, this is something needed to provide a good playback experience, so it is handled by SRT but using an alternative method.  

&nbsp;  

It does this by letting the streamer choose the maximum latency they're okay with when streaming. The SRT server then holds back data for that amount of time. During this time, it re-organizes the packets and asks for any missing ones to be sent again. But if a packet isn't received by the end of this delay, it's considered lost, and it's up to the server to deal with that.  

&nbsp;  

By doing so, [SRT makes it possible to stream data with a stable latency](https://api.video/blog/product-updates/SRT-livestreaming/) to the server which limits buffering to a certain extent.  

&nbsp;  

Now of course, this comes with a price. If unexpected congestion occurs on the network, viewers may notice playback issues like visual artifacts, audio glitches, or black screens. However, the playback will be smoother which is why, the latency target you choose to achieve plays a very important role in how your video will be delivered. 

- If you set the latency too low, the viewer experience may be deeply impacted or may even not work
- If you set the latency too high, the viewer experience will be optimal but the end-to-end latency will be high, which may be a problem for the streamer.  

&nbsp;  

Therefore, finding a good compromise between latency and quality of stream becomes very important. The table below explains everything in a crystal clear format.

|  | End-to-end latency | Visual/audio quality | Playback reliability |
| --- | --- | --- | --- |
| RTMP | Close to optimal but subject to instability | Optimal | Fair but subject to buffering |
| SRT with very low latency | Very low | Very poor (too many losses) | Good (no buffering due to ingest) |
| SRT with good latency | Low but not optimal | Almost good | Good (no buffering due to ingest) |
| SRT with very high latency | Very high | Optimal | Good (no buffering due to ingest) |

## Closing thoughts

So, as you must have seen above, it is not straight answer if you should choose SRT or RTMP for your livestreams. If you stream in stable conditions over a wired network, with a low risk of congestion/jitter, you can start with RTMP and you will probably achieve a better latency than you would with SRT.  

&nbsp;  

If the network you use is known to be unstable or there is a chance that your users work frequently with wireless networks, then SRT may be a better fit.  

&nbsp;  

***With api.video, you can either choose RTMP or SRT for your livestream. Find more details about how to live stream with api.video in our [documentation](https://docs.api.video/live-streaming/create-a-live-stream).***  

&nbsp;  

 ***If you haven’t live streamed with api.video yet and would like to start your journey with us, [sign-up](https://dashboard.api.video/register) for a free sandbox account NOW!***

SRT vs RTMP: Which one to choose for your livestream?

SRT-vs-RTMP.png

Live stream better with the Secure, Reliable, Transport (SRT) protocol

What is RTMP and why do we use it for live streaming?

live-stream-srt-protocol.png

Your Stream Name

small_Low latency livestreaming with api.video (1).png

thumbnail_Low latency livestreaming with api.video (1).png

How do you make sure that your live stream viewer stays **engaged**? what are the tools that you can leverage in order to make **the most out of the experience**? and how can you **analyze the viewer's reaction**?  

&nbsp;  

In this article, you can learn about the way you can integrate real time communication into your live stream in order to make an engaging user experience with your live streams.  

&nbsp;  

Although we will only learn how to share emojis between viewers in your live stream, you will be able to leverage the example in order to build **robust analytics** that will provide you **great insight into when and how the viewers reacted to the stream**.  

&nbsp;  

We’ll leverage api.video with [Ably](https://ably.com/) to create a real time communication scenario where one viewer of the live stream will post an emoji, and all of the other viewers of the same live stream will be able to see the reaction.  

&nbsp;  

Check out the diagram below on how this works:

## Why do Livestream viewers need to be engaged?

Live streaming is growing at a very rapid pace. Let’s talk statistics:

- Did you know that the revenue for the entire video streaming app industry reached **$82.3 billion in 2022**, and is projected to reach **$115 billion by 2026.** according to some resources it’s going to be **$118 billion by 2025**. ([Business of Apps](https://www.businessofapps.com/data/video-streaming-app-market/))

- Live commerce-initiated sales could account for as much as **10 to 20 percent** of all e-commerce by 2026 ([McKinsey](https://www.mckinsey.com/capabilities/mckinsey-digital/our-insights/its-showtime-how-live-commerce-is-transforming-the-shopping-experience)) and **41.2%** of consumers said they tune in to live streams focused on home products, and **37.5%** said they watch [live shopping events](https://tinuiti.com/blog/paid-social/live-shopping-tips/) for electronics ([Retail Touchpoints](https://www.retailtouchpoints.com/topics/digital-commerce/livestreaming-update-coresight-debunks-5-common-myths)).

- In 2022, there were **532 million** esports viewers worldwide ([Insider Intelligence](https://www.insiderintelligence.com/insights/esports-ecosystem-market-report/)).

- **52%** of live video viewers stream content through social media ([eMarketer](https://www.insiderintelligence.com/content/livestream-viewers-social-media)).

- Brands earn nearly **40%** more engagement with Instagram Reels compared to other Instagram content formats ([Business Wire](https://www.businesswire.com/news/home/20220907005644/en/Brands-Earn-Nearly-40-More-Engagement-with-Reels-Compared-to-Other-Instagram-Content-Formats)).  

&nbsp;  

And this is just a small part of some impressive live stream and video content statistics. So you ask yourself, how do I start integrating livestream into my app or website? 

## How to build a scalable and engaging live stream quickly?

What we’ll be leveraging:
- **api.video** to create and deliver the live stream
- **Ably** for the real-time communication handling
- For streaming, you can use **OBS**, [one of our live streaming SDKs](https://docs.api.video/sdks/livestream/react-native-livestream-component), or stream directly from the [api.video dashboard](https://dashboard.api.video/overview)  

&nbsp;  

With api.video, you can integrate livestream into any project in a few minutes. You can find the article on how to get started here: [Create a live stream](https://docs.api.video/live-streaming/create-a-live-stream).  

&nbsp;  

We’ll start with this simple example that was built using Next.js. You can go ahead and clone it from here: [Live stream with Ably](https://github.com/apivideo/livestream-with-realtime-ably).  

&nbsp;  

Let’s break it down; what are we looking at here? 

### The api.video React Player module

We are using api.video in order to create a stream and then the [api.video React player SDK](https://api.video/catalog/react-js-player/) in order to create a responsive on-screen video delivery while removing the control elements.  

&nbsp;   

If you navigate to the `src/pages/index.tsx` file, here’s where we consume the player and buildout the video delivery:
- We consume the api.video React player SDK here: `import ApiVideoPlayer from '@api.video/react-player';`
- And we pass it as a component to be rendered:

_**Disclaimer! In this example, the streamId is hardcoded in the index file, however, you’ll probably want to serve the streamId dynamically from your backend when you get to production.**_  

&nbsp;  

You can notice that we are passing the `ApiVideoPlayer` component all of these parameters; let’s break it down a bit; I’ll focus on the important ones:
- With Style, we are passing CSS parameters in order for the video to fit the screen first while the `size` parameter is dynamic, as `size` is a state:

Each time you resize the window, the video player size will adapt to the size of the screen.

- `chromeless` parameter removes all the player controls, which will give the user a better experience.
- With the `video` parameter, we are passing an object that includes the stream id and the optional parameter `live` that is set to true in order to give the player the indication that we are passing in a live stream and not a video  

&nbsp;  

Getting the live stream id can be done in two ways.  

&nbsp;  

### Programmatically:

1. You can leverage the livestream endpoint in order to get the list of livestream ids from your workspace: [GET Livestreams](https://docs.api.video/reference/api/Live-Streams#list-all-live-streams).

2. You’ll get a JSON response from which you can get the stream id you need:


### Manually from the dashboard:

1. Click on the live stream in Live Streams

You can find more information about the api.video React Player in our documentation: [api.video React player](https://github.com/apivideo/api.video-react-player).

### Everyone loves Emojis!

Now let’s get to the fun part; the example gives you the ability to share emojis between all the viewers of the stream; each person in the stream gets an emoji picker; once the emoji is clicked, a cool little animation will play where the emoji is hovering and then disappearing. The cool thing about that is that the animation will be played to all the viewers.

This example is very basic; however, you can take the example and **expand** on it in order to create **real time statistics** for the live stream session, for example: 
- Count the reactions from the users
- Map the different reaction emojis and get the timeframe with the most reactions
- Get real time feedback from the users
- And more...  

&nbsp;  

The emoji animation is built with [React Simple Animate](https://www.npmjs.com/package/react-simple-animate), it has a bit of complex logic, but you are free to reuse it in your app. You can find the actual animation parameters in `src/utils/randomframevalues.tsx`  

&nbsp;  

The random values are being passed to the `<AnimateKeyframes>` component that includes the actual emoji:

Go ahead and play around with the random values and the parameters, should be fun 😃

### Spread the emojis

And now we get to the challenge, how do you get these emojis across to all other users? this was an interesting task, but with Ably, it wasn’t that difficult to implement.  

&nbsp;  

We created a new class that is called `MessageHandler` where we use the Ably node library: `import Ably from 'ably';`  

&nbsp;  

Ably has a great API that allows you to create channels, get users to subscribe to them, and then broadcast and listen to any events that happen inside these channels; that’s a great fit for our use case!  

&nbsp;  

In the example, all you need to do is to replace the values of the `#apiKey`  with the one that you get from Ably:

**Disclaimer! Please note that these keys should be consumed from the backend. In this example, just to make it easy, we expose the keys on the front end. Please ensure that the backend serves the keys when you go to production.**  

&nbsp;  

**Briefly on what we are doing in the `MessageHandler` class:**

When we use Ably there are a few things we need to understand and utilize:
- Channels
- Users
- Subscriptions (listeners)
- Message publishing  

&nbsp;  

Every time the user opens a new window, they will be assigned a user id for a session (this logic works in the `index.tsx` file); the userId is passed to the class when it is initialized in order to create a unique user id for each user that watches the stream.  

&nbsp;  

Then we use the stream id as the channel id for Ably, of course, you can generate any channel id, however, it’s easier to just leverage the values that we already have.  

&nbsp;  

We then subscribe to the same channel and also broadcast the messages to it at the same time.  

&nbsp;  

The caveat is that we set the listener in the `/src/components/emoji.tsx` file, if you look closely at the listener, we have a logic that will make sure that the listener is not getting duplicated. We check if there are no listeners created already; if there aren’t, we create one. This situation is caused by the fact that each time the state changes, React will re-render and will run the same code again, causing the listener to be created multiple times, so we do something like this:

Finally, we have two functions to generate the message (which will include the emoji) and publish the message to the channel.  

&nbsp;  

Now that you know how it works, you can run the example and play around with it.
- Just make sure to install all the dependent modules by running `npm install` or `yarn install`
- After the installation is done, run the example by `npm run dev`
- The example will run on `localhost:3000`  

&nbsp;  

Happy Hacking! 🙂  

&nbsp;  

If you have any questions about the article, feel free to raise issues on the [Github repo](https://github.com/apivideo/livestream-with-realtime-ably), reach out to me directly: artem@api.video, or just open a ticket with our support team.

Boost your live streams with user engagement

live-streams-boost-user-engagement.jpg

Choosing the right bitrate for your OBS live stream

A few months ago, my colleague Yohann wrote a fantastic article on [How to create a React Native live streaming application for mobile targets](https://api.video/blog/tutorials/how-to-build-a-live-streaming-app-in-3-steps/). This time, you will learn how to create the same application with a React Native competitor: Flutter.

In this article, you will develop a live streaming application in Dart. For further details, check out our official [Flutter live stream repository](https://github.com/apivideo/api.video-flutter-live-stream).

## **Few words about Flutter**

Google developed Flutter in 2015. In 2021, it was the most used cross-platform mobile framework (42% against 38% for React Native, [source](https://www.statista.com/statistics/869224/worldwide-software-developer-working-hours/)). It is used to develop cross-platform applications (including iOS and Android) quickly. The main difference between Flutter and React Native is that Flutter compiles Dart code to native bytecode/libraries, whereas React Native uses an engine to interpret JavaScript or TypeScript code. If you haven't heard of Flutter, you can learn more on the [Flutter website](https://flutter.dev/). 

## **Getting started**

First, follow the development setup steps from [Flutter's official documentation](https://docs.flutter.dev/get-started/install).

If you're new to Flutter, you may also need to [learn the basics](https://docs.flutter.dev/get-started/codelab).

*Quick reminder: iOS development is only enabled for macOS users. If you're on Windows or Linux, you can develop for Android.*

### **Create a new Flutter app**

1. Open Android Studio.
3. You should see a “New Flutter Project” button. Click on it.
5. Verify the Flutter SDK path and click on “Next.”
7. Enter your project name: “live_stream_app” (according to the [pubspec documentation](https://dart.dev/tools/pub/pubspec#name), the name must be lower_case_with_underscore.)
9. Make sure the project type is set to Application.
11. Click on “Finish.”

### **Launch the application**

Once Android Studio is launched, you can directly run your application with the control toolbar:

1. Select your phone.
2. Click on the *Run* ▶️ icon.

It will take several minutes to finish, stay calm and grab a coffee ☕️

When the application build completes, it will be launched on your phone. Check your phone 🤳🏾

🎉🎉🎉Congratulations, you have created your first Flutter application 🎉🎉🎉  

&nbsp;  

#### **Signs your iOS application (optional)**

If you have trouble building the application for an iOS device, it might be because the application is not associated with a development profile.

Open Xcode, click  "Open a project or file," and open the `Runner.xcworkspace` located in `live_stream_app/ios.`

Click on Runner, go to the `Signing & Capabilities` tab, add your team, and create a unique bundle identifier.

## Add the **live streaming client to your app**

Now let's install the [Flutter live streaming client](https://api.video/catalog/flutter-live-stream/)!

### **Installation**

Open a terminal in your `live_stream_app` folder and the following command:

Also, you need to set the Android minSdkVersion to the one supported by Flutter live stream client.

Open your application build.gradle. It's located in the live_stream_app/android/app directory and replace:

The Flutter default project Kotlin version and the `apivideo_live_stream` Kotlin version might not be in sync.
In this case, when building the application, you face errors like `was compiled with an incompatible version of Kotlin. The binary version of its metadata is 1.9.0, expected version is 1.7.1.`.

To fix this, open `android/settings.gradle` and set the `org.jetbrains.kotlin.android` in the `plugins` section to the appropriate version (`1.9.0` in the previous error log).

### **Permissions**

⚠️ Both iOS and Android need permission to broadcast from your device's camera and record audio.

You will also need to ask for internet permission for Android.

#### Android

From your project folder, open the `AndroidManifest.xml` file. It’s located in the `live_stream_app/android/app/src/main` directory.
Add the following content just under the opening `<manifest>` tag to enable internet, audio recording, and the camera for your application:

#### iOS

From your project folder, open the `Info.plist` file. It's located in the `live_stream_app/ios/Runner` directory.
Add the following content just under the opening `<dict>` tag to enable the camera and microphone:

Don't forget to add the app description, as shown above, if you want to deploy your application in app stores.

### **Usage**

You can check the [Flutter live streaming sample application](https://github.com/apivideo/api.video-flutter-live-stream/tree/master/example) for the whole application picture.

#### **Create a controller and the camera preview**

Change your `main.dart` file located in the `live_stream_app/lib` with the following code:

Launch your application. You now have the camera preview.

#### **Manage application lifecycle**

The next step is to manage application lifecycle. You will have to stop/start the camera when your application goes to/from the background. 

The class `_MyHomePageState` must implement the abstract class `WidgetsBindingObserver`. Replace its declaration with:

Register the lifecycle observer, add in `initState`:

#### **Add a control panel**

You still can't start a live stream because there is no way to do it. 

We are going to add a [Row](https://api.flutter.dev/flutter/widgets/Row-class.html) of [IconButton](https://api.flutter.dev/flutter/material/IconButton-class.html) that can control your live streaming.

Import the following package:

Then, add the following code in `_MyHomePageState`:

Then, add the `_controlRowWidget()` in the Colum under the `ApiVideoCameraPreview`. Replace your `_MyHomePageState` `build` method by:

Finally, update the `_isStreaming` variable in the controller’s callbacks to update the `IconButton` state when the live streaming is stopped.

Replace `createLiveStreamController` by:

#### **Launch your first live stream**

⚠️⚠️⚠️ If you want to run your live stream, you will need to change `YOUR_STREAM_KEY` to a real one. 

You can find yours in the [api.video dashboard](https://dashboard.api.video/). If you don't have an account yet, create one, it's free. Then, create a livestream from the overview or the “Live streams” page.

A modal will appear with several pieces of information in it, including the shareable link and stream key. Save the shareable link to access your live stream later.

💡 You can also use the api.video API to create a live stream and retrieve your stream key dynamically. Find how to do this right here. Paste your stream key in place of `YOUR_STREAM_KEY`. Paste your stream key in place of `YOUR_STREAM_KEY`.  

&nbsp;  
Click on the live button in your application; it should be disabled if the live streaming properly starts. Then, go to the shareable link you just saved. 

There you go! You can see what your mobile is streaming in real-time! If not, wait a few seconds and check your stream key value.

🎉🎉🎉 Congratulations, you have created your first live streaming Flutter application 🎉🎉🎉

You can now do an actual live stream directly from your Android and iOS devices. 

## And now what?

[api.video](https://api.video) provides two development environments. The sandbox allows you to live stream directly from your computer or mobile, but a watermark will be applied to your video, and there is a 30-minute limit for live streams.  

&nbsp;  

To avoid these limitations, [sign up](https://dashboard.api.video/register) to api.video and go into production mode 🚀.

Also, the Flutter RTMP live stream client allows us to do much more in terms of configuration!

You can match both audio and video configuration to your needs.

Also, there are some properties can be updated during the live stream:

* Camera: front or back
* Audio: muted or unmuted.

Check out the [README](https://github.com/apivideo/api.video-flutter-live-stream/blob/master/README.md) for exhaustive information about the `apivideo_live_stream` package.

build-flutter-live-stream-app-api-video.jpg

api.video player for Flutter: playback videos on your apps

How to build a live streaming app in 3 steps

Here at [api.video](https://api.video/), we talk with lots of developers who are looking for ways to build cool and innovative services with video. Many are still figuring out all of their use cases, and trying to match them with the technical capabilities of different video services.

[Streaming live video](https://api.video/product/live-stream/) is one feature that we receive many questions about. At api.video, **our video streaming solution uses HTTP Live Streaming (HLS) to live stream video**. Another technology we are frequently asked about is WebRTC.  Both technologies are great, but have significantly different applications. In this post, we’ll look at the features and advantages of both, and the primary applications that they are suited for.

## What is HLS?

HTTP Live Streaming (HLS) was developed by Apple, and is currently the primary way that video is streamed on the web today.  The “live streaming” in the name HLS is a bit of a misnomer, as the video does not need to be live - YouTube, Netflix and other video on demand services use HLS to stream video that is not live.  This is an advantage of using HLS for live streaming - the same files used to deliver the video live can be used to playback the video later ‘on demand.’

The ‘HTTP’ in HLS indicates that it uses traditional web protocols to transmit the data over a TCP connection. The video is cut into small segments and sent from the server to the user. The player on the user’s device recombines the video for playback based on a text based manifest file that is transmitted with the video segments. What makes this powerful is that if you have different versions of the same video (different dimensions and bitrates), the player can optimise the delivery based on the actual conditions for each user (primarily network speed and screen size).

When a live video is being transmitted with HLS, the video is sent to a server and transcoded into segments for transmission to end users. This makes HLS ideal for live streaming in one-to-many streams - once the files are recorded, the files are sent like any other HTTP request and the limitation is essentially the server hosting the video. (and of course with CDNs this overhead can be further reduced).

**Latency**: HLS streaming does suffer from about 6-15 seconds of latency (and depending on architectures, it can even be longer). Since the video is transcoded into segments of finite length, the video must be held up for at least as long as the segment length. To reduce transmission errors, some players require 2 segments to be stored in the playback buffer before playback begins, further pushing playback time away from the exact live event.

NOTE: There is active work being done today to reduce HLS streaming latency, and this is expected to improve over the coming months (and api.video is investing in bringing low latency HLS to our users in the *very* near future).

**HLS Summary**: A robust solution for streaming to many users. The current state of HLS includes 10-20 seconds latency that makes HLS not ideal for interactive presentations. HLS videos are also available for playback after the live event.



## WebRTC

“Web Real Time Communication” or WebRTC is a W3C standard that is supported in all browsers, allowing for - as you might have guessed - real time communication. WebRTC has near instantaneous delivery, typically under 300ms, making it ideal for interactive back and forth conversations like in web conferencing solutions.  

The reduction in latency is (partly) due to the use of UDP instead of TCP, and because the formats being used do not require any transcoding before transmitting.

However, since there is instantaneous delivery of video between peers, there is a limit to the number of users who can share video, typically under 6. There are implementations for WebRTC where a small number of users (under 5) share their video, and another number of users can watch in real time (but this number is usually small - under 300.).  

Each person sharing video uses about 1 MBPS of bandwidth. If there are 4 people streaming, the video is 4 MBPS per viewer - the bandwidth coming out of the server will quickly be the limiting factor for the number of users who may join the stream. Additionally, users on low quality networks may not be able to ingest 4MBPS of video, and have trouble playing back the video due to the size. 

In order to save the video for later playback, the WebRTC implementation will use the MediaRecorder attribute to save the video on a local computer. For later playback, this video will have to be uploaded to a server.

WebRTC is ideal for real-time instantaneous communication, but is for small groups of viewers - typically 1-4 sharing video, and a small number of viewers.


## Are HLS and WebRTC independent?

Melding HLS and WebRTC is actually quite common. For example, if you are hosting a panel of speakers, they could join over WebRTC (like a Zoom call), and then stream the call over HLS to a large audience (Zoom offers this as a feature to increase your audience).

How are you using WebRTC and HLS in your video applications? Feel free to continue this conversation on our developer forum: [community.api.video](https://community.api.video).

webrtc.png

Live streaming your content is a great way to connect with your audience. In this tutorial, we'll walk through the steps you need to follow to set up a video livestream.

Note: we have example code of setting up a live stream in the [browser](https://api.video/blog/tutorials/live-stream-tutorial/), with [Zoom](https://api.video/blog/video-trends/start-remote-work-with-online-video-and-zoom-us/)
and with [OBS](https://api.video/blog/video-trends/video-live-streaming-in-just-5-easy-steps/).

[Here](https://docs.api.video/reference/api/Live-Streams#create-live-stream) is the direct link to the technical docs to create a live stream.

In order to establish a video livestream, you must first create a livestream container at api.video. Then you can begin streaming with the tool of your choice. In this example, the live stream will be created with OBS, free and open source software for video streaming.  

## Creating Live Stream

### Step 1: Authenticate

You need an access_token in order to create and upload a video.

You will need your API key to obtain the access_token. You can find your API key in [your dashoard](https://dashboard.api.video).  

This tutorial uses the sandbox endpoint. To upload your video in production, simply replace all `sandbox.api.video` instances with `ws.api.video`.

First, call the authentication endpoint and get your access token.


#### Example - Curl Request


### Step 2: Create the Live Stream

Now we [create the live stream](https://docs.api.video/reference/api/Live-Streams#create-live-stream). In the JSON parameter, feel free to edit the name of the live stream from "Your Stream Name" to whatever you want to name your stream.

#### Example - Curl Request

Now the server is ready to accept our live stream, and once broadcast begins (JSON above shows broadcasting:false), it will be viewable on the urls listed in the JSON response.

### Connecting Live Video

The JSON response above lists your live stream's streamKey, which will be needed in OBS to connect your video to the server.

in the OBS application:

1. Esablish a source.  In the sources section, choose a video feed to share.  You could choose to share your screen, or to share your camera (on a Mac: Video Capture Device, and then in the "Device" dropdown choose the camera).  You should now see the video source in the main OBS window.
2. Connect OBS to api.video. Under Settings, choose Stream.  You'll see a choice for service - choose custom.
3. The server should be `rtmp://broadcast.api.video/s` and the `streamKey` is the value you received in the Json when you created the stream. Click OK to accept the changes.
4. Press Start Streaming.
5. Share the embed, iFrame, so that others can watch your stream!


Extra Step:  The default video poster that your users will see is api.video branded.  You can update the thumbnail with an image of your choice:

## Conclusion

That's all it takes. We've walked through the process of creating a livestream at [api.video](https://api.video), and then how to connect that video's streamKey into OBS. Using OBS, we are then able to broadcast video to all our viewers, who can watch using the player (oriframe) url provided by the api.

[Give it a try](https://dashboard.api.video/register), and let us know how it worked for you in our [community forum](https://community.api.video). We're also there to help out if you run into any difficulties.

create-a-live-stream.png

small_SRT-vs-RTMP.png

thumbnail_SRT-vs-RTMP.png

If you've watched videos, listened to audio, or seen a live stream, you've probably encountered RTMP. RTMP stands for Real-Time Messaging Protocol and it's been used for streaming video and audio on the internet as far back as 2002, which is when Macromedia first created it. In the beginning, [RTMP](https://api.video/what-is/rtmp-real-time-messaging-protocol/) was proprietary, but eventually Adobe bought Macromedia and made RTMP publicly available in 2008.  

&nbsp;  

We've been using it for live streaming since 2002. Even now, a common practice is to take data from a source, transcode it to RTMP, and then transcode that to HLS. Why is transcoding twice so common? Why don't we transcode straight to HLS for live streams? Why is RTMP so great? Well, there's a few reasons that we'll get into. 

## What Does RTMP Do? 

First of all, let's review what RTMP does. It uses a persistent (continuous) TCP (Transmission Control Protocol) to stream audio and video from a source to a destination. Using TCP enables it to keep packets of information in the right order when received and viewed - so you don't end up watching the end of your movie or sports game before the middle. Because RTMP uses TCP to travel, it uses a three-way handshake when transporting data. The client (live stream sender) requests a connection from the server it's sending data to. It receives a response, creates a session and transmits the data.  

&nbsp;  

RTMP combined with Flash Player became so popular because it was very fast, delivering content with around 5 seconds of latency. Over time, Flash has fallen out of use, but we continue using RTMP. 

## What are the Benefits and Drawbacks of RTMP? 
### RTMP is great (even now) because: 
* It's easy to set up an encoder. There are many software based encoders that are cheap, and often hardware solutions are also low cost.
* It's delivered as a single file, which is easier to manage and process than lots of chunks (looking at you HLS). 
* Because RTMP was the industry standard for so long, it's cheaper to set up and it's easier to support because there are many tools and people who are deeply knowledgeable about how to work with RTMP. 
* It's still one of the fastest solutions out there (don't worry, we'll get to why it isn't THE fastest anymore in a little bit). 
   
&nbsp;  

### RTMP is limited because:
* New standards were developed that allow for HTML5 video streaming and adaptive bitrate delivery (...HLS).
* It has difficulty getting past firewalls. 
* There are numerous security issues with Flash. 
* Today a lot of browsers don't support RTMP.
* RTMP doesn't work on mobile devices. 
* The quality of footage is not as high as newer standards. 

## RTMP for First-Mile Delivery and Last-Mile Delivery
Because of the points I've listed, RTMP is still used, but it's no longer used for everything. You might hear terms for live streaming like 'first-mile delivery' and 'last-mile delivery.' First-mile delivery is what happens right after you transfer footage from a source to an encoder, and the encoder converted it to RTMP. Wherever the encoder sends the RTMP content to is first-mile delivery. Last-mile delivery is the CDN (or sometimes EDGE server that also handles transcoding if you use a decentralized approach) that's going to deliver content to a viewer or user device. Due to the remaining benefits of RTMP, it's used for first-mile delivery. Because of the drawbacks, RTMP is not used for last-mile delivery.  

&nbsp;  

In the image, first-mile delivery is the phase from when footage becomes RTMP through to where it is going to be transcoded. Last-mile delivery is after something has been transcoded to HLS and is being delivered to a viewer (Delivery). For the Convert to RTMP section, note that some cameras stream in RTMP, handling this step automatically, some you can convert to RTMP on your computer, and some you can send to another place to be converted. 

## Why is Transcoding Twice So Common? 
If you've been reading closely so far, no doubt you guessed why all kinds of places, like Facebook, YouTube, api.video accept RTMP and then do a second transcoding to HLS. It's because RTMP is still a combination of the fastest and most popular (reliable) choice for first-mile delivery. (Note I said it's the combination - there's starting to be faster options, but we don't yet have something that's as popular as RTMP.) It's easy to use, cost effective, well known, and reliable. But it's not good for last-mile delivery. For last-mile delivery, you want a protocol that's going to be fast, good quality, and capable of being handled by mobile, browsers, whatever the situation might be. That's why everyone eventually ends up transcoding to HLS.  

&nbsp;  

Some day, RTMP might be replaced by other, newer standards being created, for example [SRT (Secure Reliable Transport)](https://www.srtalliance.org/) is a protocol that addresses some of the issues RTMP faces. SRT preserves video quality better than RTMP, has less trouble getting past firewalls, and is lower latency.

## A Little Bit About HLS
HLS (HTTP Live Streaming) is an open standard created by Apple that offers faster and faster options as time goes by. While initially HLS wasn't a great choice for live broadcasting (latency times were often 15-30 seconds), low latency HLS has started solving this problem. With low latency HLS, you can live stream with under 2 seconds of latency, and there are faster options all the time. A great thing about the HLS protocol, is if a receiver doesn't understand something about the HLS it's being sent - say it's missing an extension or similar, it will default to playing whatever form of the HLS it does understand. So while this might mean higher latency in some instances, it means more reliable playback overall.  

&nbsp;  

If you have more questions about RTMP or any other video-related information, contact us in the [community forum](https://community.api.video/)! 

RTMP.png

In the field of video production, resolution plays a pivotal role in shaping the quality of your work. As 4K resolution becomes more prominent, many creators are contemplating whether it’s time to move beyond HD. This blog will offer a clear comparison of 4K and HD, providing you with insights to make informed choices for your projects.

## What is ‘4K’ in 4K resolution?

**The "4K" in 4K resolution refers to the horizontal pixel count of the display, which is approximately 4,000 pixels. Specifically, standard 4K resolution is 3840 x 2160 pixels, where "3840" represents the number of horizontal pixels and "2160" represents the number of vertical pixels.** 

&nbsp;

This resolution is called "4K" because the horizontal pixel count is roughly four times that of Full HD (1920 x 1080 pixels), which was the previous standard. The term "4K" has become synonymous with Ultra High Definition (UHD) video, offering greater detail, clarity, and sharpness compared to lower resolutions.

## 4K resolution vs. HD resolution

### What is the 4K resolution?

4K boasts a resolution of 2160p, which means it has four times the number of pixels as 1080p HD. This increase in pixel count results in sharper, more detailed images, making 4K a popular choice for professional video production, especially for content that needs to look pristine on large screens.

### What is the HD resolution?

HD, or High Definition, has been a standard in video production for years, primarily featuring 720p and 1080p resolutions. HD is widely used for web content, streaming, and even television broadcasts. With HD, you're working with a resolution that offers good quality at a manageable file size, making it a go-to for many video creators.

&nbsp;

_[Find out how HD is better than SD and why SD still holds relevance in some aspects of videos](https://api.video/blog/video-trends/sd-hd-difference/)._

## 4K resolution: The technical aspects

### Pixel density and image sharpness

One of the most noticeable differences between HD and 4K is the pixel density. With 4K’s higher pixel count, images are incredibly sharp and detailed, even when zoomed in. This can be particularly important for projects that require fine detail, such as nature documentaries or cinematic productions.

### Color depth and dynamic range

4K often supports greater color depth and dynamic range, which means more vivid colors and better contrast between light and dark areas. For video creators who are serious about color grading and visual effects, 4K offers more flexibility and a higher-quality end product.

## File size and storage considerations

### Data requirements for HD vs. 4K

One of the trade-offs for the enhanced quality of 4K is the significantly larger file size. A 4K video can be four times the size of a 1080p video, which means more storage space is required. For long projects, this can add up quickly, so it’s essential to consider your storage capacity before diving into 4K.

### Compression and file formats

When working with large 4K files, compression becomes crucial to manage file sizes without sacrificing too much quality. Understanding how different codecs and formats affect your footage can help you choose the best options for your project, whether you’re working in HD or 4K.

## Editing and post-production workflows

### Hardware and software requirements

Editing 4K footage requires more powerful hardware compared to HD. You’ll need a robust GPU, plenty of RAM, and fast storage solutions to handle the data-intensive nature of 4K editing. Additionally, not all software is optimized for 4K, so ensuring your editing suite can manage these files smoothly is key.

### Rendering and export times

Rendering and exporting 4K videos can take significantly longer than HD, depending on your system’s capabilities. If you’re a video creator, you need to factor in this extra time, especially when working under tight deadlines. Optimizing your workflow can help mitigate these delays, but it’s something to consider when choosing between 4K and HD.

## Who should use 4K and who should use HD?

### Use of 4K in video projects

Many successful video projects have benefited from the detail and clarity that 4K offers. For example, travel vlogs or high-production YouTube channels often use 4K to showcase stunning visuals that captivate viewers.

### When HD is still the best choice

However, there are also instances where HD is more practical. For example, creators focusing on quick, social media content or educational videos might find HD to be more efficient without compromising too much on quality.

## 4K TV and its popularity

4K TVs have rapidly risen in popularity, transforming the way we experience visual content at home. With four times the resolution of traditional 1080p HD, 4K TVs deliver incredibly sharp and detailed images, making every scene more lifelike and immersive. This leap in clarity has been a major draw for consumers, especially as streaming services like Netflix, Amazon Prime Video, and Disney+ continue to expand their 4K content libraries. Additionally, the decreasing cost of 4K TVs over the years has made this advanced technology more accessible to a broader audience. Therefore, 4K has quickly become the new standard in home entertainment, offering viewers a cinematic experience right in their living rooms.

&nbsp;

As we wrap up our exploration of 4K resolution, it’s clear that this technology offers a significant leap in detail and clarity over HD. Whether it’s the right choice for your projects depends on your specific needs and goals. If you’re aiming to enhance your content with sharper visuals and more intricate details, 4K could be a valuable upgrade. Ultimately, it’s about finding the resolution that best supports your creative vision and enhances your viewer’s experience.

## FAQs on 4K resolution

### **1. What challenges arise when editing 4K video content, and how can they be mitigated?**

Editing 4K video can be challenging due to the increased demand on system resources, such as CPU, GPU, and RAM. To mitigate these issues, editors often use proxies (lower-resolution versions of the video) during the editing process and then apply changes to the full-resolution footage in the final render. Additionally, investing in a powerful workstation optimized for video editing can improve workflow efficiency.

### **2. What are the network infrastructure requirements for streaming 4K video content?**

Streaming 4K video requires a robust network infrastructure with high bandwidth to accommodate the larger file sizes and higher bit rates associated with 4K content. Streaming platforms and content providers must optimize their delivery networks, often using [Content Delivery Networks (CDNs)](https://api.video/blog/company/api-video-proprietary-infrastructure/) and adaptive bitrate streaming technologies, to ensure smooth playback and minimal buffering for viewers across different regions and devices.

### **3. What are the key requirements for live streaming in 4K resolution?**

To live stream in 4K resolution, you need a 4K-capable camera, a powerful encoder that supports 4K output, a stable internet connection with a high upload speed (at least 20-50 Mbps for smooth streaming), and a streaming platform that supports 4K streaming, such as YouTube Live or Twitch.

### **4. How does streaming in 4K affect bandwidth usage, and what upload speed is recommended?**

[Live streaming](https://api.video/blog/product-updates/SRT-livestreaming/) in 4K significantly increases bandwidth usage compared to lower resolutions. For a stable 4K live stream, an upload speed of at least 20-50 Mbps is recommended, depending on the frame rate and bitrate. Higher bitrates provide better quality but require more bandwidth, so it’s important to ensure that your connection can handle the increased data transmission without interruptions.

### **5. What is the best resolution available today?**

The best resolution available today for consumer use is 8K resolution, which measures 7680 x 4320 pixels. This is four times the resolution of 4K and sixteen times that of Full HD (1080p). 8K offers incredibly high detail and clarity, making it ideal for large screens and applications where extreme precision is necessary, such as high-end digital displays, advanced video editing, and certain types of professional photography and videography.

&nbsp;

_api.video offers both video-on-demand and livestreaming for your videos up to 4K quality. [Sign-up](https://dashboard.api.video/register) for a free sandbox account with us to try out our offerings and see them for yourself!_

Video on demand

Live streaming

Analytics

Video infrastructure

Video player

AI features

See all features

Online learning & Corporate training

Social & Entertainment

Marketplace & E-commerce

Communication & UGC

Generative AI

Quickstart guides

Documentation

Ecosystem catalog

Clients & SDKs

Community

Blog

Demos

Customer success stories

Help center

Video trends

Guides and insights from the Video Industry