Video watermarking

Normal

medium_screen-shot-2021-01-26-at-11-48-47-am.jpg

small_screen-shot-2021-01-26-at-11-48-47-am.jpg

thumbnail_screen-shot-2021-01-26-at-11-48-47-am.jpg

screen-shot-2021-01-26-at-11-48-47-am.jpg

Erikka Innes

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

Python

One of our most requested features is video **watermarking**. 
A video watermark is a visible overlay on a video that can be text, a logo, or other image type. 

Usually, a watermark serves some purpose like increasing brand awareness by displaying your company logo, or it might prevent someone from claiming a video is their work. Sometimes a watermark might prevent you from putting the content into production - for example at api.video we watermark our sandbox videos since sandbox video content is intended for proof-of-concept testing. A watermark might also present details about privileges you have regarding the video content. 

Whatever your reason for watermarking, you can now use api.video to add watermarks to your account, then add them to your video content when you create a new video for the first time or you want to update an existing video. We'll walk through the different options in this tutorial. 

## Pre-requisites 

For this tutorial, you will need: 

* api.video account - [Sign up here](https://dashboard.api.video/register)
* api.video Python client - [Python client](https://github.com/apivideo/api.video-python-client)
* An image to use as a watermark, png or jpg 
* The video ID for a video you've already uploaded

## Installation 

Install api.video's Python client with `pip install api.video` 

## Code sample 

The code sample we're using is this: 

## Code walkthrough

What you'll be doing in the code is creating a watermark, then retrieving the watermark ID and referencing it when you upload a video that you want to display your watermark on. 

At the end, your watermarked video will be something like this:

A sample watermark of the api.video logo on a video of the river.

large_watermark.png

medium_watermark.png

small_watermark.png

thumbnail_watermark.png

watermark.png

NOTE: During the walk through, we'll go over how to move the watermark around the video and resize it. Please be aware that you must upload a new video with your new dimensions each time. 

1. The first thing to do is initialize the client and connect.

`client = apivideo.AuthenticatedApiClient("your API key here")

client.connect()
`

2. Next, we prepare our watermark (in this case I've selected the api.video logo and placed my image in the same folder as my code sample) for upload: 

`watermarks_api = WatermarksApi(client)

file = open('logo_orange.png', 'rb') # file_type | The .jpg or .png image to be added as a watermark.`

3. We send the file to api.video:
`api_response = watermarks_api.upload(file)`

4. We check that our file was successfully sent and retrieve the watermark ID which we'll need if we want to add it to a video. 
        
`pprint(api_response)
pprint(api_response['watermark_id'])
`

5. Now we need to create a video container to upload a video into. If you've checked out our other tutorials, you know that video upload is a two part step. You create your container with metadata, then you upload your video into the container. We'll start by preparing to use the video endpoint and setting up our video payload with our watermarking information: 

`videos_api = VideosApi(client)

video_creation_payload = {
    "title":"Sample video",
    "description": "Show a watermarked video",
    "watermark": {
        "id": watermark_id,
        "top":"20px",
        "left":"20px",
        "opacity":"70%",
    },
}`

6. Send the video data in to api.video to create a container to upload your video into, then retrieve the video ID: 

`api_response = videos_api.create(video_creation_payload)
video_id = api_response["video_id"]
`

7. Now with our video ID we can upload a video: 

`file = open("test_vid45.mp4", "rb")

video_response = videos_api.upload(video_id, file)
print("Uploaded Video", video_response)` 

For the last part, you'll have to wait a little bit while your video processes. Once it's done processing you can see your newly watermarked video! 

## Retrieve watermarks 

If you need to retrieve a watermark ID you can always list all your watermarks. The code for that is this:


## Conclusion 

Watermarking is a great way to show branding on your video. You can play with the settings to move your watermark around your video or set it to different levels of opacity. You can find the information in [our docs](https://docs.api.video/reference/api/Watermarks#upload-a-watermark) or ask questions in [our Community](https://community.api.video/). Happy coding! 

How to add watermarks to your videos

captions

If you are creating captions for your videos, sometimes the captions don't appear where you want. Maybe they don't sit on the screen correctly, or maybe you have a creative way you want to present them. As it turns out, captions are adjustable! It will take some fine tuning to get the hang of working with them, but WebVTT is easy to use.

## Prerequisites

For this project you need: 

* api.video account - [Sign up here!](https://dashboard.api.video/register)
* A video you want to caption, uploaded to api.video - [here's a blog about how to upload your video](https://api.video/blog/tutorials/upload-a-video-with-the-api-video-python-client/)
* A VTT file for your video - [Learn how to caption a video with Maestra](https://api.video/blog/tutorials/add-captions-to-your-video-with-maestra-and-api-video/)

## Moving captions

To move captions, open your VTT file. You'll see captions listed next to their times, like this: 

`00:00:01.000 --> 00:00:02.000 
Hello World!`

Now let's say you don't like where the caption starts from. You can add on to the end to move it horizontally. Like this: 

`00:00:01.000 --> 00:00:02.000 position: 20%
Hello World!`

The screen is divided into percentages, so if you put a lower percentage, your caption moves further to the left. If you choose a higher one, it moves further to the right. Be careful you don't move captions into positions where they can't be seen. 

You can also make the captions go vertical. For that, you'd add: 
`00:00:01.000 --> 00:00:02.000 position: 20% vertical:rl
Hello World!`

And in this case, the position is vertical, so the percentage represents a portion of the vertical. 

You can learn a lot more about how to move captions and what's possible by checking out the [WebVTT Guide](https://www.w3.org/TR/webvtt1/). Just a few things you can do include changing the color of text, adding italics, specifying if something is loud, and much more!

How to edit and style your video captions

large_caption.png

medium_caption.png

small_caption.png

thumbnail_caption.png

caption.png

Video upload

Today we'll walk through how to use the Python client to do a progressive upload for a video. Progressive uploads are great for large videos. We recommend choosing this type of upload if your video is 200MB or greater.

## Prerequisites

* Sign up for an api.video account - [https://dashboard.api.video/register](https://dashboard.api.video/register) 
* Set up a virtual environment for your project (optional)
* Install the api.video Python client - `pip install api.video`
* Get a video file that's 200MB or greater (you can use a smaller one to see how it works, but it should be at least around 50MB) 

## Code sample 
Here's our code sample for today: 

In this sample we do the following: 

1. Set up the API client.
2. Create a container for our video with a payload containing our video metadata. 
3. Retrieve the video ID from the new container we made.
4. Create a session to handle our progressive video upload using the video ID we retrieved.
5. Set the chunk size we want to use. This value will be used to create chunks of this size. It's set to a smaller number so you can demo with a smaller video. If you want to upload something bigger, you might want to use a bigger number for each chunk.
6. Set up a method that handles breaking the video into chunks of data.
7. Set up a progressive video uploader. Of note - you have to take each chunk of data and save it as a clearly numbered part. For example chunk_file.part.1, chunk_file.part.2. End the files with part.* so that the api.video server can figure out the chronological order for each chunk of video. Also of note - you must signal that you're uploading the last chunk of video with the session.uploadLastPart() method. Otherwise, the api.video servers cannot determine if you're still uploading or not, so your upload will fail. You also have to open your file after saving it, using 'rb' or read binary. 

## Conclusion
If you want to try this upload without the client, see the [article about how to do a progressive upload with just Python](https://api.video/blog/tutorials/progressively-upload-large-video-files-without-compromising-on-speed/).

Happy coding!

Progressive uploads with the api.video Python client

Video list

Today we'll learn how to grab video data from api.video, add it to a database, then use that information to create an infinite wall of videos that you can keep scrolling through.

large_infinitevideos.jpg

medium_infinitevideos.jpg

small_infinitevideos.jpg

thumbnail_infinitevideos.jpg

infinitevideos.jpg

For this project, we're going to also use Laravel 8. 

## Prerequisites

* api.video account - [Register here](https://dashboard.api.video/register)
* [Laravel 8](https://laravel.com/docs/8.x/installation) installed
* Project repository - [https://github.com/apivideo/api.video-php-client/tree/main/examples/laravel/infinite_scroll](https://github.com/apivideo/api.video-php-client/tree/main/examples/laravel/infinite_scroll)
* api.video [PHP client](https://github.com/apivideo/api.video-php-client) 
* Symfony HTTP client - `composer require symfony/http-client` 
* composer - [https://getcomposer.org/](https://getcomposer.org/)

## What you'll be doing
You have three tasks for this project: 
1. Retrieve your data from api.video
2. Add your data to your database
3. Set up your page to show the videos in an infinite scroll 

## Retrieve your data
You need to collect some data from api.video about the videos you're going to use. To keep it simple, for this walkthrough I'm just retrieving videos tagged 'holiday' and keeping the title, video ID, and MP4 link for each one. You can retain any information you might want to use or display, the most important thing is the MP4 link. 

For this part of the project, I didn't use Laravel 8, I just set up a php file with my code and used composer. 

After you run the code, you'll have a list of all videos from your account that you tagged **holiday** in a .csv file. Save the file, we'll use it for the next part of our project.

## Set up your project
Now it's time to set up our Laravel 8 project. We'll need this before we can do anything with our database. These instructions are for Macs.

1. Make a new project by opening a terminal in the place where you want to store your project by typing `laravel new holiday`. 

2. Install the api.video PHP client. `composer require api-video/php-api-client`

3. Install the Symfony HTTP client. `composer require symfony/http-client`

4. Go into your project and find the .env file. For the section that starts **DB_** delete every **DB_** item except for **DB_CONNECTION**. Set **DB_CONNECTION** to sqlite. `DB_CONNECTION=sqlite`

5. Create a database table for the .csv file we made. `php artisan make:migration create_holidays_table`

6. Go into your project in the database folder and open the migrations folder. There should be a .php file with a timestamp at the start followed by the name of the table you just created in the terminal. Open this file and paste in this code:

7. Migrate your new table. `php artisan:migrate` 

8. Now we're going to create two models. The first is for handling infinite scroll. `php artisan make:model Model/InfiniteScroll` 

9. After you've made this model, go find it in your project and paste in this code: 



10. The second model we're going to make is for setting up our Holidays table contents. `php artisan make:model Model/Holiday`

11. Navigate to your new Holiday model and paste in this code:



12. Let's create a seeder that we can use to populate our new table using our .csv file. `php artisan make:seeder HolidaySeeder` 

13. Take your .csv file and place in the data folder for your database. 

14. Go to the seeders folder and open your HolidaySeeder.php file. Paste in this code:

15. Now we can run our seeder! `php artisan db:seed --class=HolidaySeeder` This should populate your database with the information from your .csv file. We're ready to set up our page to display our video collection. 

## Display videos
In this section we'll set up routes, a controller, and the page that will display videos whose links are retrieved from our database. 

1. We're going to add a new route, but before we do that, navigate to RouteServiceProvider.php. Scroll down to the line that reads `protected $namespace = 'App\\Http\\Controllers';` - it's probably commented out. Remove the commenting so it is active again. 

2. Navigate to routes\web.php. Add a new route `
Route::get('/load-more-data', 'VideoController@InfiniteScroll' );`

3. Make a new controller. `php artisan make:controller VideoController` 

4. Navigate to Controllers and open your VideoController file. Paste in this code:

5. Now let's set up our blade file. Navigate to views and craete a new blade file called **holidayView.blade.php**. Open the new file and paste this in: 

6. If you don't have a **data.blade.php** file, create one in the same folder as your other blade files. Open **data.blade.php** and paste in this code: 

## Run your project

Open a terminal in your project and type `php artisan serve`. You should be able to see a list of scrolling videos! 

If you have any questions about this tutorial, or would like to share what you've built, please join our [community forum](https://community.api.video/). 

Create an infinite scrolling wall of videos with Laravel 8

Create an infinite scrolling wall of holiday videos with Laravel 8

large_create-an-infinite-scrolling-wall-of-holiday-videos-with-laravel-8.jpg

medium_create-an-infinite-scrolling-wall-of-holiday-videos-with-laravel-8.jpg

small_create-an-infinite-scrolling-wall-of-holiday-videos-with-laravel-8.jpg

thumbnail_create-an-infinite-scrolling-wall-of-holiday-videos-with-laravel-8.jpg

create-an-infinite-scrolling-wall-of-holiday-videos-with-laravel-8.jpg

[](https://)If you work with video, you know that when you have a gigantic video file, you must break it into chunks to send it to the server. We at api.video already offer a way for you to break up your video into chunks and send it to us, but today we are introducing a new way of uploading large files: [Progressive Upload](https://docs.api.video/vod/progressive-upload).

Instead of spending time worrying about getting the bytes right for the header, or relying on our API clients to handle it for you (still a great choice if you have a client in use) you can simplify the header for a chunk to be about what part of your video you're sending. Here's an example of what I mean:

Old header: 
`Content-Range: bytes 0-1000000/200000000`

Here you can see the Content-Range header shows the bytes being sent from the video and then the total number of bytes. But there's a couple of issues with this. First, it's tricky setting up the header correctly (which makes the clients great to use since they handle this for you) and second, what if you want to upload a video where you don't know its size? It'd also be great if you could upload video chunks concurrently and have that handled for you. Progressive Upload does this, and the new header looks like this: 

New header:
`Content-Range: part 1/*`

Every video chunk just receives a part number. The only video chunk that can be smaller than 5MB is the last chunk. Everything else must be larger. And with this explained, we're ready to prepare and try a code sample. 

## Prerequisites
For this project, you'll need:

* (Optional) Familiarity with other ways to upload (it might make this tutorial easier, but this is written so you don't need the other tutorials)
* An api.video account, you can sign up [here](https://dashboard.api.video/register)
* Python or a Python virtual environment to work with (recommended)
* Requests library for Python installed 

## Progressive Upload code sample 
The code sample we're going to walk through looks like this:

In the code sample, you're doing the following things: 

1. Retrieving a token using your API key. 

2. Setting up a video container to upload to. You upload in two parts - first you create a container with metadata about your video. Then you retrieve the videoID for your video container, and reference it so you can upload your chunks to the right container. You can only upload once to a container, so make sure you have everything set up correctly. Otherwise you'll have to start over with a new container. 

3. We set a variable **CHUNK_SIZE** to represent the size of each chunk of video we'll send. You can make this bigger if you like to speed up the process. 

4. We write a little function **read_in_chunks** that breaks a chunk of data off our video file to send, then remembers the spot it was in so when we come back to the function again, it gives us the next chunk of data. This is accomplished by using **yield** in the function.

5. In the **upload** function, we get ready to loop through our video file, sending a chunk of data each time with the appropriately labeled header. For Content-Range we just increase the part number by 1 each time, and leave it set as unknown, like: `part 1/*` If you know your video size ahead of time, you can change the asterisk to the final part number. This code sample assumes you don't know the size. What you do per chunk is check if it's smaller than 5 MB, since this will signify we've reached the final piece of the video. For this last piece of video, we change the total number of parts to match the part we're on. This signals to api.video that we aren't going to send any more chunks and that the upload is complete. 

And we're done!
To start building right now, check our [docs](https://docs.api.video/reference/api/Videos#upload-a-video) and [sign up for a free account](https://dashboard.api.video/register).

Upload large video files without compromising on speed

large_progressive-upload.png

medium_progressive-upload.png

small_progressive-upload.png

thumbnail_progressive-upload.png

progressive-upload.png

Progressively upload large video files without compromising on speed

api.video offers a PHP client to make it easier for you to upload your videos. Today we'll walk through how to do this. You can always hop on over to the GitHub repository if you'd prefer to learn about the client that way too - [api.video PHP client](https://github.com/apivideo/php-api-client).

## Prerequisites

For this project, you'll need these things: 

* Composer - if you don't have it set up, go here to learn about it and get it installed - getcomposer.org
* An api.video account - you can sign up [here](https://dashboard.api.video/register).

## Installation

You'll need to install a few things using Composer:

* The api.video PHP client - `composer require api-video/php-api-client`
* Symfony HTTP client - `composer require symfony/http-client`
* nyholm/psr7 - `composer require nyholm/psr7`

You can type **composer update** to make sure everything is pulled into your project and configured. 

## Code sample

Here is the code sample for uploading a file. You need to change **'yourAPIkey'** to your key that you retrieve from the api.video dashboard after you create an account. Place the video you want to upload in the same folder as your code sample. For the sake of simplicity, this code sample hardcodes the title of the video - change **VIDEO_TO_UPLOAD.mp4** to the title of your video file.

### Import the client
In the first part of the code, you import the parts of the api.video PHP client you'll need. The client is more efficient when you import the endpoints you need for your code, instead of everything. You also need the HttpClient from Symfony for this implementation. So it will look like this:

## Initialize the client 
Next you initialize the client for use in your API calls. 

## Create your video payload 
The next part of the code includes a video creation payload. This is a cool part of the PHP client. You can add all the metadata you'd like for your video here. Later, you're able to update your code as well. Consult the [Create a video](https://docs.api.video/reference/api/Videos#create-a-video-object) endpoint in our API reference documentation for available parameters. You capitalize them when adding them into your payload. So title becomes `setTitle` as shown in the code sample. Any parameters in camel case that you want to use would change a bit. For example, the docs have mp4Support, but if you are using the PHP client, you would write it as `setMp4support`. 

When you send multiple parameters, the code would look like this: 

`$payload = (new VideoCreationPayload())
    ->setTitle('My cool video');
$payload->setTags(['tag 1', 'tag 2']);`

When you're done setting up your payload, then you use the client to send this information to api.video servers and create your video container.

## Upload the video
In the last part of the video, you retrieve the video ID for the container you made and upload your video into the container. You can only upload into a container once, but you can change its metadata later if you wish. You can see whether it worked by reading the echoed response in the terminal.

## Conclusion
Now you know the basics of uploading a video with the api.video PHP client! You can check whether your upload worked by going into your dashboard and looking in the videos section. You should see it there. If you get a note that it's still processing, give it a bit of time to get the video ready, especially for big videos. 

If you have any questions or suggestion, please share them on our [community forum](https://community.api.video/). If you haven't created your api.video account yet, you can do that in just a few moments by follwoing [this link](https://dashboard.api.video/register). Happy building! 

Upload a video with the api.video PHP client

large_Upload with PHP.png

medium_Upload with PHP.png

small_Upload with PHP.png

thumbnail_Upload with PHP.png

Upload with PHP.png

doug.jpg

twitter-brands.svg

Doug Twitter

Doug Sillars

NodeJS

We've launched a number of demos at [a.video](https://a.video) to demonstrate the power of [api.video's APIs](https://api.video) and our video in the cloud service.  We have apps featuring video uploading, video streaming and also mashup collaborations that include auto-captioning, video moderation, live video chat and others with some select partners.

You might want to launch one of these demos for your own application or process - using your api.video account.  In this post, we'll walk through the steps we use to launch new demos for a.video, and if you follow along, you can launch your own versions in your Heroku account.

## Heroku

Heroku is a service that makes it easy to spin up a server, add your code, and launch a service on the internet.  We use Heroku for all the a.video demos, so will walk through the steps we perform in order to launch our demo applications.

## record.a.video

The [record.a.video](https://record.a.video) demo has been very popular. It allows you to record your screen and camera right from the browser.  You can choose to send that feed to api.video as a live stream, or record the video, and send it to our video hosting platform for later on demand viewing.

In this post, we'll take the record.a.video code from Github, and launch our own personal version of the application on Heroku.  At that point, you can update the page to match your expected user experience, and have a working app with just a little bit of work.

First off, we'll want to grab the code from Github.  Head to the [recordavideo](https://github.com/apivideo/recordavideo) repository, and fork it into your account:




medium_screenshot-2021-10-20-at-12-38-16.png

small_screenshot-2021-10-20-at-12-38-16.png

thumbnail_screenshot-2021-10-20-at-12-38-16.png

screenshot-2021-10-20-at-12-38-16.png

You should now have the repository in your account, with the format ```https://github.com/<your accountname>/recordavideo```.  

Before we can go live, the app uses a few api.video configurations that are set to the team's account, and you'll want to switch to yours.

There are a couple of ways to do this - you can clone the repository to your machine to make the edits (and then push the fixes back to Github). If you 've used Github a lot, this will feel like second nature.  For those who have not used git regularly, you can manually change 3 lines of code using the web interface.

We need to change the first 3 lines of ```/public/index.js```.  


```
RTMP_url = 'rtmp://broadcast.api.video/s/30087931-229e-42cf-b5f9-e91bcc1f7332';
live_url = 'https://embed.api.video/live/li400mYKSgQ6xs7taUeSaEKr';
delegated_token = 'tompBU8ZJcUCEsKGxxoBydh';
```

Record a video allows you to livestream, or upload a recorded video.  The RTMP_url and live_url are used for live streaming.  The video from the browser is sent to the RTMP_url, and then the broadcast is visible from the live_url.

* To set these up, you must [create a livestream](https://docs.api.video/reference/api/Live-Streams#create-live-stream) using our API.  We have a [tutorial using cURL](https://api.video/blog/tutorials/live-stream-tutorial/) to help you create a live stream. This will give you the RTMP and live URLs to update lines 1 and 2.
* Next, we'll create a delegated token, for the video on demand upload option. For this, we'll use the [generate upload token](https://docs.api.video/reference/api/Upload-Tokens#generate-an-upload-token) API endpoint - (and the corresponding [curl tutorial](https://api.video/blog/tutorials/delegated-uploads/).

Once you've updated the ```public/index.js``` with your values, we're ready to launch on Heroku.

Create a free account (or login) to [Heroku](https://dashboard.heroku.com/apps).  You'll land at your dashboard, and in the upper right corner is a button "New."  Choose "Create new app" from the menu.

The name "recordavideo" is taken, so pick another descriptive name for your application:


large_screenshot-2021-10-20-at-16-04-25.png

medium_screenshot-2021-10-20-at-16-04-25.png

small_screenshot-2021-10-20-at-16-04-25.png

thumbnail_screenshot-2021-10-20-at-16-04-25.png

screenshot-2021-10-20-at-16-04-25.png

Once you create the application, you'll land at the Heroku dashboard for the app, in the "Deploy" section.  We want to deploy via Github, so in the center, click the Github logo.  Then, choose the Github account and search for the repository you wish to deploy.  In the screenshot below, I have selected repordavideo in the dougsillars github account:

large_heroku-deploy.png

medium_heroku-deploy.png

small_heroku-deploy.png

thumbnail_heroku-deploy.png

heroku-deploy.png

Once you connect your repository, you can set it up to automatically redeploy when changes are made in Github.  Enable this, so when you do update the UI/UX, it will automatically appear in the launched app.  You can also manually deploy the repository from here.

### Settings

Move to the Settings tab in the dashboard to further configure your server.  The record.a.video application uses ffmpeg on the Node server - it [transmuxes](https://api.video/what-is/transmuxing/) the video from the canvas on the screen into RTMP for api.video.  We need to tell Heroku to install FFmpeg.  There is a buildpack already created ```https://github.com/jonathanong/heroku-buildpack-ffmpeg-latest.git``` so we'll add it. Then we will add the NodeJS buildpack.



large_buildpacks.png

medium_buildpacks.png

small_buildpacks.png

thumbnail_buildpacks.png

buildpacks.png

> Note: the buildpack for the language must be the last one on the list. If the order is reversed, your app will not build.

In the table above, you can add any environmental variables (there are none in this app, but many NodeJS apps use process.env.<variablename> to reference API keys and other values that should not be published into github, or left referenced in code.
	
For example:

```
const apiVideoKey = process.env.apiProductionKey;

```
	
You would have apiProductionKey in these variables - referenciung your api video production API key.
	

large_env.png

medium_env.png

small_env.png

thumbnail_env.png

env.png

With all these settings made, you can now go back to the "deploy" tab and manually deploy your application. Once that is completed, you can visit the URL listed in the settings page to run your own copy of record.a.video (or whichever app you copied).

### Bonus steps

If you have a domain you;d like to use, the Settings tab allows you to set a domain that will point to this app's instance. You'll need to do CNAME DNS work to make this all happen, but this is how we get our apps to point to our ```a.video``` subdomains.


## Conclusion

That's all there is to it - simply pick your app, fork it, and update to your API keys/ settings, and follow the steps to deploy on Heroku.



Build an api.video demo with Heroku

medium_screenshot-2021-10-21-at-10-59-29.jpg

small_screenshot-2021-10-21-at-10-59-29.jpg

thumbnail_screenshot-2021-10-21-at-10-59-29.jpg

screenshot-2021-10-21-at-10-59-29.jpg

video create

The first step to displaying your video online is getting it uploaded. Today we'll go over how to upload a video using Laravel 8 with api.video's PHP Client. Before we dive in, let's go over what we'll be doing when we upload a video. 

Uploading a video is a two step process. First, we create a container for the video and retrieve the video ID. Then, we upload a video into the container by referencing the ID. You can only upload a video to a container once, but you can modify details about the video at any time after that. Our uploader will let you add a title, description and list whether you want to have the video be public or private and whether you want to offer an MP4 link of the video for download. 

## What you'll need 
To get started, make sure you have these things:

* Account with api.video - you can sign up [here](https://dashboard.api.video/register)
* Laravel 8 - you can use other versions, but some things work differently
* NPM and node.js - you install these when you set up Laravel 
* Composer - you'll need this installed 
* [api.video PHP client](https://github.com/apivideo/php-api-client)
* Project repository - [https://github.com/apivideo/php-api-client/tree/main/examples/laravel/video_upload](https://github.com/apivideo/php-api-client/tree/main/examples/laravel/video_upload)

You can also review the API reference documentation for the endpoints used in this project: 
* [Create a video](https://docs.api.video/reference/api/Videos#create-a-video-object)
* [Upload a video](https://docs.api.video/reference/api/Videos#upload-a-video)

## Create your project
The first thing you'll need is a Laravel 8 project to work with. Here's what I did:

1. In a terminal make a new project by typing: **laravel new fileuploader** or similar project name.
2. Open your project folder, you'll need to install a few things.  
3. You'll need to add the api.video PHP client, so at the terminal type: **composer require api-video/php-api-client** 
4. You'll also need the symfony http client, at the terminal type: 
**composer require symfony/http-client**
5. And the last thing to add is nyholm/psr7:
**composer require nyholm/psr7**

You can type **composer update** to make sure everything is pulled in to your project and configured.
 
## Create a controller
We will need a controller for our video uploader, so let's go ahead and do that now. In the terminal in your project folder type: 

**php artisan make:controller UploadController** 

This will automatically create what we need to start building the controller. 

## Set up the home page with an upload form
For this walkthrough, we're using the home page to create an upload form. So in your views folder, go into **home.blade.php** and create the form. I selected to allow the user to add basic details about their project. I'm also using bootstrap, so the basic form looks like this: 

Image of upload form showing available fields

large_viduploadphp.png

medium_viduploadphp.png

small_viduploadphp.png

thumbnail_viduploadphp.png

viduploadphp.png

And here is the code that creates this form: 

We pull in the bootstrap details up top under the Scripts and Styles sections. Then for our form, we have all the form data sent in a POST request to the '/upload' route. (We'll need to create that route in a moment.) 

The form is straightforward - we list the type of data as text for the name of the file and the description of the file. For choosing whether the file will be public or offer an MP4 for download, we use a radio button, so the type is radio. For the video, we choose type file and then we set up our submit button. Bootstrap styles everything for us, so we're all set here. Now we need to handle the route. 

## Set up the /upload route
Open your **web.php** file and add a new route: 

**Route::post('/upload', 'UploadController@upload');** 

This route indicates that when submit is clicked in the form, it should go to /upload and carry out the upload instructions listed for the UploadController. 

We don't have that set up yet, so let's do that next. Also, the other routes are added into the project, you can see everything if you download the repository.

## Set up your UploadController
Our controller takes the details provided by the form, then uploads the content to api.video. Behind the scenes, we're going to need our api.video API key, so let's make sure we handle it securely. 

1. Go to your .env file. In the top section, you'll see items to do with your app. At the bottom of the list of items beginning **APP_** you'll see **APP_APIVIDEO=yourapikey**. Replace **yourapikey** with your key (retrieve it from your api.video dashboard). Don't add quotes. 
2. Open **RouteServiceProvider.php**.
3. In the file, take the commenting **\\** off of the line **protected $namespace = 'App\\Http\\Controllers';**. This returns the use of the automatic namespace, which is handy.
4. Open **UploadController.php**. 
5. Add this code: 


In our code, we set up the api.video client and collect the information from the request object that comes in from the form. We check if the data for the radio buttons is set and if it is, we add it to our payload for upload. Then we send the data and redirect the user to a page that says 'Success!' 

## Conclusion
These are the basics for uploading a video to api.video. You can try using different styles or set ups if you want to allow users to add more metadata on upload. If you have any questions or suggestions, please share them on our [community forum](https://community.api.video/). Thanks for reading! 



Upload a video with Laravel

webhooks

JavaScript

Video bumpers are small video intro and exit scenes added to a video to help the viewer understand what they are about to watch.  The intro 'bumper' often has a title or description of the video that is to follow, and the outro 'bumper' provides a call to action on what the viewer can do next - now that they have watched the video.

At api.video, we add bumpers to many of our videos to provide context and a subject for each video, and the end bumper provides a 'call to action' after the video has been watched.

Adding bumpers to your video makes your video appear more polished, as an editing step was taken to add these to the raw video you recorded with your camera (or screen sharing tool).  It is often a manual task in your video editing software.

In this post, we'll automate the task of adding bumpers to a video recording.  We'll use the [Shotstack API](https://shotstack.io/) to add the bumper image and text titles to the front and end of a recorded video.  The completed video will then be uploaded to api.video, and be ready to play in seconds - removing several manual steps from the creation of your training videos!

You can also check out the API reference documentation for the endpoints used for this project: 
* [Webhooks](https://docs.api.video/reference/api/Webhooks#create-webhook)
* [Video status](https://docs.api.video/reference/api/Videos#retrieve-video-status-and-details)

## The "old way" of adding bumpers:

1. Create slides in Google Slides for the intro & outro
2. Take screenshots of the slides
3. Import the screenshots into iMovie
4. Add them to the video timeline
5. Encode the video
6. Upload the video to api.video


The downsides to this: 
Steps 1-4 are all manual, and are repeated for each video that I create.
In steps 5&6 there is a lot of waiting.  

## The "new way": bumper.a.video

Add images, text and video to a web form. Click "upload." The video will upload and have the bumpers added automatically - with no manual work, and (what seems like) a lot less waiting.



Let's see how it is built!


## Ingredients for the demo

* [api.video account](https://dashboard.api.video/register)
* Background image: a 16:9 image suitable for the background

large_bumperbackground.png

medium_bumperbackground.png

small_bumperbackground.png

thumbnail_bumperbackground.png

bumperbackground.png

* Watermark image.  In this demo, we'll use the api.video logo. It is sized to 100x100 pixels to fit properly on the video. The image is also transparent to ensure that there is no white "background" on top of the video.

logoorange100.png


* 4 Text fields

  * Intro title
  * Intro 2nd title
  * Outro title
  * Outro 2nd title


## The tools used in this demo

### Shotstack

The Shotstack API is a video editing API. You can splice together videos, add watermarks, and add text into your video using their API.  We'll use this API to create our bumpers:

1. Upload a background image (we use the same image for both bumpers)
2. Add a title and a 2nd title for both bumpers (text fields)
3. Add a watermark in the upper right corner for the entire video.

### api.video

The initial video will be uploaded to api.video. Once the mp4 has been produced, it is sent to Shotstack for 'bumper work.' Once the video with bumpers has been created via the Shotstack API, we will re-add the completed video to api.video, and provide a playback url.


## Creating the video

Once you hit 'send' on the form at bumper.a.video, a lot of action takes place:

1. The 2 images are uploaded to bumper.a.video/images.  Shotstack requires that the images be publically available on the internet for the api to process them.
2. The video is uploaded to api.video.  For security reasons there are a few steps in this process:

   * The node server makes 2 calls to api.video: creating a delegated token and a videoId (with the name & description provided by the user). 
   * A delegated token works as a public API token for upload only.  
   * Sending this and the videoID back to the browser, we can use the api.video [JavaScript uploader](https://docs.api.video/sdks/vod/apivideo-typescript-uploader) to securely upload the video to api.video.
3. Once the video is uploaded - a message appears to the user, and a button appears to update the status of the processing.

Now that the video has been uploaded to api.video, the rest of the work is done between the Node server, api.video and Shotstack. 

1. Shotstack requires a publically available video URL for processing the video.  We use the ```video.encoding.quality.completed``` [webhook](https://docs.api.video/reference/api/Webhooks#create-webhook) to monitor the creation of the videos at api.video. When the webhook alert tells us that the mp4 version of the video has been created, we know that the mp4 file is ready.  Now we can request the api for the URL of the mp4 (to send to Shotstack).
2. In order to build the bumpers correctly, we also need the duration of the video uploaded. The [video status](https://docs.api.video/reference/api/Videos#retrieve-video-status-and-details) endpoint tells us the duration of the video in the metadata section of the response.

### Creating the call to Shotstack

The Shotstack API works like an onion with many layers that must be defined to create a full video: 

Every video has a ```timeline``` that defines the overall video.

Each ```timeline``` has one or more ```tracks```.  Tracks sit atop one another (in our case, we will have a watermark track sitting atop the video track).

Each ```track``` has one or more ```clips```.  The clips are bits of video/text or images that have specific durations inside the track.

Each ```clip``` has an ```asset``` that defines the clip - this could be a string of text, or an image or a video file.



large_screenshot-2021-09-30-at-17-10-37.png

medium_screenshot-2021-09-30-at-17-10-37.png

small_screenshot-2021-09-30-at-17-10-37.png

thumbnail_screenshot-2021-09-30-at-17-10-37.png

screenshot-2021-09-30-at-17-10-37.png

There are two tracks that play the length of the video - the watermark track - which has a single clip for the single image asset.

the code for this (using the NodeJS SDK) looks like this:

```
let watermarkAsset = new Shotstack.ImageAsset;
							watermarkAsset.setSrc('https://bumper.a.video/images/'+wmpath)
						//watermark to run full video 
						let watermarkClip = new Shotstack.Clip;
							watermarkClip.setAsset(watermarkAsset);
							watermarkClip.setPosition("topLeft");
							watermarkClip.setOffset({"x": 0.05,"y": -0.05});
							watermarkClip.setOpacity(0.5);
							watermarkClip.setFit("none");
							watermarkClip.setStart(0);
							watermarkClip.setLength(4+duration+4);
```

The clip is used to set the location - in this case the top left - with a bit of (x,y) adjustment, the opacity (50%), and how long the clip should play.

Since the intro and outro are 4 seconds, and the video has length ```duration``` - we set this clip to appear for the entire video.

The main track of the video has many clips (and assets).  Both the intro and outro have background and 2 text assets each, and the middle section has just the video clip/asset.

Shotstack does not like having clips with identical times. That means I cannot add the titles at the same moment as the background image. I could have perhaps placed the text items into different tracks to overlay the background - and then had them all start at the same time.  Instead I have the background appear, and then add each bit of text every 100ms:

```
						let titleIntroTextAsset =new Shotstack.TitleAsset;
							titleIntroTextAsset.setText(introTitle);
							titleIntroTextAsset.setStyle('chunk');
							titleIntroTextAsset.setColor('#ffffff');
							titleIntroTextAsset.setSize('x-large');
							titleIntroTextAsset.setPosition('center');
						let titleIntroClip = new Shotstack.Clip;
							titleIntroClip.setAsset(titleIntroTextAsset);
							titleIntroClip.setStart(0.1);
							titleIntroClip.setLength(3.9);

						let titleIntroTextAsset2 =new Shotstack.TitleAsset;
							titleIntroTextAsset2.setText(introTitle2);
							titleIntroTextAsset2.setStyle('chunk');
							titleIntroTextAsset2.setColor('#ffffff');
							titleIntroTextAsset2.setSize('large');
							titleIntroTextAsset2.setPosition('bottom');
						let titleIntroClip2 = new Shotstack.Clip;
							titleIntroClip2.setAsset(titleIntroTextAsset2);
							titleIntroClip2.setStart(0.2);
							titleIntroClip2.setLength(3.8);
```

The main text asset is present from 100ms into the video to 3.9s, and the secondary text asset is present from 200ms to 3.8s.  It looks kind of cool, as if they are boomeranging in and out, so I kept it this way.

The video clip in the middle has the volume set to 50%. It starts at 4s, and has a length of ```duration``` seconds.

```
						let videoAsset = new Shotstack.VideoAsset;
							videoAsset.setSrc(mp4Url);
							videoAsset.setVolume(0.5);
						let videoClip =  new Shotstack.Clip;
							videoClip.setAsset(videoAsset);
							videoClip.setStart(4);
							videoClip.setLength(duration);
```


All of this data is sent to the Shotstack API, and it begins processing the video - adding the watermark and the bumpers.

Once the video is completed (the Node server polls every 2s to get an update), a new video at api.video is created, using the source URL from Shotstack:


```
	function updateApiVideo(url){
							//ok so the video is created at Stostack
							const videoCreationPayload = {
								title: title, // The title of your new video.
								description: descr, // A brief description of your video.
								source: url, // If you add a video already on the web, this is where you enter the url for the video.
								
							}; 
							finalUpload =  client.videos.create(videoCreationPayload);
							finalUpload.then (function(finalVideo) {
								console.log(finalVideo);
								var finalvideoId = finalVideo.videoId;
								var finalPlayerURL = finalVideo.assets.player;
								console.log('finalvideoid',finalvideoId);
								console.log('finalPlayerURL',finalPlayerURL);
								//res.send(finalPlayerURL);
								videoProgressJson.finalVideoId = finalvideoId;
								videoProgressJson.finalPlayerURL = finalPlayerURL;
								videoStatus(videocreationList, videoId);



							});
						}
```

Finally - we use the same video encoding webhook we used earlier to wait until the 720p version of the video is ready for playback (looking for the new videoID, and the HLS version at 720p resolution).

The user - back on the webpage, can click the "update status" button and track this process.  The update status reports:

* Initial mp4 created
* Shotstack id
* Shotstack status
* New api.video videoID
* Final video at 720p

When the last item reports true - we add a link and embed the new video right onto the bumper.a.video page.

## Conclusion

Automating the mundane tasks we run regularly makes life easier. In this demo, I identified a process that was very manual - creating video bumpers for demo videos.  I used [api.video](https://api.video) and [Shotstack.io](https://shotstack.io) to automate the process, and thereby making the creation of video demos faster and easier!

If you have any questions or suggestions, please share them on our [community forum](https://community.api.video). If you still need to create your api.video account, you can do that in just a few moments by following [this link](https://dashboard.api.video/register). Happy building! 

Add bumpers to your video with bumper.a.video

large_bumperavideo-1.png

medium_bumperavideo-1.png

small_bumperavideo-1.png

thumbnail_bumperavideo-1.png

bumperavideo-1.png

Laravel is a great framework for building web applications. It does a lot of the heavy lifting for you, so you can focus your development efforts on the more unique elements of your application. Because there are multiple versions of Laravel and many of the packages you'll use with it have their own updates, it can sometimes get tricky to troubleshoot. There are many troubleshooting suggestions online, and this quick article aims to help sift those for the best tips. 

## Check your version of Laravel
One issue you will encounter is matching your version of Laravel to the advice you find online. This guide may work for other versions of Laravel, but is intended for Laravel 8. When troubleshooting, make sure you are conscious of what version you have and what version the tips you find are for.

## Bootstrap isn't working in my Laravel project
You must properly install Bootstrap for your Laravel project in order to add it to your files. If you find that Bootstrap styling isn't appearing on your HTML pages as expected, this section may be for you.

### How to install Bootstrap 4 for Laravel
To install Bootstrap 4 for your Laravel project, you do these things: 

1. At the command line, type `composer require laravel/ui`.
2. At the command line, type `php artisan ui bootstrap` if you just want Bootstrap for your project but don't plan to do any authentication. If you want to handle authentication in your project with bootstrap, then type `php artisan ui bootstrap --auth`. 
3. You'll also need to make sure npm is installed, so at the command line, type `npm install`.
4. Finally, at the command line run `npm run dev`.  

Some problems that might arise are having packages that aren't up to date, or issues with installing Laravel Mix. You can search online for how to handle packages that aren't up to date if there's a special issue. For the Laravel Mix issue, simply run `npm run dev` again. It often solves the issue.

### How to add Bootstrap 4 to your blade files 
To add Bootstrap 4 into your **blade.php** files, you use mustache quotes {{}} to reference the Bootstrap content you'll need. It looks like this: 

You may see the choice where you just reference a link to a public distribution, but blade files work differently. You need to use the mustache quotes version to add the files.

### Bootstrap still isn't working 
You'll see a note on installation that you don't have the most recent version of popperjs. If you want to update that to see if it corrects your issue, you can use the following command: 

`npm i @popperjs/core` 

## I don't see the changes I made to SASS and JS
If you don't see changes implemented in your application after updating something in SASS or JS files, the issue might be that you didn't run `npm run dev` again. Every time you change content here, you must use this command. If you don't want to do that and want to continually see your changes while you're making them, you can use `npm run watch`. This command will start regularly checking your files and recompiling every time it detects new changes. 

## I made changes to my application and they're not reflected on my server
If you made changes that are not just updates to the views, you may need to restart your server. You can do that like this: 

1. Press **Control + C** at the same time.
2. Type in the terminal in your project folder `php artisan serve`. 

## I installed a new library 
If you install a new library with Composer, you need to make sure you pull in all the new changes that causes. In the terminal type: 

`composer update` 

## I made changes to my database schema 
If you change your database schema or add something new, you need to run a migration. This is pretty simple, type: 

`php artisan migrate:fresh`

## My application isn't accessing my public folder correctly
To make sure your application accesses your public folder, which is where you'll often store assets, you need to create symbolic links for your application: 

`php artisan storage:link` 

## I'm still not sure why I can't see changes I made
If you get stuck, an easy thing to try is: 

`php artisan config:clear` - this clears your cache file. If you corrected something, but the cache isn't cleared, you might not be able to see your update. 

## The route I want isn't displaying
The order of routes in your **web.php** file matters! If you put routes that include variables first, it can mess up the flow of your application. Try to put concrete routes first, and then routes with flexible components after. 

## My controllers aren't found
In Laravel 8, the automatic namespace is turned off. If you want the same functionality as earlier versions of Laravel back, go to **RouteServiceProvider.php** and make it so `protected $namespace = 'App\\Http\\Controllers';` is no longer commented out.

## Conclusion 
When working with Laravel, there are lots of small details to remember. Updating and refreshing various aspects of your application can help correct a lot of problems you may encounter. If you want to try building something with api.video and Laravel, check out our post [Create your own version of Instagram using api.video and Laravel](https://api.video/blog/tutorials/create-your-own-version-of-instagram-using-api-video-and-laravel/).

Troubleshooting tips for your Laravel 8 project

medium_laravel8logo.png

small_laravel8logo.png

thumbnail_laravel8logo.png

laravel8logo.png

codec

small_cedric.webp

thumbnail_cedric.webp

cedric.webp

Cédric Montet

Product updates

At api.video, our goal is for video to be easy and affordable for anyone to build, be it individuals or organizations. We understand that achieving this goal means reducing costs at some stage of the video streaming process. That’s why, we now offer adaptive bitrate encoding for your videos at zero cost. 

&nbsp;

Yes, you heard me right. 

&nbsp;

**Encoding videos will be absolutely free for all video qualities (1080p or 4K) at [api.video](https://api.video/) - no hidden calculations, footer notes or tricks.**

(Check out this [video](https://www.youtube.com/watch?v=ouosgLbW7Ts) for more details) 


## A step towards making video streaming affordable

Video encoding is crucial as it makes it possible for videos to be shared and played smoothly on the internet. It is why we are easily able to consume various types of video media, whether it’s a YouTube video, our favorite shows on Netflix, or even catching up with friends across the globe on Zoom. Video encoding basically makes the world go around in regards to anything related to video and video content.

&nbsp;

We at api.video recognize that. From [increasing the transcoding and playback speed ](https://api.video/blog/product-updates/2021-in-review/)to building [specialized hardware like ASICs](https://api.video/blog/video-trends/the-comeback-of-specialized-hardware/) cards to increase our transcoding capacities, we've been working to make video streaming easier for you every day. And after dedicating ample time to engaging with our customers and learning about their concerns, free encoding seemed to be the next step in this direction. 

&nbsp;

So, we worked tirelessly behind the scenes to give you what no one else will - free encoding for all video qualities, be it 360p or 4K. 

## How does free video encoding benefit you as a customer

The benefit is straightforward: you save a LOT of money!

&nbsp;

- With free video encoding, you will have one less thing to worry about. As you know, you pay for three things for streaming videos — encoding, hosting, and delivery – out of which encoding is the most expensive, especially if you have a lot of videos. Free video encoding will allow you to focus your attention and resources to what is most important.

&nbsp;

- As the video needs of your app users grow, you might need to scale up your encoding capacity. Free video encoding services will give you the power to scale without any additional costs, meaning your users can handle more videos without increasing your expenses.

&nbsp;

- You can [migrate from your previous provider to api.video](https://api.video/compare/azure-media-services/) without paying an ‘entry tax’ to us. With free video encoding, you no longer need to spend money on encoding videos with a new provider when you have already paid for encoding with an older one.

&nbsp;

Now with all the saved cost, you can allocate your resources and money to a place where it is actually important – building your product and delighting your users. 

## How to get started

To use the free video encoding benefit, getting started is easy. 

&nbsp;

- If you’re a new user, [sign-up](https://dashboard.api.video/register) for a free sandbox account and start uploading your videos
- If you are looking to migrate from another vendor, [import](https://import.api.video/) your videos from your current vendor
- If you have any questions, [talk to us](https://meetings.hubspot.com/apivideo/talk-to-us) by booking a slot in our calendar

&nbsp;

To know more about our[ features](https://api.video/features/), [pricing](https://api.video/pricing/) or ask any other questions, [talk to our team ](https://meetings.hubspot.com/apivideo/talk-to-us)and we will help you out. 

&nbsp;

Or, you can straightaway [sign-up](https://dashboard.api.video/register) for a free sandbox account and check our product out for yourself. 


Huge pricing update: Introducing video encoding at no cost

small_Blog_Zero Cost.webp

thumbnail_Blog_Zero Cost.webp

Blog_Zero Cost.webp

api.video

Video trends

Modern technology has been helpful for an increasingly fast and simple method of consuming various types of video media, whether it’s a YouTube video, our favorite shows on Netflix, or even catching up with friends across the globe on Zoom. Despite the relative ease of doing anything related to video, a few complex processes take place behind the scenes, away from public view. One such process is video encoding.

Video encoding basically makes the world go around in regards to anything related to video and video content. Thanks to the technologies behind the video encoding process, it has become much easier for people and companies to share video content on the internet. But what exactly is video encoding, and what happens during the process? We’ll take a closer look at this and much more in this handy guide to video encoding.

## What is video encoding?

In a nutshell, video encoding occurs when you take raw video footage, either from a digital camera or an analog film camera, and digitally compress it to make it a more manageable file size. Video encoding happens daily in both professional and personal capacities, and many people don’t realize it.

But, without encoding, services like Netflix and YouTube would not exist – or, at least, not in the same way that it does today. Without it, we couldn’t send videos of our beloved pets to our friends and family as easily as we can today.

## Why is video encoding used?

There are a variety of reasons why video encoding is used, but all factors point to the single function of video encoding – **compression**.

This is done to ensure optimal performance and compatibility with a selected suite of software and hardware, be it for DVD/Blu-ray playback, mobile viewing, online video streaming, or general video editing. A file's video and audio information undergo transformation and compression during the encoding process, all in accordance with the requirements of the selected encoding standard.

On a professional level, the ability to compress raw video into more manageable sizes makes it easier to transmit video content such as training, promotion, presentation, and so on over the internet. 

On a personal level, video encoding makes it much easier to send videos taken from your phone directly to friends and family. Most modern-day personal devices have built-in video encoding capabilities to allow for this to happen without a second thought.

To put things in perspective, uncompressed or unencoded video can have a data rate that’s as low as 3,000 Mbps and as high as 12,000 Mbps, depending on the length and quality of the video recorded. 

**Without encoding, it would take up to days for anyone to not just transmit video, but to be able to consume it, too.**

## Differences between video encoding and video transcoding

You need to be familiar with two more [essential terms related to video encoding](https://api.video/what-is/) – transcoding and codecs.

Transcoding relates to the conversion from one digital encoding format to another. It takes the already encoded video file, decompresses it, and then alters it before re-encoding or compressing it into a different codec. Codecs are what allow encoding to occur in the first place. They are software or hardware that gives us the ability to compress video to make them more easily stored and delivered tightly.

While you may hear “encoding” and “transcoding” used interchangeably, the two terms actually mean different things. Putting it succinctly, encoding is the initial process of compressing a video from a source – such as a camera – into a codec, while transcoding takes an already encoded video file to convert it into a different codec.

## Examples of video codecs

In order to understand video encoding, you must first be familiar with two interrelated terms: [video codecs and video formats](https://api.video/blog/product-updates/every-video-format-codec-and-container-explained/). These also tend to be used interchangeably, but much like the terms encoding and transcoding, they refer to two different things.

Video formats are the type of files in which the compressed video/audio is stored. Also known as a “container”, you can tell what a video format is by looking at the file’s extension — the three to four characters that sit after a period in a file name. Here are some of the most common video formats used today:

* MP4
* FLV
* MOV
* MKV
* LXF
* MXF
* AVI
* WebM
* QT

On the other hand, **the codec is short for “Coder / Decoder” (compression / decompression)** and relates to the video compression algorithms that allow encoding to happen. Over the years, codecs have gone through multiple iterations as it coincides with the increasing sophistication and rise in the quality of filmmaking. 

If you’re a content creator, you might be aware of some of the video codecs that exist today:

- **H.264 – also known as AVC, this is the most widely-used video codec available on every platform and mobile device.**
- H.265 – also known as HEVC, stands for High-Efficiency Video Coding, and it’s slowly overtaking H.264 as the standard. This codec can compress video much more efficiently than its predecessor.
- **VP9 – is an open-source, royalty-free codec developed by Google and is considered the direct competitor of H.265. The video compression codec VP9 was created to reduce file sizes, making streaming videos simpler.**
- **AV1 – is another royalty-free, open-source codec released in 2019 by the non-profit Alliance for Open Media. It was developed to become the successor to Google’s VP9 and contend with HEVC more directly.**

## How do different technologies handle video encoding

As you may have suspected, there are a majority of ways that different technologies handle the video encoding process. Let’s take a look at the most common technologies that use video and how video encoding works on each of them:

### Video editing software

When it comes to video content creation, a majority of people will use one of two video editing software — Adobe Premiere Pro or Apple’s Final Cut Pro. Both of these video editing software handle video encoding in very similar ways: when exporting the finished video.

Depending on which device the video content is recorded on, it will already be encoded and formatted according to the settings of the device. For those using iPhones recording 1080p video at 25 frames per second (FPS), for example, the iPhone will automatically encode the video using H.264 and contain it in a .mov file format. The video editing software will “open up” the container to get to the encoded, compressed video file within so the editing process can begin.

After editing the footage is complete, it will need to be exported, which typically concerns video encoding. The edited raw media taken from a recording device such as a camera will be encoded via the codec of the person’s choosing before being put into a .mp4 container once they’ve hit “export”. As we’ve mentioned before, the most common codec used in video content creation is H.264 for HD videos, with 4K videos using H.265. 

### Websites

Different websites utilize different techniques to handle video encoding – with a majority of the major sites like YouTube, Netflix, and so on using their own technologies to handle the process. A majority of social media websites allow you to upload video files directly onto the site to share, although most of them require the files to be saved in specific containers. 

These websites will take your video file and transcode it before using their own systems and serves to re-encode it to match multiple display resolutions. This process will happen regardless of your video file's original codec and settings. Different websites have different processes, but companies that don’t have the capacity to build their own video encoding systems can use a third-party application programming interface (or API) to handle this process. These APIs act as [dedicated video encoder](https://api.video/what-is/video-encoding/) that allows companies to add on-demand videos to their websites more efficiently.

Using [api.video](https://api.video) as an example, all of the videos submitted to the platform will be transformed into H.264 codec in an MP4 container. This may be done using transmuxing and/or transcoding.

We expect the video bitrate to be lower than 16 Mbps for up to 1080p resolution and 50 Mbps for up to 4K resolution. We accept any bitrates, however, we will scale them down to the limits mentioned because anything above is usually challenging for most viewers’ connection to watch.

### API

The ability to generate, store, and distribute video is made possible via a video API. [api.video](https://api.video)’s solution can be tailored to suit any specific need. 

The backend process of video on demand (VOD) is exceptionally complex, even if you’re a software programmer specializing in video. It is necessary to encode, package, and typically transcode the data before sending it to any of several possible destinations. All of these things, and more, may be done with minimal fuss using api.video.

Our API basically keeps the complexities of streaming media hidden from view, so you can rapidly develop apps with as much control as you need. This saves time and effort so developers can concentrate on making the product.

## Conclusion

As you can see through this video encoding guide, a lot of work goes into making the video you watch and the video you share possible. Without video encoding compressing raw video footage, it could take days to upload and transmit video content over the internet and perhaps even longer to be able to download and enjoy them. 

The best part about encoding at api.video is that is offered at ZERO cost. You will only be charged for delivery and hosting of your videos, and the encoding will be free. Now integrate your videos in minutes with api.video or [contact us](https://api.video/contact/) for more information.

A Guide to Video Encoding & Video Codecs

large_poster-3.png

medium_poster-3.png

small_poster-3.png

thumbnail_poster-3.png

poster-3.png

Encoding and transcoding are often used interchangeably but they have slightly different definitions. **Encoding is the initial process of converting raw video files into a specific digital format or codec.** It involves compressing and packaging the video data, often to reduce file size while maintaining acceptable quality. Encoding prepares the video for storage, transmission, or playback.

&nbsp;

**Transcoding, on the other hand, involves converting a video from one digital format or codec to another.** This is typically done to optimize the video for different devices or platforms, adapt to varying network conditions, or ensure compatibility with specific playback requirements. Transcoding occurs after encoding and often involves changing resolution, bitrates, or formats without altering the content itself.

## What goes on behind encoding a video?

It's easy to say that encoding is when you go from an _uncompressed source_ to a _compressed source_, but you may ask, what exactly do compressed and uncompressed sources mean?

&nbsp;

Uncompressed sources are video files that contain data that comes directly from a camera sensor vs. encoded video. In the digital space, it's SDI (Serial Digital Interface) or HDMI (High Definition Multimedia Interface). Both of them are popular standards. You'll find HDMI in places like your GoPro camera, or a mini camcorder. These days, you might also find HDMI in professional settings, but SDI is more common due to its reliability. Another example of an uncompressed source would be something analog, for instance, VHS tapes.

&nbsp;

A compressed sources, on the other hand, are video files that have undergone compression during the encoding process. Compression involves reducing the file size by removing unnecessary information or encoding the data in a more efficient format. This process results in a smaller file size, making it more manageable for storage, transmission, and playback.


## What are the types of transcoding methods?

There are three types of transcoding, depending on what you are trying to do to get a video to suit a particular browser, player, or platform:

* **Lossless-to-lossless** - This type of transcoding maintains the quality of your video across formats but allows you to take advantage of better hardware or compression algorithms. 
* **Lossless-to-lossy** - This type of transcoding will decrease your video in quality, but it will benefit you in ways such as – you will get a smaller and/or faster playing file, or a file that is compatible with the requirements of a particular platform, player, or browser.
* **Lossy-to-lossless** - Sometimes people think this means they are regaining quality. This isn't the case in this type of transcoding. If you transcode from a lossy format to a lossless format, all that it means is that you will not lose additional quality in the conversion process. You will not regain data you already lost through compression.

## Codecs for encoding and transcoding

For both encoding and transcoding, you will need to make use of codecs. A codec's job is to compress and decompress video files. It's right there in the name -  **co**mpress **dec**ompress or encode decode. So basically, codec is an algorithm that takes the video and shrinks it or changes it into a format that makes it compatible with the requirements of wherever you want the video to play. There are many codecs because there are many ways to compress a video or livestream for playback.



## What is transmuxing?

Now that you know the difference between encoding and transcoding, let's throw one more term in there - transmuxing. Transmuxing is when you change the container for a video instead of the format. It's a way of repackaging a video to make it compatible somewhere without changing what's in the file. 

&nbsp;

This process is faster than encoding or transcoding and takes less computing power because you only change the container, not the file. It's great when you need to quickly make something available, but the downside is that it doesn't handle things like making multiple video resolutions available. If you choose a container type that's incompatible with your video file, you may also cause compatibility issues, resulting in not being able to play the video.

## In closing

* **Encoding** - Encoding happens when you compress a raw data file from a video camera sensor or an analog source like a VHS tape. 
* **Transcoding** - Transcoding happens when you take an already compressed video file and change it to another format.
* **Transmuxing** - Transmuxing happens when you change the container of a video file but leave the video file untouched. 

We hope that explains the difference between encoding and transcoding clearly. 

_If you are looking for an affordable video API solution that does not burn a hole in your pocket for transcoding and encoding videos, check out our offerings on our [homepage](https://api.video/) or [sign-up for a free account here](https://dashboard.api.video/register)!_

Encoding and transcoding: what's the difference? 

large_EncodingTranscoding.png

medium_EncodingTranscoding.png

small_EncodingTranscoding.png

thumbnail_EncodingTranscoding.png

EncodingTranscoding.png

Once I upload my video, how quickly will it be ready to be viewed?

Our reply to this question has always been “it's really fast.”  And it is really fast. But, the dev team gave me access to the backend database, and pointed me to a few tables that might be helpful (thanks to Thomas Persohn for your patient help!)

Thus armed, I waded into a sea of data to better understand how fast our videos are encoded at api.video

## Encoding

When a video is uploaded to api.video, it is re-encoded to a HLS stream, with several different video dimensions and bitrates.  This allows api.video to deliver properly sized video to all users - no matter the device or network connection. (Read our post on [Responsive video delivery](https://api.video/blog/video-trends/responsive-video-delivery/) to learn more.)

> Summary:  All videos are encoded at 240p, 360p, 480p, 720p, 1080p and 2160p. However, the videos are only encoded up to the initial size of the video (so if the original video is 720p, there will not be 1080p or 2160p versions available). 

**FYI:** For our customers, encoding is absolutely free – we offer adaptive bitrate encoding at zero cost. 

How long does this step take? If a customer uploads a video to our service - they want to know how efficient api.video creates the content for viewing.

### Data in the study

We are constantly making adjustments to our infrastructure to speed the encoding step of our video (and that is one reason this post is dated 2H 2020 - we expect to be faster in early 2021). The last major adjustment was made in mid October, so the data presented in this study from every video uploaded to the api.video service between 15 October and 2 December 2020.

### Parameters that affect encoding

There are 2 major parameters that affect the speed of encoding a new video stream: the output dimensions and the length (duration) of the video.  

#### Dimensions

The output video dimensions have a huge impact on video creation - a 3840 × 2160 (or 4K or 2160p) video has millions more pixels than a 320x240 (240p) video, so it takes a lot longer to create.  In general, the videos exit the encoding process from smallest to largest.

#### Duration

If a video is 30 frames per second, and is 60 seconds long, there are 1800 frames to be created.  If a 30 frame per second video is an hour long 3600s), there are 108,000 frames to be created, so the longer the video - the more time for creation.

## Analysis

To better understand the encoding time, I divided the data by the size of the output video size, and looked at 2 lengths of video  - those under 5 minutes, and videos that are 45-75 minutes long (we are often asked how long a 1 hour video takes to encode).

I calculated encoding time for each bucket of video using percentiles.  

> Quick review - percentiles break the data into 100 evenly sized segments, so the 25th percentile is when 25% of the videos have been encoded. The median is the 50th percentile, and is when 50% of videos have been encoded.  We report here to the 95th percentile for video encoding.

### Short videos - under 5 minutes long

Many of the videos uploaded to api.video are short - under 5 minutes long.  These videos are generally ready to play in a few seconds:



The above chart has a lot of data, the 25, 50, 75, 90 and 95th percentile encoding times for all 6 variants of the video that api.video creates.

The median video is ready to play (at 240p) in 5.6 seconds, but a 720p version will be ready in 15s after encoding begins, and the 4K version will be ready in 37 seconds.

95% of all videos (under 5 minutes) will be playable in 32.6s, and will have 1080p versions ready in just over 2 minutes (140s).

### Long videos - 45 - 75 minutes long

Our most frequently asked question on encoding is "how long for a 1 hour video to be encoded and ready?"  Here are the numbers:


Observant viewers will see there are no 4K videos in this report. At this time, there are very few 4K streams that reach the 1 hour timeframe, and the data was quite noisy.  Hopefully, more of our 'long uploads' will add 4K support, so we can add this metric in our next update.

The median hour long video (red line) will be ready to play (at 240p) in just over 9 minutes (555s), and a 720p version will be ready about 18 minutes after encoding begins (1099s).

95% of hour long videos will have a 240p version ready in 33 minutes, and 720p in 54 (3230s).  the 1080p version will be available for 95% of videos in 108 minutes,

## Conclusion

Short videos will be ready to play - even at high resolution - in under a minute: the median 4K encoding for a short video is 37s. 

Hour long videos take longer to encode, and the median 720p video will be ready in 18 minutes.  95% of 720p videos will be ready to play in 54 minutes.

This is really fast! You can have responsive streaming video ready for your customers in just a few minutes with a simple upload!

That said, our team is working hard in the background to improve our infrastructure to make our encoding speeds even faster! 

We're really excited to have hard numbers to share with you on our encoding speeds, and we cannot wait to re-benchmark this data in 2021 to see how much faster your videos will be encoded as we improve our service.

Do you have questions about api.video or video encoding? Reach out on our [community page](https://community.api.video).


Video on demand

Live streaming

Analytics

Video infrastructure

Video player

See all features

Online learning

Short-form videos

Marketplace & E-commerce

Video messaging and recording

Quickstart guides

Documentation

Ecosystem catalog

Clients & SDKs

Community

Blog

Demos

Help center

Tutorials

Follow along these tutorials using api.video