Normal

doug.jpg

twitter-brands.svg

Doug Twitter

Doug Sillars

large_api-video-blog-tutorials.png

medium_api-video-blog-tutorials.png

small_api-video-blog-tutorials.png

thumbnail_api-video-blog-tutorials.png

api-video-blog-tutorials.png

Tutorials

Live streaming is a "one to many" form of communication.  Like a conference talk, or a class lecture - the live streamer(s) are presenting, and the viewers watch.  With api.video's live streaming, you can stream to thousands of viewers around the world in near real time!

However, at a conference there are Q&A sessions.  During a lecture, students may raise their hands with a question.  The communication is still primarily "one to many", but there is an aspect of reverse communication that is lost with *just* a live stream.

In many of the virtual conferences I have spoken in over the last 18 months, this reverse communication has been facilitated with a chat application.  Much like a live streamer on Twitch can get text questions/comments, the chat allows for the communication from the viewer to the streamer.

## Latency

With HLS live streaming - you are able to broadcast to thousands of viewers, but there is generally a latency behind 'real-time' of 5-20 seconds.  The great thing about a 'real-time' chat is that this latency cannot be felt by the viewers.  Any delay in reply from the streamer is attributed to typing time, or reading time, or formulating the answer time - making chat-boxes and HLS live streaming an excellent combination.

## Building Chat & Live Streaming

In this post, we'll build a simple webpage that integrates a live stream from [api.video](https://api.video) with a chat app from [CometChat](https://www.cometchat.com/).  

### Live Video

When you [Create a Live Stream](https://docs.api.video/reference/api/Live-Streams#create-live-stream), a player URL and iframe are generated:

```
<iframe src="https://embed.api.video/live/li4pqNqGUkhKfWcBGpZVLRY5" width="100%" height="100%" frameborder="0" scrolling="no" allowfullscreen=""></iframe>
```

You can paste this iframe into a webpage, and the live stream will appear on that page.  If the stream is not streaming, you'll see the thumbnail.

### Chat

To add a chat widget, simply copy the code from the [CometChat web widget](https://prodocs.cometchat.com/docs/web-chat-widget) page to the same page.  Add in your credentials into the chat widget, and it'll load as you expect.

### That's it

Really - that is all there is to it.  A little boilerplate code from [api.video](https://api.video), and from [CometChat](https://cometchat.com), and your live stream with chat is now up and running.

You can see an example of this today at [chatduring.a.video](https://chatduring.a.video).  It was built in about 5 minutes using the steps above.  (if the live stream is not broadcasting, it is because I am moving this month, and my Raspberry Pi is in a box around here... somewhere....)  The code is live on [Github](https://github.com/apivideo/cometchatvideo) (it's literally just the html page) if you want to crib even further.

So, check out the demo, and build your own.  We'd love to see what you've built - leave a note with a link on our [community page](https://community.api.video)



Two way communication: Chat during a live stream

large_screenshot-2021-07-23-at-11-40-43.png

medium_screenshot-2021-07-23-at-11-40-43.png

small_screenshot-2021-07-23-at-11-40-43.png

thumbnail_screenshot-2021-07-23-at-11-40-43.png

screenshot-2021-07-23-at-11-40-43.png

large_logo_avatar.webp

medium_logo_avatar.webp

small_logo_avatar.webp

thumbnail_logo_avatar.webp

logo_avatar.webp

Erikka Innes

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

If you're new to video content creation, at some point you'll ask yourself whether you should host your videos on a site like YouTube or your own website. YouTube is incredible for content creators and for those looking to build fanbases for their content. For a business that wants to make a conversion to a buying customer, YouTube may not be the best spot for that business's video content. Instead, for many businesses the best place for video is their own website. And by that I mean hosting video content yourself, either entirely or by using a flexible cloud video/video streaming provider. But rather than take my word for it, consider these aspects of handling video content for yourself to make the best decision: 

* Business goals and requirements
* Reach 
* Engagement 
* Conversion 
* Analytics 

## Choosing business goals and requirements
The first step in choosing the right video strategy for your business is going over your goals and requirements. For example, if you prioritize minimal effort, YouTube might be great. However if you prioritize conversions and you're willing to put in a little effort for video SEO and other optimizations, then hosting video on your website might be better. 

Make a list of everything that's a requirement or goal to start with. And as you go over the rest of this article, you can refer back to and refine your list. If anything in your list conflicts (for example choosing minimal effort and hosting content on your own site) you can reprioritize or remove certain items. By the end of this article you should have a great idea of what option works best for you.

## Reach
When deciding whether to post videos on YouTube, or host them yourself on your site, the first thing to consider is reach. In marketing, reach is how many people see your content. It doesn't necessarily mean they engage with the content, but it means it's at least put in front of them. A big selling point for YouTube is that when you add your video there, you get the benefit of YouTube's algorithms like related videos, circulating popular videos, automatic video SEO and indexing of your content and features like playlists (see how to create your own playlist feature here: [Playlist](https://watch.a.video/playlist/)), YouTube search and more. This has the potential for huge reach.

It sounds great. The problem is about 500 hours of video are uploaded to YouTube every minute. The odds that content for your business is going to be popular right off the bat and benefit from some of the YouTube algorithms geared for popularity are not strong. While you might put in minimal effort tweaking video SEO for reach, you will put in maximum effort figuring out how to: 
* Get subscribers
* Engage relevant audience
* Buy google ads to advertise your content 
* Drive people to your YouTube channel 

Another issue is that you are spending time driving people to your YouTube channel. If you're selling something, you probably want people to go to your website and buy what you're selling. So you're sending traffic to YouTube to watch a video to convince them to go to your website. 

You can cut out a step by placing the video on your own website. It can be tricky to host your own video content, so you can host, stream and deliver content from a cloud video provider. By placing the content on your own site, you now benefit from your own site's existing reach, the SEO work you do for your site and when you advertise you are always driving traffic to something on your site instead of elsewhere. You can also do your own video SEO to get your content indexed. The end result is a centralized spot where people go to learn about you. The downside is if you wanted monetization of content handled for you, it wouldn't be. You have to handle that yourself. 

## Engagement 
Engagement is about creating an interactive experience with your content. It's coming up with ways to get them to watch more of the videos you create, check out more of your products and become more loyal and attached to your product by encouraging them to interact with you. Interactions can be all different kinds of things, from clicking through different pages of content to agreeing to join a newsletter to signing up for a free trial of a product.

YouTube is designed to maximize audience engagement, but specifically focused on watching videos. You can subscribe to content, explore new content, review your watch history, create or watch playlists made by others and YouTube is constantly trying to show you content it think you will like based on your other viewing habits. If all you need is people watching video content, this is perfect. The issue is, YouTube has its own goals for engagement, and they might not align with yours.

On YouTube, their goal is to keep viewers on YouTube, watching as many videos as possible so they can show you as many ads as possible. Your content is not a priority. If you know how to create material that is valued by YouTube because of the kind of ads they can place on your content, then you can do very well there. You won't be able to easily add other kinds of engagement though. Everything will be focused on interacting with video content.

If instead, you decide to set up content on your own site, the immediate plus is you can make your content the priority. At the end of a video, you can always recommend your own content for further viewing. You can also control how it may be viewed and by who (check out our article about creating self-guided content [Build a self guided training course with api.video](https://api.video/blog/tutorials/build-a-self-guided-training-course-with-api-video/). And to start with, only your content will be available. Depending on how elaborate you want to get with the video content you offer, you can create your own algorithms for what videos to show the viewer next based on their session (see our article about [Dynamic Metadata](https://api.video/blog/tutorials/dynamic-metadata/)). You can choose to keep your content ad free and create your own calls to action. Maybe you ask the user to watch something and then sign up for your product right on the site. Or you ask for their email so you can send them a newsletter. You have many more options than you do on YouTube. 

## Conversion
There is no doubt that the best place for conversion starts with your website where you're selling your product or offering your trial. Extra steps, like bringing a person from YouTube to your site, increase the chance that a potential customer will lose interest or find something else to do online. 

YouTube, as we discussed earlier, is great about coming up with new content for viewers to watch. If you just interested a potential customer in your product, but YouTube distracts them into watching a cool video where they then forget to check out your website, you've lost a conversion. There aren't tons of obvious ways to get conversions out of a YouTube video. You can possibly embed links, but these take you away from YouTube, and frequently people would prefer to stay on the site watching content. 

Another issue is that your YouTube video is using the excellent, automatic video SEO provided by YouTube. This is great, but YouTube gets the traffic from that. And then, because it's not a great place for conversions you lose out.

It's much better to put the content on your own website, spend the extra time to set up the video SEO, and then manage the traffic from that. 

## Analytics
In order to improve the effectiveness of your marketing, analytics are a must. YouTube offers detailed analytics and a plus is they're easily accessible through a GUI if you aren't technically inclined. One potential issue is you may have to do some extra work to figure out what traffic comes from your YouTube content to your site. 

You can get the same degree of detail with analytics from cloud video providers as well. Places like Vimeo and api.video (yes us!) offer detailed analytics. At api.video, you can get all kinds of details about your videos, like location (here's a fun post about creating a [Choropleth map](https://api.video/blog/tutorials/use-observable-to-create-a-choropleth-map-of-your-viewers/)), device type, where the viewer came from to start the session, what they did with a video during a session (for example, did they drop off part way through, where was that?) and more. 

large_choropleth.png

medium_choropleth.png

small_choropleth.png

thumbnail_choropleth.png

choropleth.png

On a flexible video platform like api.video, because you have control of everything, you can use analytics to decide whether to localize content, when and what to show viewers, and more. 

## Conclusion 
YouTube is an incredibly interesting and creative platform. It's perfect for content creators making a name for themselves, developing a visual aspect of their brand that doesn't require conversions, or anyone who wants to spend time mastering how to create successful video content on YouTube. 

Your own website is the best platform for video content if you are interested in driving traffic to your site for conversions. Nothing beats having everything in one place or pointing people to one place to learn more. You should consider a cloud video platform that will transcode, host and deliver your content but leaves the rest up to you. The video SEO is a bit more effort, but it is well worth it. If you want to give api.video a try, [register here](https://dashboard.api.video/register)

Should I host my videos on YouTube or my own website? 

small_youtube.png

thumbnail_youtube.png

youtube.png

small_bees.png

thumbnail_bees.png

bees.png

Erikka Innes and Anne-Sophie Poupard

large_api-video-blog-case-studies.png

medium_api-video-blog-case-studies.png

small_api-video-blog-case-studies.png

thumbnail_api-video-blog-case-studies.png

api-video-blog-case-studies.png

Case Studies

Based in Paris, [Coverd](https://www.coverd.co/) is a company that offers smartphone insurance. And they’re revolutionizing their industry. 

Where other coverage providers only offer insurance from date of purchase, Coverd can offer plans for post-purchase smartphones. According to one of their co-founders, Nicolas Schwartz, the company got its start based on a single observation - that smartphones are a key part of everyday life for people everywhere, and a lot can happen to a smartphone. 
Anything from losing the phone, breaking it, drowning it, you name it, smartphones are susceptible to many disasters great and small. And the insurance for them, if you’ve ever tried using it, is all about the insurance company getting out of paying for damages to your phone. This is not the case with Coverd. They’re a low-cost, completely online option that covers all risks, and doesn’t make the user commit to anything. 

So where does api.video come in? Let’s find out. 

## The need to centralize video content
When Coverd was first starting out, they needed a way to document damages to user phones. 
Because the company is completely online, they required a simple, effective way to ensure customers weren’t committing insurance fraud. 

“*We started with photos at first*,” said Nicolas Schwartz, co-founder and CTO of Coverd. “*Then we moved to video, but it was very manual. We collected videos through email or chat. It was complicated to centralize all these videos, and sometimes the size was too big to be sent through email*.” 

## Finding the right solution
Coverd needed an easy-to-implement, high quality video solution that centralized their claim information. 
This would allow them to process more claims, and more easily check the damage on their customers’ phones. 

That’s when they discovered api.video. 

They knew that they wanted a video on demand solution where customers could upload videos of their damaged phones from anywhere. Once they had their design in place, they turned to api.video. “*The documentation was clear and the API was easy to use, so we were able to finalize our integration quickly*,” Schwartz said. 

Two key features that were important to Coverd were keeping the [videos private](https://api.video/blog/product-updates/video-access-management-how-to-create-deliver-and-manage-private-videos-and-what/), since only their back office would use them for claim evaluation, and [fast transcoding](https://api.video/blog/product-updates/api-video-encoding-times-2h-2021-edition/) and upload. 

api.video delivered on all fronts, and continues to be a part of their revolutionary smartphone insurance solution. 

If you are interested to know more about our end-to-end solution and how you can integrate videos into your own product, you can ask questions in our [community](https://community.api.video/) or [create a free account](https://dashboard.api.video/register) to get started.

How video helped Coverd to improve their customer support

large_coverd.png

medium_coverd.png

small_coverd.png

thumbnail_coverd.png

coverd.png

Case Study: How video helped Coverd to improve their customer support

video create

Delegated Upload

Video upload

JavaScript

Uploading a video to api.video just got easier!

We have created a [JavaScript uploader](https://docs.api.video/sdks/vod/apivideo-typescript-uploader) script to abstract this code into a single function - allowing you to focus on your code and making the video upload process easier for you and your development team!


## JS Uploader Widget

You can read about uploading a video in the [tutorial](https://api.video/blog/tutorials/uploading-large-files-with-javascript/) describing the code. The JS Uploader widget abstracts the file slice, creating all of the headers, and uploading the files - it also adds retries for segments that have issues!

The new code for uploading is under 30 lines, and most of that is for updating the page during the upload.

First, we add the script to the head (with a defer tag to not slow page load)

```
   <script src="https://unpkg.com/@api.video/video-uploader" defer></script>

```
Next we have a event listener for changes in the file upload form:

```
     input.addEventListener('change', () => {
       console.log("upload commencing");
       uploadFile(input.files[0]);
       function uploadFile(files) {
           const uploader = new VideoUploader({
               file: input.files[0],
               //changed to sandbox, because we cannot have nice things
               uploadToken: "to5PoOjCz98FdLGnsrFflnYo",
               chunkSize: 1024*1024*10, // 10MB
               retries: 10
           });
           uploader.onProgress((event) => {
               var percentComplete = Math.round(event.currentChunkUploadedBytes / event.chunksBytes * 100);
               var totalPercentComplete = Math.round(event.uploadedBytes / event.totalBytes * 100);
               document.getElementById("chunk-information").innerHTML = "Chunk # " + event.currentChunk + " is " + percentComplete + "% uploaded. Total uploaded: " + totalPercentComplete +"%";
           })
           uploader.upload()
               .then((video) => {
                   console.log(video);
                   playerUrl = video.assets.player;
                   console.log("all uploaded! Watch here: ",playerUrl ) ;
                   document.getElementById("video-information").innerHTML = "all uploaded! Watch the video <a href=\'" + playerUrl +"\' target=\'_blank\'>here</a>" ;
               });
       }
     });

```

### Walking through the code

The uploadFile function takes the files and creates an uploader function:

```
 const uploader = new VideoUploader({
               file: input.files[0],
               //changed to sandbox, because we cannot have nice things
               uploadToken: "to5PoOjCz98FdLGnsrFflnYo",
               chunkSize: 1024*1024*10, // 10MB
               retries: 10
           });

```

The chunkSize defaults to 50MB, but I have lowered this to 10MB for the sake of the demo, so you can see multiple chunks uploaded.

The retry count defaults to 5.  

#### During Upload

```
 uploader.onProgress((event) => {
               var percentComplete = Math.round(event.currentChunkUploadedBytes / event.chunksBytes * 100);
               var totalPercentComplete = Math.round(event.uploadedBytes / event.totalBytes * 100);
               document.getElementById("chunk-information").innerHTML = "Chunk # " + event.currentChunk + " is " + percentComplete + "% uploaded. Total uploaded: " + totalPercentComplete +"%";
           })


```

The onProgress updates the video upload every 50ms.  We calculate the % uploaded, and update the browser - so the user is aware that the video upload is underway.

#### Upload complete

When the video upload is complete, the API will reply with the videoId, and links to the video. We take this information to display the url to the user:

```
           uploader.upload()
               .then((video) => {
                   console.log(video);
                   playerUrl = video.assets.player;
                   console.log("all uploaded! Watch here: ",playerUrl ) ;
                   document.getElementById("video-information").innerHTML = "all uploaded! Watch the video <a href=\'" + playerUrl +"\' target=\'_blank\'>here</a>" ;
               });

```


## Conclusion

The new JS video uploader widget weighs in at just 11.5 KB, and as it is not required until after the page loads, will not impact your page speed (as long as you use the defer tag).

It will make building video upload widgets in JavaScript easier, as we've abstracted all the complexity into the library - allowing you to focus on your application, and not on the intricacies of partial uploads of video files.

Read all of the [technical details](https://docs.api.video/sdks/vod/apivideo-typescript-uploader) in our documentation, and [get started](https://dashboard.api.video/register) with your video app uploads today!


New video uploader JavaScript library

large_new-video-uploader-javascript-library.png

medium_new-video-uploader-javascript-library.png

small_new-video-uploader-javascript-library.png

thumbnail_new-video-uploader-javascript-library.png

new-video-uploader-javascript-library.png

Live stream status

[FFMPEG](https://api.video/what-is/ffmpeg) allows you to stream and [live stream](https://api.video/live-streaming/) video, but sometimes what the output means can get confusing. 

We are going to go over every part of the information in the output, so if something seems obvious, skip ahead to the part you wanted to learn about.

Here's our sample. This sample shows a session where a live stream is started using my Mac and the Mac's iSight camera. I started it using the [livestream.a.video](https://livestream.a.video) demo through a Chrome browser. There might be some differences based on what computer you're on, so keep that in mind. 

## Hello from mediarecorder-to-rtmp server!

We're using an RTMP connection, which is based on TCP. So when I connect with my request to create a live stream, my client gets a response: 

"SERVER:Hello from mediarecorder-to-rtmp server!" 

I'm asked to provide my stream key, which is going to be what I will use to broadcast. Because of how the demo is set up, that's already been sent, so now the server tells me it's received the information about where I want to broadcast my live stream to: 

"SERVER:Please set rtmp destination before start streaming.
SERVER:rtmp destination set to:rtmp://broadcast.api.video/s/30087931-229e-42cf-b5f9-e91bcc1f7332"

The last part tells me what version of FFMPEG we're using and provides a link to static builds of FFmpeg for Linux kernels 3.2.0 and up. It also gives me copyright information - wow we've had FFMPEG for 22 years!

## Configuration details 

The next part of the FFMPEG output shows us the configuration details for the live stream. 

In this section, we're told that FFMPEG was built with gcc 8. GCC stands for GNU Compiler Collection and it's the standard compiler for Linux. It's associated with the Linux distribution Debian (Debian GNU/Linux). The Debian Linux distribution is super popular and while it's less user friendly than distributions like Ubuntu, it is great for people who like free and open source software. 


## FFMPEG library versions
This section of output lists the main libraries in FFMPEG and the versions you have installed. 


## FFMPEG input info 

This section shows you details about your video live stream. 

Here's the first line: 

"FFMPEG:Input #0, matroska, webm, from 'pipe:':

This explains how video is being input. We can see here that the multimedia container matroska and the open video format webm is being used to capture video.

"Metadata:
  encoder         : Chrome
 Duration: N/A, start: 0.000000, bitrate: N/A"
 
 Next, there's more information about the streams being input: 
 
 "Stream #0:0(eng): Audio: opus, 48000 Hz, mono, fltp (default)
  Stream #0:1(eng): Video: h264 (Constrained Baseline), yuv420p(progressive),   
	240x240, SAR 1:1 DAR 1:1, 1k tbr, 1k tbn (default)"

### The audio stream
The audio stream is using the opus codec with a sample rate of 48000 Hz, which is standard for digital video files. Mono means the audio is monophonic, meaning all sounds are mixed together in a single channel. And fltp is Planar Floating point format. It's a way of retrieving the sample format for your audio. Sample format information is used to determine how many bits will be in each audio sample. The higher the number of bits per sample in a file, the more data that will be stored in the sample. You can learn more about sample format here: What is Sample Format?

### The video stream
The video stream is using the h264 codec with a constrained baseline. The term constrained baseline describes the video stream profile. A profile determines the methods that an encoder can use to generate streams and also describe the methods a decoder is expected to perform in order to decode the stream later. The term 'yuv420p' describes the type of video signal you're using. 

YUV is a type of video signal where colors are split into three channels, one for luminance (brightness) which includes green, and two for chrominance (color) which include blue and red in separate channels. 420 describes the chroma subsampling used on the video. Normally, you'd notate this as 4:2:0. It's telling you that the color channels have half the resolution of the luminance channel. If you want to learn a bit more about this way of representing color, see the api.video definition for YCbCr. The term progressive means that the video is in a progressive format, which means that the TBR value (coming up in our discussion) is talking about the frame rate rather than the field rate. There's confusion about both these terms. For the purpose of this walkthrough, let's keep things simple. A progressive video format will use frame rate to describe frames per second. An interlaced video format will use field rate. It takes two fields to show you one image. 

240x240 describes the pixels in each frame of video. SAR stands for Sample Aspect Ratio, and it's showing you the ratio between the width and the height of each individual pixel - 1:1. DAR stands for Display Aspect Ratio and that's the ratio between the width and height of a full image in your video. In this case it's also 1:1. 

In the final line, it closes out with "1k tbr, 1k tbn (default)." TBR represents the frame rate baseline. This is guessed by FFMPEG when it looks at the video stream. At the start of a video stream, TBR is low. In our stream, it's 1 at the very start. Sometimes if you have a video format that's interlaced, the TBR will be twice as high as expected, because there are two fields used to create an image. TBN represents the time base in AVStream that comes from the container. TBC is the time base for the codec for the stream.

## Stream mapping 
Next in our information from FFMPEG we have a section about stream mapping that looks like this:

Stream #0:1 is our video stream. This means that the input stream is from the first file '0' and it is the second stream in that file '1.' h264 (native) means that the detected codec of the input stream is H.264 and that FFMPEG is going to use the built-in decoder to decode the stream. It's being mapped to h264 (libx264) meaning that the output stream is going to be H.264 and FFMPEG will use the libx264 encoder to generate the stream. 

Stream #0:0 is our audio stream. This means that the input stream is from the first file '0 and its the first stream in that file '0.' opus (native) means that the detected audio codec of the input stream is opus and as before, native means that FFMPEG is going to use its built-in decoder for opus to decode the stream. aac (native) means the output audio will be in aac, and FFMPEG will use the built in encoder for aac to generate the stream. 

## Configuration details for libx264
We're mapping to libx264, so now we receive some details about how libx264 is configured for our stream. 

You can see the Video Buffering Verifier confirms that there's a buffer size set, but the max bit rate it can handle isn't specified, so it's ignored. Then the SAR is 1:1, as it was to start with. We can see the CPU capabilities available for sending our live stream and that we'll be using the constrained baseline for H.264. 

Next there's the line: 

"FFMPEG:264 - core 164 r3065 ae03d92 - H.264/MPEG-4 AVC codec - Copyleft 2003-2021 - http://www.videolan.org/x264.html"

This tells us what version of the H.264 codec FFMPEG uses. It's followed by options that are configured for the codec. 

**cabac=0** 
Cabac stands for context-adaptive binary arithmetic coding. It's a type of entropy encoding, which is a lossless data compression technique. H.264 is lossy, so cabac is used at the end to do a final compression that is lossless. You should not mistake its inclusion in H.264's compression steps as meaning all the steps are lossless. Also, explaining this algorithm in detail would take some time. If you want to learn more about cabac, look here: Context=adaptive binary arithmetic coding

**ref=1**
This indicates which frame will be the first reference frame. Here, it's the first frame.

**deblock=0:0:0**
This is the deblock filter for H.264. It creates pixelation to help improve the appearance of your video. It's useful when macroblocking occurs, which would be a huge block of pixels that look unnatural. Deblocking blurs these blocks to make them look normal again.

**analyse=0:0** 
This is part of deblocking. It helps determine the size of each block you will apply deblocking to. 

**me=dia**
This is saying that the motion estimation method is diamond or dia. Motion estimation is the process of determining motion vectors that describe the transformation from one 2D image to another; usually from adjacent frames in a video sequence. Diamond search technique for block motion estimation is based on diamond search patterns. The process of block matching motion estimation is to find out a candidate block, within a search area in the previous frame, which is most similar to the current block in the present frame. So you're saying here use this technique for motion estimation.

**subme=0** 
This is for the sub-pixel motion estimation method. It's important for video coding inter-frame prediction and has high computation complexity. It's set to 0 meaning there will be zero sub-pixel motion estimation done. 

**psy=1 psy_rd=1.00:0.00**
This is also to do with motion-compensated DCT, which is a lossy block compression transform coding technique. If set to 1 it means use psychovisual optimizations. It means optimizing quantization tables based on the human visual system and humans see. It's a complex topic that can't be fully explained here. psy_rd is about setting how strong the psychovisual optimization will be.

**mixed_ref=0** 
This allows you to use one reference per partition as opposed to per macroblock. A macroblock is a large block of pixels and a partition is a smaller, multiple variable-sized prediction block. 

**me_range=16**
Again about motion estimation, but this time about the range for a motion vector. In video compression, a motion vector is the key element in the motion estimation process. It is used to represent a macroblock in a picture based on the position of this macroblock in another picture, called the reference picture. This parameter lets you set the range.

**chroma_me=1** 
Typically when doing motion estimation, only luminance is examined. You can have chroma considered as well by setting chroma_me to be 1.

**trellis=0** 
This lets you set the rate-distortion optimal quantization. This is a method used to improve video quality in video compression. It optimizes the amount of video quality lost per chunk of data by measuring how far an optimization will deviate from the source material and the cost of that deviation. This can be used to decide what choices are useful vs. resulting in the loss of too much data. It's a slow process, so sometimes it's better not to use it, which is what's being done here by setting trellis=0.

**8x8dct=0** 
With this parameter you can enable adaptive spatial transform. This is a way of altering an image or video frame through rotation, flips, scaling and deformation. For our case, where it's for video, it's about ways to manipulate the block of data so it appears less distorted and of higher quality.

**cqm=0** 
Allows the use of a custom quantization matrix to weight frequencies differently in the quantization process. The presets quant matrices are "jvt" and "flat". Recommended only if you know what you're doing.

**deadzone=21,11** 
When trellis isn't activated, deadzone parameters determine how many DCT coefficients are rounded up or down. Rounding up results in higher quality and more detail retention, but costs more bits--so rounding is a balance between quality and bit cost. Lowering these settings will result in more coefficients being rounded up, and raising the settings will result in more coefficients being rounded down. Recommended: keep them at the defaults. This is part of the settings for rate-distortion optimal quantization. This is again fairly complex to explain. If you want to learn more about it conceptually, check out this page: Quantization

**fast_pskip=1** 
By default, x264 will skip macroblocks in P-frames that don't appear to have changed enough between two frames to justify encoding the difference. This considerably speeds up encoding. However, for a slight quality boost, P-skip can be disabled. In this case, the full analysis will be done on all P-blocks, and the only skips in the output stream will be the blocks whose motion vectors happen to match that of the skip vector and motion vectors happen to match that of the skip vector and which have no residual. The speed cost of enabling no-fast-pskip is relatively high, especially with many reference frames. There is a similar B-skip internal to x264, which is why B-frames generally encode much faster than P-frames, but it cannot be disabled on the commandline.

**chroma_qp_offset=0** 
This stands for chroma quantization parameter offset. It is the quantization parameter difference between chroma and luma. 

**threads=3**
FFMPEG is multi-threaded by default. How many threads it will use depends on the codec. By default for libx264 it is cores x1.5 for frame threads and cores x 1 for slice threads. 

**lookahead_threads=3** 
A lookahead thread looks at incoming frames before they are transcoded. Number of lookahead threads can impact performance speed.

**sliced_threads=1** 
Sliced threading decodes multiple parts of a frame at the same time.

**slices=3**
If the codec you're using supports multi-threading, you can decode more than one part of a single frame at once by working on multiple slices. This is only available if the video was encoded using slices.

**nr=0** 
Confusingly, this stands for noise-sensitivity. You can use it with static-thresh to change the threshold on blocks that are examined in an image. If they fall below the specified threshold the encoder skips them.

**decimate=1** 
This allows you to drop duplicated frames at regular intervals. 

**interlaced=0** 
This is a simple interlacing filter from progressive contents. This interleaves upper (or lower) lines from odd frames with lower (or upper) lines from even frames, halving the frame rate and preserving image height.

**bluray_compat=0** 
Configure the encoder to be compatible with the bluray standard. It is a shorthand for setting "bluray-compat=1 force-cfr=1".

**constrained_intra=0** 
You can enable constrained intra prediction, which is required for the base layer of SVC encodes. This is an intra prediction technique where the video encoder limits the use of neighboring blocks as reference blocks in the intra prediction process. If you're using constrained intra prediction, you can configure video to not use neighboring blocks as reference blocks if the neighboring blocks were coded using inter prediction. By not using inter predicted blocks as reference blocks for intra prediction, the video encoder may create an encoded video bitstream that is more error resilient.
 
**bframes=0** 
You can set the maximum number of concurrent B-frames that x264 can use. Without B-frames, a typical x264 stream has frame types like so: IPPPPP...PI. With --bframes 2, up to two consecutive P-frames can be replaced with B-frames, like: IBPBBPBPPPB...PI. B-frames are similar to P-frames, except they can use motion prediction from future frames as well. This can lead to significantly better efficiency in terms of compression ratio. 

**weightp=0** 
Use this to enable use of explicit weighted prediction to improve compression in P-frames. Higher modes are slower.

**keyint=30** 
This sets the maximum interval between IDR-frames (aka keyframes) in x264's output. You can specify "infinite" to never insert non-scenecut IDR-frames. IDR-frames are 'delimiters' in the stream - no frame can reference data from the other side of the IDR-frame. As well as this, IDR-frames are also I-frames, so they don't reference data from any other frame. This means they can be used as seek points in a video.

**keyint_min=16** 
This sets the minimum length between IDR-frames. Very small keyint ranges can cause "incorrect" IDR-frame placement (for example, a strobing scene). This option limits the minimum length in frames after each IDR-frame before another can be placed.

**scenecut=0** 
This sets the threshold for I/IDR frame placement (read: scene change detection). x264 calculates a metric for every frame to estimate how different it is from the previous frame. If the value is lower than scenecut, a 'scenecut' is detected. An I-frame is placed if it has been less than keyint_min frames since the last IDR-frame, otherwise an IDR-frame is placed. Higher values of scenecut increase the number of scenecuts detected.

**intra_refresh=0** 
You can disable IDR-frames, instead H.264 uses intra coding for each macroblock in the frame every keyint_min frames. Blocks are refreshed in a horizontally scrolling column - the 'refresh wave'. This benefits low-latency streaming by making it possible to achieve more constant frame sizes than is possible with standard IDR-frames. It also increases the resilience of the video stream to packet loss. This option does reduce compression efficiency, hence only use it when needed.

**rc=crf**
rc stands for Rate Control. You can adjust the file data rate in several ways, the option shown here is CRF, or Constant Rate Factor. CRF is an encoding mode that adjusts the file data rate up or down to achieve a selected quality level rather than a specific data rate. CRF values range from 0 to 51, with lower numbers delivering higher quality scores.

**mbtree=0** 
This stands for macroblock tree rate control. Macroblock tree rate control improves compression by tracking how long different parts of an image last across frames. For parts of an image that stay the same, you don't need to continually save that data, only make a note that it continues to be there so you can use that as a reference to reconstruct that part of the frame later. 

**crf=25.0** 
This is related to the rc=crf command. CRF is an encoding mode that adjusts the file data rate up or down to achieve a selected quality level rather than a specific data rate. CRF values range from 0 to 51, with lower numbers delivering higher quality scores.

**qcomp=0.60** 
The default setting is 0.60. qcomp stands for quantizer curve compression factor. A setting of 0 will give you a constant bitrate while a setting of 1 will give you a constant quantizer. This can be combined with mbtree, but the higher your qcomp setting, the weaker the effect of the mbtree setting.

**qpmin=0** 
The default setting for this is 0 and raising this minimum is discouraged because it can negatively impact the quality of background areas in your frame. 
qpmin defines the minimum quantizer that H.264 will ever use. The lower the quantizer, the closer the output is to the input. 

**qpmax=51** 
The default setting for qpmax is 51. The default of 51 is the highest quantizer available for use in the H.264 spec, and is extremely low quality. This default disables qpmax. You can set this as low as the 30-40 range if you want to cap the minimum quality x264 can output, but adjusting it is not recommended.

**qpstep=4**
This allows you to set the maximum change in the quantizer between two frames. 

**ip_ratio=1.40** 
The default setting is 1.40. You can change the average decrease in quantizer for B-frames vs. P-frames, with higher values decreasing B-frame quality.

**aq=0**
aq stands for Adaptive Quantization. This helps distribute bits between macroblocks in your video. If you don't use it, it can underallocate bits to sections that lack detail. A setting of 0, as with other FFMPEG settings, means you will not use it at all. 

## Output to api.video
Now that you've got all the configuration settings for your streams and you've mapped them, you'll want to see some details about what will be output to your destination. 

Here you can see the destination, shown by the stream key and then a summary of details about your video and audio streams. The encoders being used are listed as well. We don't need to walk through everything listed here because we covered it in the earlier sections when we mapped the video and audio streams. FPS is frames per second. 

Now we can take a look at the lines that show us details about each chunk of data being streamed. Here's one of the lines: 

"FFMPEG:frame=65 fps= 55 q=12.0 size=29kB time=00:00:05.06 bitrate=  47.1kbits/s speed=4.26x"

The line is a snapshot where everything that is happening at that moment is reported to the terminal. It says that in this moment, you're streaming frame 65. The frames per second is 55, and the quality (q) is 12. The lower the number for quality, the better the video. The higher the number, the worse. The size of the chunk of data being streamed is also listed in kB with size. The time is the time from when the live stream started, and the bitrate is how many kbits per second yu're streaming. speed is how fast everything is streaming. 

## Conclusion
While this guide doesn't tell you everything about all concepts (for example quantization, which is too complicated to include in this post) I hope that this walkthrough helped explain what things are a bit more.
To help you further, you can go on [our Community](https://community.api.video/) or [start building](https://dashboard.api.video/register) now.



What do my video output live stream details from ffmpeg mean ? 

What do my video output live stream details from ffmpeg mean?

large_what-do-my-video-output-live-stream-details-from-ffmpeg-mean.png

medium_what-do-my-video-output-live-stream-details-from-ffmpeg-mean.png

small_what-do-my-video-output-live-stream-details-from-ffmpeg-mean.png

thumbnail_what-do-my-video-output-live-stream-details-from-ffmpeg-mean.png

what-do-my-video-output-live-stream-details-from-ffmpeg-mean.png

large_api-video-blog-product-updates.png

medium_api-video-blog-product-updates.png

small_api-video-blog-product-updates.png

thumbnail_api-video-blog-product-updates.png

api-video-blog-product-updates.png

Product updates

## What's .new at api.video?

We've been really busy building the best video streaming API around.  All of our teams are growing to meet the need of the rapid growth going on.  (Interested?  Check out the [careers page](https://jobs.api.video/).)

We recently launched [webhooks](https://docs.api.video/reference/create-and-manage-webhooks) that tell your backend when a live stream starts or finishes.  Our video player has undergone a number of [new features](https://docs.api.video/sdks/player/apivideo-player-sdk), and we've launched [a half dozen new API clients](https://docs.api.video/sdks/api-clients/apivideo-csharp-client), a React Native [Live Stream](https://docs.api.video/sdks/livestream/react-native-livestream-component) and [player](https://docs.api.video/sdks/player/apivideo-react-native-player) modules. There's so much more coming that we cannot wait to share with you!

## Why does your post say .new?

Aren't all these features just *new*?

Ahh, yes.  We have also launched a number of domains that showcase one of the basic premises of api.video: uploading videos for video on demand (VOD) playback.  

These all use the Top Level Directory ".new", and utilize the most basic function of api.video - a video upload:

* [embed.new](https://embed.new)
* [ingest.new](https://ingest.new)
* [mp4.new](https://mp4.new)

All of these videos are using synonyms to describe a video upload.

* [Embedding](https://api.video/what-is/embed/) a video is the ability to add external video content onto your webpage.  When your video is uploaded to api.video, the JSON response will contain the code for an iframe embed of your video.

* [Ingesting](https://api.video/what-is/ingest/) a video is the process of uploading and converting a video for streaming on demand.  All videos uploaded to api.video are ingested and made into [HTTP Live Stream (HLS)](https://api.video/what-is/http-live-streaming-hls/) videos for responsive and optimized playback.

* [mp4](https://api.video/what-is/mp4/) is the most common format of video on the web.  In the case of api.video, when you upload or ingest a video, you'll have a playable h.264 mp4 video ready to be shared in addition to the HLS video stream.

When you use these sites to upload a video, you'll see the progress of the video ingestion into api.video. Upon completion, get a JSON response of the completed upload, and retrieve links for an iframe *embed* and *mp4* playback.

After a few seconds, you can also refresh the video, and see the video on demand video stream right from the page:

large_screenshot-2021-08-09-at-21-06-11.png

medium_screenshot-2021-08-09-at-21-06-11.png

small_screenshot-2021-08-09-at-21-06-11.png

thumbnail_screenshot-2021-08-09-at-21-06-11.png

screenshot-2021-08-09-at-21-06-11.png

Give our demos a try, and if you like what you see, they all have links to the code on GitHub, so you can copy and reuse for your application. All you have to do is add your api.keys and delegated upload tokens to ensure the videos end up in your [api.video](https://api.video) account.

Finally - you might see all the links that point to definitions in this post. We're building a [video glossary](https://api.video/what-is/) to help you navigate all the terms that are sometimes thrown about when working with video on the web.

What's ".new" at api.video

small_dotnew-1.png

thumbnail_dotnew-1.png

dotnew-1.png

Authenticate

Python

You've prepared the perfect ad copy for your business, but now you're trying to figure out how you can personalize the ad for each business. One great way to do that would be to use a voice over tool that allows you to customize the content based on the location of your customers. Fortunately, this is available! By combining api.video with aflorithmic.ai's voice over this problem is easy to solve. 

## Imagine, if you will, that you own a pizza chain

To make this fun, let's imagine you are the owner of a popular pizza chain - Renzo's pizza chain. You have fifty different outlets and you've prepared the perfect ad: 

--Insert video here-- 

This ad is great for one of your locations, but you want people near all of your restaurants to know they can eat the best pizza for the least dough. For each location, you'd like to run this ad, but have it play information that tells the listener the city, address, day of the week and the time of the offer being described. 

No problem! We can do this in the tutorial today. Let's get started. 

## Prerequisites 

For this project, you're going to need: 

* An api.video account - [Sign up here!](https://api.video)
* An aflorithmic.ai account - [Sign up here!](https://console.api.audio/)

## Installation

We will use the [api.video Python client](https://github.com/apivideo/python-api-client) and [Aflorithic.ai's apiaudio library](https://docs.api.audio/recipes).

Installation for api.video: 
```pip install api.video```

Installation for Aflorithmic:
```pip install -U apiaudio```

### ffmpeg installation
If you want to run the project as-is, you'll also need to install ffmpeg. These instructions help you with installation on a mac. What you'll want to do is make sure you have brew installed. Then it's very easy, you just install with:

```brew install ffmpeg``` 

You need to install ffmpeg before you install the next two items.

### pydub and pyaudio installation
pydub and pyaudio can also be difficult to install, depending on your set up and what you've tried to install already. If you made the mistake of trying to install these before installing ffmpeg, then what you would do is first run:

```brew remove portaudio```

Then, reinstall this like so: 

```brew install portaudio``` 

After these steps, you should be able to successfully install the modules you'll need. Here's the commands: 

```brew pyaudio```

and 

```brew pydub```

## Project overview 
Here's what we're going to do with the example script today:

1. Prompt to collect the api.video API key and the Aflorithmic API key. 
2. Select our video from the Videos folder (for your own tweaks later you can drop other videos here to use, or use a different folder system to organize your content). 
3. Select the script we want from the Script folder and offer the user a preview of the script to make sure it's the right one. 
4. Select the localization .csv file we want to use with our script.
5. Create a sample audio file with the voice over, using the first line from the .csv file
6. Give the user the sample file so they can make sure it sounds like what they want.
7. Next we'll combine the first audio file with the video.  
9. We'll display that file for review by the user to make sure it looks right.
10. If the user approves the file, one by one we'll create an audio file, combine it with the video, tag each video with the information from the csv, and upload it for storage and hosting on api.video.
11. We'll return the user a list of video titles and a link to a playable copy of the final file. 

## Code sample 
Here is the code sample. It's a wizard that will walk you through all the steps. The complete project is available on github here: [https://github.com/apivideo/python-api-client/blob/master/examples/video_audio/README.md](https://github.com/apivideo/python-api-client/blob/master/examples/video_audio/README.md)

## Walkthrough the important stuff
A bunch of the demo is set up to walk you through the process of combining information. We don't need to go over each while loop, but let's go over some details regarding API behavior and the tools used to create the demo. 

### The script 
You can place your script into your code directly by using quotes. It could look like this (I'm saying could because there are a few different ways to set up your api.audio script): 

You can see that the script is split into three sections. This demo doesn't really make use of the features available per section so I'm not going to go into detail for this part. Personalization is achieved by using {{ }} around the name of a column from your csv spreadsheet. They can be used in whatever order you like. 

You can also choose to read your script from a .txt file. If you choose to do this, make sure to take the quotes off from the beginning and end or it will screw up the parser. A common error you will get will say there's a problem with creating a final file or working with a URL and it's usually because something broke before that point, so keep that in mind when debugging. 

In your code, when you set up your script, you'll use a command that looks something like this: 

```script = apiaudio.Script().create(scriptText=text, scriptName=script_details[0], moduleName=script_details[1], projectName=script_details[2])
```

In this snippet, you've already authenticated with your api key (```apiaudip.api_key = your_key```) so now you can work with the api's endpoints. 

The only required field is scriptText, which will contain the text of your script. However it's useful to provide the other names for reference. Be aware that you cannot delete projects or modules. After you set up your script this way, you'll be able to reference it in your code easily via scriptId. Like so:

```script.get("scriptId")```

### The audio file
For starters, when you create an audio file with api.audio, it names your file based on your project name and personalization parameters. In this demo, if you named your project "ad" then every audio file would begin with the word "ad." Next, it puts the headers for the csv file in alphabetical order, and adds the appropriate parameter next to each header. For example, our .csv file has the columns (in this order): 

* city
* address
* day_of_week
* offer_time

After each column title, the entry that appears in the audio file will appear. To separate each column, two underscores are used. Here's a sample:

ad__address_1353%20harlem%20street__city_springfield__day_of_week_tuesday__offer_time_6%20to%208%20pm

So something you'll possibly want to do is rename the files when they arrive. An easy way to handle this is with the built-in os module. 

When creating an audio file you'll do two steps, one is text-to-speech and one is mastering the audio. For text-to-speech you can pick a voice, how fast it will speak and then give it a dictionary containing the list of personalization terms you want to insert into your script. 

You can also choose a template, which will play some background music under your spoken audio. You can see in the demo I used "copacabana." To list voices or background music options, go to the [api.audio API reference docs](https://docs.api.audio/reference) and use the endpoint for listing voices or the endpoint for listing music. 
 
### The .csv
This demo reads information from a .csv file. If you want to read from something else, you can as long as your output for your program to work with becomes a list of dictionaries. .csv is pretty simple to use, so I went with that option.

### Playing a track from your application
You can play a track to check out the audio by using a variety of tools. For this one, I used pydub and pyaudio. These are fairly popular modules. In order to use them, however, audio must be converted to .wav. You will see in the code  that two imports are made from pydub: 

```
from pydub import AudioSegment
from pydub.playback import play
```

These allow us to play straight from the terminal or wherever we may be. The code to convert to .wav and play is very straightforward:

```
wav_track = AudioSegment.from_mp3(file)
wav_track.export(audio_title, format="wav")
```

There are other choices available for converting, but api.audio returns .mp3 files, so we use the from_mp3 choice. 

After we have the track, playing it is as simple as this:

```
play(wav_track)
```

### Merging audio and video 
Prior to uploading your video to api.video, you will want to add the sound and video together. This can be accomplished with ffmpeg, which you need to import to use pydub and pyaudio anyway. The code for merging audio and video is:

```
input_video = ffmpeg.input(video)
input_audio = ffmpeg.input(wav_track)
title = title + ".mp4"
ffmpeg.concat(input_video, input_audio, v=1, a=1).output(title).run()
```

This will produce an mp4. You can then upload it to api.video. 

### Upload to api.video
For details about uploading a video with api.video, you can check out the tutorial about it here: [Upload a Video with the api.video Python Client](https://api.video/blog/tutorials/upload-a-video-with-the-api-video-python-client/)

Something to note is to upload a file, it must be in the same folder as your application or it will not upload.

Once it's uploaded, you can retrieve the .mp4 from the response and play it right away in your browser using the built-in webbrowser module. 

To retrieve the mp4 from the response, you do this:

```
link_mp4 = video_response['assets']['player']
```

And then you can open the link like this:

```
 webbrowser.open(link_mp4)
 ```

This will let you make sure everything combined properly so that the audio matches with the video the way you want. 

### Create all the localized videos
After all the steps to make sure you're creating the right type of video, you can use the recipe from api.audio with a couple of tweaks to create all your new videos with personalized ads by location, then upload them for hosting to api.video.

This demo deletes every video you upload right after the upload happens so you don't end up sitting with fifty videos in a folder.

Thanks for reading! Happy coding. :) 

Localize Advertisement Videos with Personalized Voice Overs!

api.video + aflorithmic.ai: Localize Advertisement Videos with Personalized Voice Overs!

When there are a large number of attendees on a Zoom call, the call can become very laggy, and the video and audio quality is not always as good. When there is a call with a large number of participants - you may be in a case where only a few attendees are participating and most of the attendees are 'listeners.'  If that is the case, you might consider placing the listeners on a live stream - where they can listen to the meeting, but they are not on the actual Zoom call, which will make the interaction between the active participants easier.

In this post, we'll walk through the steps to add an api.video live stream to your Zoom call. Here's a video walking through the setup as well:







## Set up

In order to livestream your Zoom calls, you must be on a paid plan.  This feature is not available on the "Basic" free plan.

Go to your Settings page, and choose "in a meeting (advanced)"


medium_screenshot-2021-07-26-at-12-21-31.png

small_screenshot-2021-07-26-at-12-21-31.png

thumbnail_screenshot-2021-07-26-at-12-21-31.png

screenshot-2021-07-26-at-12-21-31.png

In this section, you'll find the "Allow livestreaming of meetings" section. Turn on the 4th option "Custom Live Streaming Service."  You can add a text comment - in the screenshot above, I added 'api.video,' but you could leave this blank.

## Creating the meeting


Adding the live streaming settings is easiest from the browser.  In your Zoom account, create a meeting.  Do all the normal things, like setting the date & time.  When done, press "Save"

A page will load with a summary of your meeting, but at the bottom is a section for setting up your live streaming:



large_screenshot-2021-07-26-at-12-35-30.png

medium_screenshot-2021-07-26-at-12-35-30.png

small_screenshot-2021-07-26-at-12-35-30.png

thumbnail_screenshot-2021-07-26-at-12-35-30.png

screenshot-2021-07-26-at-12-35-30.png

When you click the button to Configure your live stream, you'll be asked for 3 things:

* Stream URL: rtmp://broadcast.api.video/s
* Stream Key: Unique to your stream
* Viewing URL: The page where viewers can watch the stream


medium_screenshot-2021-07-26-at-12-43-01.png

small_screenshot-2021-07-26-at-12-43-01.png

thumbnail_screenshot-2021-07-26-at-12-43-01.png

screenshot-2021-07-26-at-12-43-01.png

These values are all available on the summary page of your live stream on your [dashboard](https://dashboard.api.video/) as shown in the above screenshot (Stream Key is obfuscated for security reasons.

Once you enter these values on the Zoom meeting, you are set - until the meeting actually starts.

## In the meeting

Even though you have set up the Live Stream, it is not actually active until you turn it on.  You do this in the "More" setting in the meeting, and choosing the "Live on Custom Streaming Service" button:

large_screenshot-2021-07-26-at-11-29-58.png

medium_screenshot-2021-07-26-at-11-29-58.png

small_screenshot-2021-07-26-at-11-29-58.png

thumbnail_screenshot-2021-07-26-at-11-29-58.png

screenshot-2021-07-26-at-11-29-58.png

Zoom will open a webpage, and then redirect to the "watch page."  When you return to the Zoom meeting, you'll see a notification in the upper right hand corner:



medium_screenshot-2021-07-26-at-11-33-48.png

small_screenshot-2021-07-26-at-11-33-48.png

thumbnail_screenshot-2021-07-26-at-11-33-48.png

screenshot-2021-07-26-at-11-33-48.png

## Now your meeting is Live Streaming!

In summary, there are a few steps to set up and then turn on your Zoom -> Live Stream.  But once they are set up, it is a pretty simple task to ensure that your Zoom conference calls are live streamed to your wider audience.

If you run into any issues, please reach out to us on the [api.video community](https://community.api.video)


Live stream your Zoom call with api.video

Add an api.video live stream to your Zoom call

small_zoomapivideo.jpg

thumbnail_zoomapivideo.jpg

zoomapivideo.jpg

webhooks

Analytics

NodeJS

One of the most satisfying features of livestreaming is seeing a live counter of how many people are watching your live stream.  In this demo, we’ll build a counter that gives a real time count of the number of viewers watching a live stream.

## api.video livestreams

Each livestream at api.video can be used over and over. It is a conduit for your livestreams.  There is a RTMP url that you use to send your livestream to api.video, and a playback url that you can embed in your website.  When you look at a livestream on your [api.video dashboard](https://dashboard.api.video/), you’ll see all the connection details (some are obfuscated in the screenshot) to connect your livestream. 

large_screenshot-2021-07-22-at-06-12-10.png

medium_screenshot-2021-07-22-at-06-12-10.png

small_screenshot-2021-07-22-at-06-12-10.png

thumbnail_screenshot-2021-07-22-at-06-12-10.png

viewer-count-video.png

Right underneath the thumbnail of the livestream, you can see a viewer count.  In the screenshot above it is at 632. That is the count of historical views for this livestream - a sum of all the views for every livestream that has been run. While this is an interesting stat, this is not exactly what we want to see during a livestream.

This NodeJS function takes your liveStreamId, and calls the analytics endpoint to get the total number of sessions that have occurred for that live stream:

```
function getLiveSessionCount(liveStreamId){
 
   return new Promise(function(resolve, reject){
       console.log(liveStreamId);
       var pageSize=1;
       var currentPage = 1;
       params = {
           "liveStreamId": liveStreamId,
           "pageSize":pageSize,
           "currentPage":currentPage
       }
       //get all sessions for livestream
       var sessionList = client.rawStatistics.listLiveStreamSessions(params);
       sessionList.then(function(liveSessionList){
           //get total sessoin
           var sessionCount = liveSessionList.pagination.itemsTotal;
           console.log("live sessions" , sessionCount);
           resolve(sessionCount);
       }).catch((error) =>{
           reject(error);
       });
   });
}

```

## Counting the views

To get an accurate count of viewing sessions during a livestream, we need to grab the livestream count when the stream starts (all of the views PRIOR to the current stream).  As the stream progresses, the number will increase, but a simple difference ```currentCount - startCount``` will provide the number of sessions that occurred during the current stream.

### Live stream webhooks

In July 2021, we launched 2 new webhooks: ```live-stream.broadcast.started``` and ```live-stream.broadcast.ended```.  These webhooks announce whenever one of your live streams begin/end broadcasting. 

When the ```live-stream.broadcast.started``` webhook fires, our webhook listener identifies that a live stream has started.  Then it calls the getLiveSessionCount function to get the starting count of sessions.

```
app.post("/receive_webhook", function (request, response) {
   console.log("new video event from api.video");
    let event = request.body;
   let body =request.body;
   let type = body.type;
   let emittedAt = body.emittedAt;
   webhookResponse = "";
   if(type =="live-stream.broadcast.started"){
       liveStreamId = body.liveStreamId;
       liveStreamStatus = true;
       webhookResponse = "event: " +type+ " at: "+ emittedAt+ " LiveStream,Id: "+liveStreamId+ "  has started.";
      
       //change the broadcasting status in the JSON pbject
       broadcastingStatus[liveStreamId]=liveStreamStatus;
       //TODO - get the number of views at start
       startViews = getLiveSessionCount(liveStreamId);
       startViews.then(function(startcounter){
           console.log("number of views when broadcast starts", startcounter);
           viewersAtStartOfStream[liveStreamId] = startcounter;
           webhookResponse = "event: " +type+ " at: "+ emittedAt+ " LiveStreamId: "+liveStreamId+ "  has started. There have been "+startcounter+" at the beginnig";
 
       });
      
    } else if (type =="live-stream.broadcast.ended"){
       liveStreamId = body.liveStreamId;
       liveStreamStatus = false;
       broadcastingStatus[piLiveId]=liveStreamStatus;
       webhookResponse = "event: " +type+ " at: "+ emittedAt+ " LiveStreamId: "+liveStreamId+ "  has stopped.";
    }
  
   //console.log(headers);
   console.log("response",webhookResponse);
 
  
   response.sendStatus(200); 
 });


```

Now, as the streaming progresses, the website polls /getLivecount every three seconds:

```
// Send list of the new count of viewers every x seconds
app.get("/getLivecount", function (request, response) {
 
 
   var LiveId = request.query.live;
   console.log("LiveId", LiveId);
   console.log(viewersAtStartOfStream);
   startCount = viewersAtStartOfStream[LiveId];
   console.log("startCount", startCount);
   //we have liveid get new user count
   var currentCount = getLiveSessionCount(LiveId);
           currentCount.then(function(currentWatchCount){
 
               console.log(startCount + " " + currentWatchCount);
               numberOfWatchers = currentWatchCount - startCount;
               console.log("numberOfWatchers", numberOfWatchers);
               response.send("There are " +numberOfWatchers + " watching this stream!");
           }).catch((err) => {
               console.log(err);
           });
 });

```

And this returns the difference from the start of stream (stored in an array on the server), and the current count.  Voila, a simple view counter!

##  Conclusion

In this demo, when the live stream begins broadcasting, we utilize the [live stream started webhook](https://docs.api.video/reference/api/Webhooks#create-webhook), which broadcasts that the stream has started. We determine the ‘seed’ number of sessions using the [Live stream session analytics](https://docs.api.video/analytics/overview). Now we know the “0” for this live streaming session.

We can call the same endpoint every 3 seconds and report the growth in the number of sessions.  Each one of these is a new loading of the live stream video player - counting as a new viewer of the stream. This is then added to the page to indicate how many viewers are watching the live stream.

This demo is live at [watch.a.video/broadcast](​​https://watch.a.video/broadcast?streamId=li400mYKSgQ6xs7taUeSaEKr). To begin the stream, head over to [livestream.a.video](https://livestream.a.video) and begin the stream. To grow the number of viewers, you must open [watch.a.video/broadcast](​​https://watch.a.video/broadcast?streamId=li400mYKSgQ6xs7taUeSaEKr) in multiple incognito/private browser tabs (since the session is browser window based).

Try it out, and tell us what you think! If you’d like to look at the code to modify for your app, it is live on [Github](https://github.com/dougsillars/watchLivestream).


Count your live stream viewers with api.video

thumbnail_counter.jpeg

counter.jpeg

In today's fast-paced digital landscape, the explosive growth of videos has revolutionized the way we consume information, connect with others, and engage with brands. Whether it's on social media, streaming platforms, or corporate websites, videos have become an integral part of our online experience.

&nbsp;

And behind the captivating visuals, lies a treasure trove of data waiting to be unraveled. Today, we recognize the importance of data-driven insights in shaping strategies, enhancing user experiences, and achieving desired outcomes. By meticulously examining viewer behavior, engagement patterns, and demographic insights, we can uncover actionable intelligence that allows us to personalize experiences and unlock untapped potential.

&nbsp;

For this very reason, **api.video has recently launched real-time video Analytics which allow you to dive deeper into the numbers behind your videos**. Let's learn a little more about it below. 

## How does Analytics help you?

Analytics help you get in depth insights for your videos and live streams. It will help you answer questions like: 

&nbsp;

- Which videos are being viewed the most today or this week or this month?
- Where in the world is my content being viewed?
- Which devices, browsers, and operating systems are viewers using the most?
- What time of the day is my content most engaging?

## What do you get with Analytics?

Analytics provide you engagement data related to your videos and live streams. For instance, you can:

&nbsp;

- get the number of plays for a specific video for a period like the current day, current week or the last 30 days
- get the number of plays by country
- get the number of plays for specific devices, browser agents, and operating systems.


## How does it work?

Api.video's solution uses playback data to analyze and segment your viewers. 

&nbsp;

- Numbers are automatically collected for every video or live stream if played with the built-in api.video player
- Each interaction with the video content generates a play event
- Play events are reported in real time and can be instantly viewed on the api.video dashboard or retrieved through the API
- Third-party players are also supported through the provided analytics plug-ins (any HTML5 player that supports event-based reporting)
- The data is retained for 30 days

&nbsp;


![pexels-lukas-590020.jpg](https://datocms-bucket.s3.eu-central-1.amazonaws.com/pexels_lukas_590020_4c03e9015f.jpg)

## The best part - it is all real-time data!

Yes, you read that right! All the data you see under the Analytics section is collected and computed in real-time. We all know time and speed = money, which is why this data will be available immediately for your usage and analysis. This real-time data can be especially useful if you are using it to keep track of live stream engagement or manage a lot of user-generated content.

## How do you start using Analytics?

To start viewing data, you can use the dedicated API endpoint or check the dedicated page on the api.video dashboard if you are looking for convenient access and viewing.

&nbsp;

Check out the detailed guide in our [analytics documentation](https://docs.api.video/analytics/overview) for more details on this, and our [FAQ section](https://help.api.video/en/articles/7983849-analytics) for some common questions you may have. In production, you can activate Analytics from your Dashboard. You will need to be the owner of the workspace account to do so.

&nbsp;

__[Sign-up on api.video](https://dashboard.api.video/register) now and get the complete toolkit for your videos at one place!__

Introducing Analytics at api.video for better video insights

Analytics at api.video for better video insights

large_video_meets_data_not_rounded.jpg

medium_video_meets_data_not_rounded.jpg

small_video_meets_data_not_rounded.jpg

thumbnail_video_meets_data_not_rounded.jpg

video_meets_data_not_rounded.jpg

Understanding your audience is key to successful video and live stream content delivery. Whether you deliver your own content, or develop a mobile app which enables creatives to deliver their own, leveraging data and analytics can help you. With api.video's [Analytics solution](https://docs.api.video/analytics/overview), you gain vital insights into the viewers’ preferences and behaviors, enabling you or your users to make data-informed decisions in content creation, and engage better with the audience.

&nbsp;

**In this tutorial, we’ll go through two methods that you can use to retrieve analytics data for your videos and live streams.**

## What data?

The mainspring of api.video’s Analytics solution are **viewer events**. Metrics are generated every time a member of your audience engages with your video or live stream.

&nbsp;

There is a wide selection of available **metrics**, enabling you to measure user interaction in a variety of dimensions. Metrics can help you count: 

&nbsp;

- `play`: the number of times your content has been played,
- `impression`: the number of times your content has been loaded and was ready for playback,
- `play-total`: the total number of times a specific content has been played,
- `play-rate`: the ratio that calculates the number of plays your content receives divided by its impressions,
- `start`: the number of times playback was started,
- `end`: the number of times playback has ended with the content watch until the end,
- `impression-time`: the time in milliseconds that your content was loading for until the first video frame is displayed,
- `watch-time`: the cumulative time in seconds that the user has spent watching your content.

&nbsp;

You can define the way you want to see these metrics, using aggregations like `count`, `total`, `average`, and `sum`.

&nbsp;

Depending on the data you are viewing, api.video’s analytics solution can help you group interaction data by these **dimensions**:

&nbsp; 

- the date and time of the viewer event,
- the ID of a specific video or live stream that generated events
- the countries where your viewers are based,
- the device type your viewers are using, like `phone` or `computer`
- the browser your viewers are using, like `Chrome` or `Firefox`
- the operating system that your users are running, like `iOS` or `Windows`
- the [tags](https://docs.api.video/vod/tags-metadata) used on a video.

&nbsp;
 
api.video helps you read and filter this data, enabling you to segment and understand your audience better.

## Requirements

Before we discuss the two methods, let’s talk about some requirements. api.video can only generate analytics data when you meet these simple requirements:

&nbsp;

1. You have already uploaded a video or are broadcasting a live streams.
2. These videos or live streams already had viewers that create interaction events.
3. You use the api.video player to deliver your content. You will meet this requirement when you integrate one of [api.video’s Player SDKs](https://docs.api.video/sdks/player), or embed the video or the live stream into a website, or simply share the video or live stream URL with your viewers.

You can also use a different player solution, however, you will need to integrate api.video’s [analytics plug-ins](https://docs.api.video/sdks/player#player-analytics-sdks), which are available for [hls.js](https://github.com/apivideo/api.video-hlsjs-analytics), [video.js,](https://github.com/apivideo/api.video-videojs-analytics) [Android](https://github.com/apivideo/api.video-android-player-analytics), and [iOS](https://github.com/apivideo/api.video-swift-player-analytics).

&nbsp;

Once you fulfill these requirements, you’ll immediately be able to retrieve analytics using both methods discussed in this tutorial.

&nbsp;

*Note that when using api.video’s **Sandbox environment**, the extent of data that you can retrieve is limited to the last 24 hours.*

## The no-code way

By far the easiest method to get analytics for your videos and live streams is through the [Analytics page in the api.video dashboard](https://dashboard.api.video/analytics). The dashboard shows the number of play events grouped by some of the most useful dimensions that can help you answer questions like:

&nbsp;

- Which videos or live streams are the most popular this week?
- What time of the day is your content most engaging?
- Which country are most of your viewers based in?
- Which devices, browsers, and operating systems are viewers using the most?

## The integrated way

For those that prefer a more hands-on approach, we’ll dive into how you can leverage our API to retrieve analytics data and build out some typical Analytics use cases.

&nbsp;

api.video offers 3 dedicated API endpoints that you can use to programmatically retrieve data about your content:

&nbsp;

- [`/data/metrics/{metric}/{aggregation}`](https://docs.api.video/reference/api/Analytics#retrieve-aggregated-metrics) to retrieve aggregated metrics,
- [`/data/buckets/{metric}/{breakdown}`](https://docs.api.video/reference/api/Analytics#retrieve-metrics-in-a-breakdown-of-dimensions) to retrieve metrics in a breakdown of dimensions,
- [`/data/timeseries/{metric}`](https://docs.api.video/reference/api/Analytics#retrieve-metrics-over-time) to retrieve metrics over time.

&nbsp;

Visit the **[API reference](https://docs.api.video/reference/api/Analytics)** for details about the Analytics API, including request parameters and sample responses.

### 1. Set up the **api.video client**

Let's initialize the [api.video client SDK](https://docs.api.video/sdks/api-clients) in your environment, using an example **in Node.js**:

### 2. Create a request

The client SDK will require your API key, which you can find [in the dashboard](https://dashboard.api.video/project-settings/api-keys). Check out the [Authentication guide](https://docs.api.video/reference/authentication-guide) if you want to understand the different authentication methods you can use with api.video.

&nbsp;

Let’s say you want to know **the number of plays your French audience members have created over 5 days.**

&nbsp;

To get this data, use the [`/data/buckets/{metric}/{breakdown}`](https://docs.api.video/reference/api/Analytics#retrieve-metrics-in-a-breakdown-of-dimensions) endpoint.

Notice that we’re passing the `from` and `to` parameters to define a timeframe. We set the `play` metric to see the number of times your content has been played. We’re also using the `country` dimension, which groups data based on countries your viewers are from. We can then filter the data set using the `filterBy` parameter, with the specific country you are interested in: `FR`.

&nbsp;

Here’s an example response payload for this request:

In the response, `metricValue` shows the value we wanted to see, and `dimensionValue` shows the country we filtered for.

&nbsp;

Now let’s try a different approach. Maybe you updated your app to speed things up. Let's see some functional performance and retrieve **the average time in milliseconds that your content was loading for until the first video frame is displayed**.

&nbsp;

To get this data, use the [`/data/metrics/{metric}/{aggregation}`](https://docs.api.video/reference/api/Analytics#retrieve-aggregated-metrics) endpoint.

Again, we’re passing the `from` and `to` parameters to define a timeframe. One month should be enough. We set the `impression-time` metric to see the load times, with the `average` aggregation.

&nbsp;

Here’s an example response payload for this request:

Check out the **complete list of dimensions** and **example response payloads** for both success and error cases in [the API reference](https://docs.api.video/reference/api/Analytics).

### 3. How to use this data?

When building an application or website where you serve videos or live streams, you can find some creative ways to leverage analytics data:

&nbsp;

- Create **data visualizations** for your users. This could include graphs and charts showing views over time, peak viewing periods, or geographic distribution of the audience.
-  **Localize Content.** Use geographic data from play events to tailor content to specific regions, accommodating regional preferences or languages.
- **Create recommendations**. Find the most popular, or even the least popular videos and show them as recommended videos for your viewers.

## Conclusion

With api.video’s Analytics solution, you're not only delivering content; you're unlocking a world of data that helps you connect more meaningfully with your audience. Whether you're aiming to expand your reach, tailor content to specific regions, or simply understand your audience better, api.video’s Analytics is your gateway to smarter content strategy.

&nbsp;

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

How api.video’s Analytics can help you enhance your content strategy

api.video Analytics helps you enhance your content strategy

Blog_Analytics.png

Use api.video Analytics to mark viewer density with Observable

Api.video Analytics: Add markers representing viewer density per city to a map with Observable

 Build a Choropleth Map with api.video Analytics

Api.video Analytics: Build a Choropleth Map (and find out what one is)

Using analytics to analyze where to edit a video

Leverage api.video’s Analytics to enhance your content strategy

How many people have watched my video?

How much of my video are people watching?

Is there a common abandonment time?

Are my users skipping ahead in the video?

These are questions that can be solved with api.video's [analytics](https://docs.api.video/reference/api/Analytics).  

## Now available with external players

api.video offers video encoding, hosting, delivery and analytics.  If you do not want to use our player (or already have an integration with another player), you can use your [3rd party player to deliver the video](https://api.video/blog/tutorials/using-api-video-with-external-video-players/). 

Until now, when you used an external player, you lost the opportunity to gain any insights from our analytics engine. We have now launched libraries for [videojs](https://github.com/apivideo/videojs-player-analytics), [hlsjs](https://github.com/apivideo/hlsjs-player-analytics), and a general [analytics package](https://github.com/apivideo/player-analytics), allowing you to integrate api.video analytics into your customized 3rd party video player!

## How does it work?

Let's look at an integration with videoJS. Here's a simple page that loads a video from api.video into videoJS, (and has added in analytics):


```
<head>
  <link href="https://vjs.zencdn.net/7.10.2/video-js.css" rel="stylesheet" />
  <script src="https://vjs.zencdn.net/7.10.2/video.min.js"></script>
  <script src="https://unpkg.com/@api.video/videojs-player-analytics"></script>

  
  
</head>

<body>
  <video
    id="my-video"
    class="video-js"
    controls
    preload="auto"
    width="1280"
    height="720"
    poster="https://cdn.api.video/vod/vi4blUQJFrYWbaG44NChkH27/thumbnail.jpg"
    data-setup="{}"
  >
    <source src="https://cdn.api.video/vod/vi4blUQJFrYWbaG44NChkH27/hls/manifest.m3u8" type="application/x-mpegURL" />
    
      To view this video please enable JavaScript, and consider upgrading to a
      web browser that
      <a href="https://videojs.com/html5-video-support/" target="_blank"
        >supports HTML5 video</a
      >
    </p>
  </video>

  <script>
             videojs.registerPlugin('apiVideoAnalytics', VideoJsApiVideoAnalytics);
            
             var player = videojs('my-video');
	         player.apiVideoAnalytics();
			 
         </script>
</body>
```

To add analytics, we add the script in the head of the document:

```
 <script src="https://unpkg.com/@api.video/videojs-player-analytics"></script>
```

and then to add the analytics engine, we add the JavaScript at the end of the page:
* registering the api.video analytics plugin
```
 videojs.registerPlugin('apiVideoAnalytics', VideoJsApiVideoAnalytics);
```
* assigning a variable to the player
```
 var player = videojs('my-video');
```
* connecting the player to the analytics plugin
```
player.apiVideoAnalytics();
```

and that's all there is to it!

## Can I add metadata to the analytics?

Yes! If you replace: 

```
player.apiVideoAnalytics();
```

with:

```
      player.apiVideoAnalytics({
        metadata: {
          player: "videojs"
        }
      });
```

you can collect [dynamic metadata](https://api.video/blog/tutorials/dynamic-metadata/).  In this case, I am assigning the value videojs to the player variable.  Now, whenever anyone watches a video using this videoJS player, it will be recorded in the dynamic metadata as such (so I can break down the playback across different devices).

Querying the analytics, we can see this in action:


```
		{
			"session": {
				"sessionId": "ps4ZrdWqAR8mevHi4IwHoACf",
				"loadedAt": "2021-04-01T11:07:25+00:00",
				"endedAt": "2021-04-01T11:07:25+00:00",
		*		"metadata": [
					{
						"key": "player",
						"value": "videojs"
					}
				]*
			},
			"location": {
				"country": "United Kingdom",
				"city": "Chesham"
			},
			"referrer": {
				"url": "https://jsfiddle.net/",
				"medium": "unknown",
				"source": "unknown",
				"searchTerm": "unknown"
			},
			"device": {
				"type": "computer",
				"vendor": "unknown",
				"model": "Other"
			},
			"os": {
				"name": "Mac OS X",
				"shortname": "Mac OS X",
				"version": "11.2.3"
			},
			"client": {
				"type": "unknown",
				"name": "Chrome",
				"version": "89.0.4389"
			}
		}
```

## Conclusion

We are working to make api.video integrate easily into your infrastructure.  If you use a 3rd party player, you are no longer prevented from using our analytics to study the playback of your videos.

Grab the appropriate library, and try it today!

[videojs](https://github.com/apivideo/videojs-player-analytics)

[hlsjs](https://github.com/apivideo/hlsjs-player-analytics)

[General analyitics package](https://github.com/apivideo/player-analytics)

New feature: Analytics libraries for 3rd party video players!

43160471697fbafef276c.jpg

In the classic movie *Field of Dreams*, a mysterious voice whispers to Kevin Costner “if you build it, they will come.”  


<video autoplay muted loop>
		<source src="https://media.giphy.com/media/gZuxOq7zSL5DO/giphy.mp4">
</video><br/><br/>


His belief of this statement completely transformed his life and drove him to build a baseball stadium in the middle of a cornfield in Iowa… and they came…<br/>


<video autoplay muted loop>
		<source src="https://media.giphy.com/media/z3WMjg3hu3ce4/giphy.mp4">
</video><br/><br/>


## If you Stream it...

You've created some awesome videos, and uploaded them to api.video.  Great work - it looks awesome.  

Here is a video that we posted in our blog post announcing our new video player:

<iframe src="https://embed.api.video/vod/viTLpKB231ATWOWjkHgi9bf#autoplay#loop" frameborder="0" scrolling="no" allowfullscreen=""></iframe>
<br/><br/>

## ...Who will come?

Eventually you want to know, how many people came to see my video?  What can I learn about them? Enter api.video’s powerful [video analytics](https://docs.api.video/reference/api/Analytics) API. Using the API, we can transfer all of the view data form our videos into our favourite database, and learn about the viewers of our videos.

Let’s start with grabbing the viewing details for a video. In this case, I’ll use this Planets video that my daughter recorded for her class on astronomy:

<iframe src="https://embed.api.video/vod/vi16NDdXmGxk5QSggW54qw0v#autoplay#loop"  frameborder="0" scrolling="no" allowfullscreen=""></iframe>

The url for this video is: https://embed.api.video/vod/vi16NDdXmGxk5QSggW54qw0v

First I must [authenticate](https://api.video/blog/tutorials/authentication-tutorial/) myself at API.video, and I receive an access token that is good for an hour.

With the token, I can use the videoId to request all of the view information about my video with the [analytics API](https://docs.api.video/reference/api/Analytics).  The videoId for the video is the value at the end of the url (vi16NDdXmGxk5QSggW54qw0v):




In this case, I am requesting 25 results per page, and page one of the data.  That’s actually fine, since I know there are only 19 views on this video.  

The JSON result is pretty long, but here is what one entry looks like:


To me, this is super cool.  A person in Vietnam, using Firefox on Ubuntu, watched this video in June!  And there are 18 more of these to look at and to parse.

### Demo

We have created a demo that takes a videoId and counts the country, device and browser for each view, and places the results on a page. You can try it out at [whoswatched.a.video](https://whoswatched.a.video).

In order to look at the data, I am going to suck the JSON file into Couchbase - a database that uses JSON to create a "table" format similar to SQL. This will allow me to run queries on the JSON much like one would run a database query.

### Creating a database in Couchbase:

Download and install [Couchbase](https://www.couchbase.com/) on your computer.  When the install is complete, you’ll have an admin dashboard open in your browser (on my Mac it is running on localhost:8901).  We’d like to add in our api.video JSON file into a data bucket.  To create the bucket - navigate to the Bucket section and click the "ADD BUCKET" button. I have the memory set at the minimum 100 MB (there are all of 19 entries after all!).


Great - now we have our data bucket added.  Now we’ll want to import the JSON from api.video, so we can do our analysis.  This is done in the terminal using the ```cbimport``` command:

My username is Administrator with password 123456 (Google Chrome is mighty peeved about my use of an insecure password on localhost), adding a json file into the videoStats bucket.  Each video view has a sessionId, so I use that as a unique key.

I get a success message in my terminal, and looking back at the Couchbase admin panel under Documents, I can see each entry from the JSON has been added:


Now we must index the data. In the Query Editor, enter:

Now we can do data analysis of our video views. For example, to understand the number of views per country:

That’s pretty cool!  


## Live Stream Analytics

We can do exactly the same thing with live stream analytics. Note: these only show “views” of a live stream.  If you run a live stream and no one watches - there will be no analytics reported.  Further - if your live streams are saved as video on demand (VOD) for later use - any VOD analytics are saved with the newly created VOD video, and will have no connection to the original live stream.

Let’s look at a live stream that has a number of views.  On the [api.video](https://api.video) homepage, we have a demo that allows you to livestream right from the homepage.  The live streamer then “watches” their stream in the browser at the same time that they are broadcasting - guaranteeing that every live stream gets at least one viewer (in the same location as the live streamer!)

The API call is similar to that of the VOD request, I just use the 'live-streams' endpoint as opposed to the 'videos' endpoint I used above.

### GeoLocation  


The live stream demo is hosted in North America and in Europe, and we use geolocation to direct our users to the correct server. Let’s see how well our load balancers are doing. Traffic directed to North America is on the left, and European traffic is on the right:


It looks like our load balancing is doing a bang up job. :)


Combining the two sets of data (I just created a new bucket with all the data added) allows us to see that api.video’s home page has been live streaming all around the world:


### Devices & browsers

Most of the streams are from desktop machines. All 28 phone instances correspond directly to 28 Android devices.(This is due to a limitation in Safari that prevents the demo from working on any iOS device.)  Of our Android users, we see 25 using Chrome, 1 Samsung Internet, 1 Opera (and one hidden variant.)

Desktop users are mostly Windows and Mac (and pretty evenly distributed), but also a good number on Linux/Ubuntu).


## Conclusion


The video analytics offered by api.video allow you to better understand who is consuming your content. In this post, we've walked through the steps to extract the data using the Analytics API in JSON format, and then ingested the data into a database for fast and easy queries.  

We used this data to see how the live stream demo on the api.video home page was used in July 2020.

How are you using api.video's analytics? Drop us a note in the [community forum](https://community.api.video) with your use cases!

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

Blog

AI >< Video: The Video Model Hub unveiled