Video upload

Normal

small_t02cw29ka-u04jtt0jcg3-549047173ac2-512.jpeg

thumbnail_t02cw29ka-u04jtt0jcg3-549047173ac2-512.jpeg

t02cw29ka-u04jtt0jcg3-549047173ac2-512.jpeg

Artem Matinian

Tutorials

When considering building your project or website, you went through several languages and eventually settled for PHP. It’s a great language, easy to pick up and it can help you build your own project within minutes. 

&nbsp;
 

However, with all the great things that come with PHP, there are also some challenges. For example, how do you upload videos with PHP, while also making sure that users have a good experience while uploading and streaming these videos?

&nbsp;
 

You are probably already aware of some of these challenges, otherwise, you wouldn’t be reading this article. 😄

## How to upload a video: A step-by-step guide

For the sake of this example, let’s stick to the basics and build a very simple video uploader on an existing PHP server. The workflow is quite simple:

&nbsp;
 
1. Your PHP server shows the user a file selector.
2. The file selector lets the user pick a file from their device.
3. The selected file is delivered in a multi-part form to the PHP server.
4. The PHP server then uploads the video to [api.video](http://api.video/) for transcoding, hosting, and delivery.

&nbsp;
 
Now, let’s start with creating a simple PHP server . You can skip the Preparation if you already have PHP implementation set up.

## Preparation

### 1. Sign up to api.video for free

[Let’s create a free account with api.video.](https://dashboard.api.video/register) We’ll handle the video transcoding, hosting, and delivery for your viewers.

### 2. Install PHP

You can skip this step if you have PHP already installed. If not, you can find instructions in the [PHP official installation guide](https://www.php.net/manual/en/install.php).
&nbsp;
 
Alternatively, you can use MAMP to create a local server environment. Visit the [official MAMP website](https://www.mamp.info/en/windows/) for more information.

### 3. Install Composer

In order to get all the respective libraries for the use case we are building here, you’ll need a package manager. Let’s install Composer, a simple package manager for PHP. Check out the instructions on how to download and install Composer [here](https://getcomposer.org/doc/00-intro.md).

### 4. Create a PHP server folder

1. Let’s a new folder for the app. Choose any name for the project.
2. Create a new file called `server.php` inside that folder.

&nbsp;
 

Now that you’re all set, let’s begin with the process.

## Create the video uploader frontend

We’ll start by setting up the PHP server and the multipart form.

&nbsp;
 

1. The server will receive a request: we will check that the request type is [GET](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET).
2. We will also check that and that the URL that the user is hitting is `/`. This means that the user landed on the main page.
3. The multipart type form is necessary if the user uploads a file through the form. Give the form a `name` and an `id`. We’ll use it later on.


&nbsp;
 
Copy this script into your `server.php` file:

Now let’s do a quick test run! 

&nbsp;
 

1. Open your `cmd` or `terminal` 
2. Navigate to the PHP folder you've stored the project in

3. Run the PHP server (this command will run the file server.php on your local machine on port 8000)

4. Navigate to localhost:8000 on your browser

large_Screenshot 2023-11-13 at 21.30.51.png

medium_Screenshot 2023-11-13 at 21.30.51.png

small_Screenshot 2023-11-13 at 21.30.51.png

thumbnail_Screenshot 2023-11-13 at 21.30.51.png

Screenshot 2023-11-13 at 21.30.51.png

large_Screenshot 2023-11-13 at 21.31.45.png

medium_Screenshot 2023-11-13 at 21.31.45.png

small_Screenshot 2023-11-13 at 21.31.45.png

thumbnail_Screenshot 2023-11-13 at 21.31.45.png

Screenshot 2023-11-13 at 21.31.45.png

If this is the first time you are working with PHP, then congratulations - you’ve just created your first PHP website!

## Create the backend

Now that the frontend part is done, let’s set up the backend. The backend’s job is to:

&nbsp;
 

1. Receive the videos from the frontend
2. Send the videos over to [api.video](http://api.video) in order to make sure your users have the best experience while uploading and streaming.

### Configure file uploads in PHP

Let’s enable file uploading, and configure the size of the files your users can upload. To configure this, we need to find the `php.ini` in your implementation.

&nbsp;
 

1. In your terminal, type:

This should give you the following output:

Navigate to the php.ini file, and change or add these following values:

You can choose smaller or larger values than 150M. Now let’s save it.

### Receive the video files

Before the file is sent to [api.video](http://api.video), it has to be stored locally. This is only temporary and you can delete the file after your server uploads it to api.video.

This is the workflow we’ll follow:

&nbsp;
 

1. First, we create a new “endpoint” that accepts `POST` requests to an `/upload` endpoint. Remember our multipart form? It is actually already set up to submit the file to `/upload`. Multipart form are set to `POST` by default. So, we will create an `if` statement to handle that.
2. Once a `POST` request will hit this endpoint, it will pass in the file. We pick it up and save it in a `/uploads/` directory in the PHP server folder. Let’s create the `/uploads` folder inside the PHP project folder:

Now edit the server.php file and add this code we just described:

With this code, we take the file name and store it in the `/uploads` folder with the [move_uploaded_file](https://www.php.net/manual/en/function.move-uploaded-file.php) function.

&nbsp;
 

Awesome! Now we have a cool server that can ask the user for a file. Let’s run the server again to test it. Start the PHP server again:

Navigate to localhost:8000 and this time, select a file to upload and click on Upload Video. After the file is uploaded, you should see it in the /uploads folder in your PHP server project.

thumbnail_Screenshot 2023-11-13 at 21.56.23.png

Screenshot 2023-11-13 at 21.56.23.png

## Upload the videos to api.video

You’re more than half-way done, great job! 

&nbsp;
 

Now, you only need to add a small thing to all the mix. After uploading the video to your PHP server, you can just give your users public access to this file, and let them play it, right? 

&nbsp;
 

Not quite. There’s a lot of science behind delivering a video. While it can be delivered directly from your PHP server, your users may see issues with the playback: long loading times, and even issues with loading the video at all. It comes down to transcoding the video to different qualities, hosting the video on a scalable environment and having a good enough CDN that will deliver the video fast. You also need a capable player that will have all the options that your users need, without having to pour vast amount of money and resources into expensive services.

&nbsp;
 

With around ten simple lines of code, you can make sure your users have the best experience while watching and uploading their videos.

### Add api.video to your code

Now that you have an api.video account, grab your [API key from the dashboard](https://dashboard.api.video/apikeys) and paste it in as the value of `$apiKey` in the `server.php`:

Notice that we are also initializing the api.video client library. So, we need to run the Composer in order to get these libraries inside the server’s main folder.

&nbsp;
 

1. Let’s make sure that Composer is installed.
2. Open the terminal again and run these commands:

3. After the packages are installed, run the PHP server again:

## Deliver the videos

Let’s try upload a new video in your `localhost` environment. 

&nbsp;
 

Since we implemented api.video in the code, uploading a video will give you a response with different parameters, including the assets. The assets are actually the video you just uploaded in different streaming formats (HLS and mp4). You’ll notice that you also have an `iframe` parameter, which is your video embedded in an `iframe`. Let’s display the video as soon as it is ready. We’ll add a bit more code to retrieve the status of the video, so once it’s ready, we can display it in the `iframe`.

&nbsp;
 

Let’s add a status request to our code:

We’ve added a `while` loop that checks the video status. If the video is playable (which means that api.video finished transcoding it), we can take the `iframe` asset, embed it, and display it to the users. This part is handled in echo `$response->getAssets()->getIframe()`.

&nbsp;
 

Now save your code, upload a new video via `localhost`, and enjoy the show! 😊

How to upload a video file in PHP

large_Upload with PHP.jpg

medium_Upload with PHP.jpg

small_Upload with PHP.jpg

thumbnail_Upload with PHP.jpg

Upload with PHP.jpg

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

Erikka Innes

Product updates

api.video is proud to announce a brand new PHP client for our video API. Our old PHP SDK will be deprecated. You can continue to use it, but it will no longer be updated. Instead, the new PHP client will stay up-to-date with all our new feature releases. 

Like our other clients, it's autogenerated and handles authentication for you, including refreshing your access token when needed. It also handles paginated responses and chunked uploads for large files. A unique aspect of this client is that it is also [PSR-18](https://www.php-fig.org/psr/psr-18/) compliant. This makes it more reusable as it reduces the number of dependencies and lowers the likelihood of version conflicts.

You can install our new client with:
```composer require api-video/php-api-client```

And the entire client is available in the GitHub repository here: 
[https://github.com/apivideo/php-api-client](https://github.com/apivideo/php-api-client)

In addition to the documentation we have at docs.api.video, you can find client-specific documentation in the GitHub repository. If you are looking up parameters, we recommend that you refer to the content provided in the client respository first. Some information may be tweaked to make it easier to create and use the client. There's a docs page for each part of the API here: [https://github.com/apivideo/php-api-client/tree/main/docs/Api](https://github.com/apivideo/php-api-client/tree/main/docs/Api) 

PHP is fast, flexible and widely used in web applications. We hope you'll enjoy using our new client to code your video projects! 



api.video announces a new PHP client

large_php.png

medium_php.png

small_php.png

thumbnail_php.png

php.png

Delegated Upload

Python

api.video offers delegated uploads! For uploading video, this means you can create an authorization token, and choose how long your authorization token lasts, anywhere from a few seconds (this might be a bit extreme) to forever. The value in using a delegated upload token is that you don't expose your api key, authorization token, or refresh token. All you need is the delegated token you create. You can create tokens for users if you want them to be able to do uploads and you can delete tokens at any time if they are compromised, or no longer needed.

## How does a delegated video upload differ from a regular video upload?
Glad you asked! There are a few differences. If you use the regular upload endpoint, you must: 
* Use the authorization token you retrieve with your API key.
* Create a video container with any details you want to provide about your video.
* Upload your video into the video container you created. 

If you use the delegated video upload endpoint, you must:
* Create a delegated token for use with the delegated upload endpoint.
* Upload your video - api.video creates the container for you. You don't provide more detail than the file title. 

You can use the delegated token for as many uploads as you like, or delete the token if you don't need it any longer. You can add details about your video later using the update a video endpoint. 

## The Authorization Flow for Delegated Uploads 
You use your api key to authenticate and get a token. Then, you use your token to request a delegated token. The delegated token may be used for uploads through the delegated upload endpoint only. What's great about it, is if you want you can create and give this token to someone else to make uploads with. You can give the delegated token an expiry time, or let it last forever. Don't worry, you can also delete tokens if one of then is compromised, or if you don't need it any longer. 

## What's in this tutorial
We'll go over a code sample for: 

* Uploading a Video Under 200 MiB with a Delegated Token
* Uploading a Video 200 MiB or greater with a Delegated Token 

## Delegated upload for video under 200 MiB
<a title="RRZEicons, CC BY-SA 3.0 https://creativecommons.org/licenses/by-sa/, via Wikimedia Commons" href="https://commons.wikimedia.org/wiki/File:Upload.svg"><img width="256" alt="Upload" src="https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/Upload.svg/256px-Upload.svg.png"></a><br>
If you have a video under 200 MiB, upload is fairly straightforward. Here's the code sample: 

### Walkthrough - Delegated Upload for a Video Under 200 MiB

The start of this you're probably familiar with by now if you've tried the other tutorials. You're going to add the requests library, grab your API key (you can use sandbox or production, the difference being that for sandbox all video will be watermarked), and authenticate so you can get a token. 

### Retrieve a delegated token for video upload

Use your access token to set up the bearer auth header you'll need to retrieve a delegated token. For the body of your request, you need to add a value for the **ttl** field. TTL stands for time-to-live. In this walkthrough, we are setting ttl equal to 0, which means the token will last forever. You can set the token to other lengths of time in seconds. 

After you've set the payload, send your request, then retrieve the delegated token from the response. Armed with your shiny new token, you're ready to upload your video! 

### Upload your video that's under 200 MiB

To upload with the token, you need to send with the application/vnd.api.video+json header. Then the token is sent as a query field. The payload will be your video file, opened in binary. The title of your uploaded file will be the same name as the title of the file you send. 

## Delegated upload for video 200 MiB and bigger

This section shows you how to complete a chunked video upload. Because some of the code is the same as what was in the walkthrough directly preceding this one, we'll post the code sample, then focus in on what's different. 

After you get your delegated token, there are a few differences in the code to be aware of. Our read_in_chunks function stays the same, but for the upload function, notice that we set a videoId variable. This is because we are going to need to retrieve the videoId. 

Because api.video creates the video container for you on a delegated upload, you don't know what videoId you're uploading to. This is fine if you're uploading a complete video, but if you're sending your video in chunks, you need to tell the server what video container you want to send the chunks to. When you send your first upload request for a chunked video, include the Content-Range header (the only header you'll need) and then retrieve the response from your request. 

Get the videoId from the response, and in subsequent requests, you include the videoId. Like so: 

As you can see here, we use a few different tools from the requests library to make the subsequent requests. Your token for authenticating is a query parameter. The videoId goes in the body of your request. And you attach your file chunk as a file. 

If you change the name of the file in your requests (the spot where it says "file name here") then your file will be named to match that. Use the same title in both places for "file name here" in the code. The file you open for upload won't be referenced, because in a chunked upload, the request doesn't get the name of the file, it just has a chunk of the file attached each time. So it's a little different than a regular upload. 

There's only one step left for your chunked upload, and that's to use the function: 

Ta-da! You've done it! You've uploaded a video or a chunked video... or at least read all about it. In future posts, we'll go over how to manage your tokens. 

## Posts you may also like...
* [Upload a Video with the api.video API Using a Public URL (Python)](https://api.video/blog/tutorials/upload-a-video-with-the-api-video-api-using-a-public-url-python/)
* [Upload a Video From Your Computer with the api.video API (Python)](https://api.video/blog/tutorials/upload-a-video-from-your-computer-with-the-api-video-api-python/)
* [Upload a Big Video File Using Python](https://api.video/blog/tutorials/upload-a-big-video-file-using-python/)

Delegated uploads for videos large and small

medium_uploadbar.jpg

small_uploadbar.jpg

thumbnail_uploadbar.jpg

uploadbar.jpg

Android

thibault_rond.png

Thibault Beyou

Kotlin

This article is about how to easily add an upload mechanism from [api.video](https://api.video) to your Android application with a specific component from the Android API client and the Android video uploader called the UploadService.

In your Android application, if you use the `upload` API with the [Android API client](https://github.com/apivideo/api.video-android-client) or the [Android video uploader](https://github.com/apivideo/api.video-android-uploader), you might have noticed that it is not a piece of cake. Here are the main reasons why:

- **NetworkOnMainThreadException**: on the modern Android version, you must not perform network calls on the main thread; otherwise your application will crash with an `android.os.NetworkOnMainThreadException` . As `upload` is a synchronous API, you must call it from a Thread.
- **Background**: performing long-running tasks in your Activity is forbidden, so if the user sends your application to the background while an upload is in progress, the system might kill the process at some point and the file will never be uploaded
- **Upload management**: with the `upload` API you can't just cancel a running upload, you can't efficiently perform multiple uploads unless you have implemented it in a separate Thread.

At some point, you will have to implement the `upload` API in a dedicated Thread or an [Executor](https://developer.android.com/reference/java/util/concurrent/Executor) or, even better with [Kotlin coroutines](https://kotlinlang.org/docs/coroutines-overview.html). It might be a lengthy task if you are not familiar with these components. A Thread won't be able to handle uploads when the application is in the background. If you are already familiar with Android Services, you know that implementing a Service is a good solution for this kind of issue. Let's have a deeper look at this component.

## 1. Android Service

According to Android [documentation](https://developer.android.com/guide/components/services):

"A [Service](https://developer.android.com/reference/android/app/Service) is an [application component](https://developer.android.com/guide/components/fundamentals#Components) that can **perform long-running operations in the background**. It does not provide a user interface. Once started, a **service might continue running for some time, even after the user switches to another application**. Additionally, a component can bind to a service to interact with it and perform interprocess communication (IPC). For example, **a service can handle network transactions**, play music, perform file I/O, or interact with a content provider from the background."

Nice!

There is another interesting part about the service:

"When a service is running, it can notify the user of events using [snack bar notifications](https://developer.android.com/develop/ui/views/notifications/snackbar)
 or [status bar notifications](https://developer.android.com/develop/ui/views/notifications/build-notification)."

For a type of service called Foreground Service, your service must display a notification. The notification can look like a text, but it can also be an audio player.

When you start looking for Service notifications, they are everywhere.

untitled.png

Why am I talking about notifications? Because it would be nice to have a notification showing the upload's progress. Right? Like this:

untitled-1.png

So, if your application requires uploading files to [api.video](https://api.video/), the solution would be to call the `upload` API from an Android Service.

I have an excellent news for you: **the [Android API client](https://github.com/apivideo/api.video-android-client) and the [Android video uploader](https://github.com/apivideo/api.video-android-uploader) comes with a fully customizable Service whose purpose is to upload files, called UploadService.**

## 2. api.video UploadService

The UploadService is the easiest way to upload video files to [api.video](http://api.video) on Android.
It supports:

- upload with video id
- upload with upload token
- progressive upload
- progress notification of the upload of the current file
- success notification
- error notification
- multiple uploads: it uploads files from an internal queue
- cancel the upload of a specific file or all files

Here is a small video to show how it’s used in the [‣ example](https://github.com/apivideo/api.video-android-uploader/tree/main/examples/service):

### UploadService notification customization

The UploadService comes with many levels of notification customization:

- Notification color and icon
- Notification messages
- Notification itself. You can choose not to display progress or to display the name of the file currently being uploaded. For example, notifications could have a Stop button.

To customize the UploadService, the first step is to extend the UploadService:

If you have a closer look at the UploadService constructor, you will notice that you can change the notification icon and color with:

To have more controls over the notification, you can override `onUploadProgressNotification`, `onUploadErrorNotification`, `onUploadStartedNotification`, `onUploadCancelledNotification`, `onUploadSuccessNotification`, `onLastUploadNotification`.

There is a solution for each of your requirements!

### Implementation

As with every service, you have to declare it in the `AndroidManifest.xml`

As the UploadService is a Foreground Service (a special type of service), you also have to add:

Nice. We are almost done. You have to start it and bind it. Fortunately, there is a static API to simplify its usage:

As startService binds your application to the UploadService, you must call UploadService.unbindService when your application is put to background.

Once you have access to the service, you can call upload API for a video id

## Conclusion

With the UploadService, uploading a video to [api.video](http://api.video) has never been this easy! For a complete example with the UploadService, check out the [‣ example](https://github.com/apivideo/api.video-android-uploader/tree/main/examples/service).

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

Upload videos on your Android app with an Android Service

large_blog-thibault-article.png

medium_blog-thibault-article.png

small_blog-thibault-article.png

thumbnail_blog-thibault-article.png

blog-thibault-article.png

How to easily upload videos on your Android app with an Android Service?

Video update

large_logo_avatar.jpg

medium_logo_avatar.jpg

small_logo_avatar.jpg

thumbnail_logo_avatar.jpg

logo_avatar.jpg

api.video

NodeJS

no code

Video content is a critical digital media component, offering a dynamic way to share information and engage with audiences. [api.video](http://api.video) provides a robust video on demand platform, where you and your users can have full control over video accessibility. You can enable viewers to download the source videos directly from the api.video player, or from the player of your choice. Improve user experience and drive engagement in your solution by enabling viewers to access videos offline, or give content creators the ability to create backups of their media. It also works the other way around - you have the ability to disable video download functionality altogether and restrict access to the video source file, if that suits your use case better.

This article will explain the ways you can **enable or disable video downloading through the api.video player using our API and the Dashboard**, and will also give you a simple example for creating a custom download button for the player of your choice.

## Download access control with a single setting

api.video simplifies the process of offering downloadable videos by providing a single property that can be set to either `true` or `false` when a video is uploaded. The `mp4Support` property decides whether your viewers can access and download the source file a of a video. When enabled, this feature introduces a download button directly on the api.video player, allowing viewers to download videos with a single click. Setting the property to `false` on the other hand disables the download option, giving creators more control over the distribution of their content.

>The `mp4Support` property is enabled by default for all video uploads.

### Control downloads via the API

Let’s dive into how you can control video downloads programmatically when integrating with one of api.video’s API clients. 

>This example uses api.video’s **[Node.Js API client](https://docs.api.video/sdks/api-clients/apivideo-nodejs-client).** Check out our Libraries & SDKs for a complete list of [available API clients](https://docs.api.video/sdks/api-clients).

Utilizing api.video’s `/videos` endpoint, you can enable or disable downloads for individual videos during upload, or you can update an already uploaded video to change download permissions.

 
Let’s see how this process looks like when uploading a video: 

 

&nbsp;

1. **Create a video object and define the `mp4Support` property**

 

Now let’s see how the same thing looks like for a video that is already hosted on api.video:

>Check out the [API reference](https://docs.api.video/reference/api/Videos) for more details about the `/videos` endpoint, and take a look at the [Video Download guide](https://docs.api.video/vod/video-download)’s examples for other API clients.

### Enable downloads through the Dashboard

When you are hosting your own content at api.video, the Dashboard gives you granular control over every video that you upload. Check out the [Videos page](https://dashboard.api.video/videos) to see a list of all your uploaded videos!

&nbsp;

Let’s see how you can modify download access without writing a single line of code:

 

&nbsp;

1. Open the **Details** view for any specific video where you want to enable or disable download access:

Showing an uploaded video in the Dashboard

medium_Untitled.png

small_Untitled.png

thumbnail_Untitled.png

video_download_1.png

2. On the Video details page, click on the **Update video object** button:

Showing the Video Settings page in the Dashboard

large_Untitled (1).png

medium_Untitled (1).png

small_Untitled (1).png

thumbnail_Untitled (1).png

video_download_2.png

3. Modify the `MP4 support` setting with a simple toggle and click on **Update Video** to save your changes:

large_video_download_3.png

medium_video_download_3.png

small_video_download_3.png

thumbnail_video_download_3.png

video_download_3.png

Once you save your changes, the download button will appear for this video in the api.video player.

## Create a custom download button

Most video player solutions have native support for downloading the video’s source file. However, you can also add a download button to a custom player that does not have this functionality.

&nbsp;

Leverage api.video’s API by sending a request that retrieves the video’s `id`,  and then render a custom download button serves the `mp4` asset for video.

&nbsp;

Check out the [Video download guide](https://docs.api.video/vod/video-download#creating-a-custom-download-button) for a step-by-step walkthrough on how to create a custom download button using Node.Js, api.video’s Node.Js API client, npm, and React.

## Conclusion

The ability to enable or disable video downloads is a fundamental aspect of content management, and [api.video](http://api.video) is here to offer a simple and intuitive solution for both developers and content creators. 

&nbsp;

Explore the capabilities of api.video! Check out our [documentation](https://docs.api.video/), browse through the available [Libraries & SDKs](https://docs.api.video/sdks), and [sign up to get started for free](https://dashboard.api.video/register).

&nbsp;

Start with api.video today to deliver a comprehensive, feature-rich video on demand service. The team is readily available to assist you with any inquiries or to help you discover the full potential of api.video.

Enhancing Video Accessibility: Control Video Downloads with api.video

small_Blog_ VideoDownload.jpg

thumbnail_Blog_ VideoDownload.jpg

Blog_ VideoDownload.jpg

vimeo

Arushi_.png

Arushi Gupta

Video trends

_“Once a new technology rolls over you, if you're not part of the steamroller, you're part of the road.”_ - Stewart Brand, Writer

&nbsp;

Picture yourself in your office or home, daydreaming about your next thrilling vacation. Two options lie before you: flipping through a travel booklet, or immersing yourself in captivating videos showcasing breathtaking landscapes, mountains, oceans, delicious food, vibrant cultures, and more! If you had to choose, you will surely choose the second option, because let’s all agree, videos are far more realistic and give you the right information quickly. !

&nbsp;

But there are various formats to videos, and video-on-demand is one format in which videos are consumed today — thanks to video-on-demand (VOD) platforms like Netflix, Hulu, Hotstar, and more. 

&nbsp;

Now what are VOD platforms in the first place and how do they work? Let’s find out. 

## What is VOD?

Let’s first understand what is on-demand. On-demand is something that is desired for or wanted. Similarly, [video-on-demand ](https://api.video/what-is/vod-video-on-demand/)or VOD is any content format that gives the audience the power to watch it whenever, wherever, and however they want. It can be found anywhere on the internet for any purpose — be it entertainment, online learning, or e-commerce. Since VOD is streamed through the internet, there is no intervention of cable or satellite connections unlike traditional broadcasting methods. 

&nbsp;

And that is what makes VOD so popular and also, so convenient to use. 

## Benefits of VOD

Now that we know the meaning of VOD, let's look at some of its important benefits.

### VOD offers enhanced engagement

With VOD, you can create multiple videos for your products and services, providing proper descriptions of their features and functionalities. Attendees can watch, understand, and learn about your offerings through these on-demand streaming videos. Moreover, it is a common habit for people to watch various videos, read content, and then make product comparisons before making a decision. This provides you with an opportunity to capture the attention of a global audience for your products and services. 

&nbsp;

_Did you know?_

According to a 2022 study by [Wyzowld](https://www.wyzowl.com/video-marketing-statistics/), it was found that a massive 94% of marketers agree that video helped them understand a product or service better. It was also noted that 88% of people had been convinced to buy a product or service after watching the brand's video. Not to mention, the study also found that 96% of people watched an explainer video to know more about a product or service.



giphy.gif

### VOD is convenient for your business

Video on demand allows your audience or customers to watch content according to their will. There are no restrictions on place and time, and they can watch the video as they wish. The best part is that unlike most other general broadcasting services, VOD platforms’ availability is not restricted to certain geographical locations, so viewers from around the world can stream content. 

&nbsp;

_Did you know?_

[77% of Americans](https://www.statista.com/statistics/949965/pay-tv-streaming-satisfaction-rate/) report being happy with the convenience and flexibility of streaming video on demand, while [71% discarded cable TV](https://www.statista.com/statistics/319924/reasons-not-have-cable-usa/) as they can easily find the content they want online. 


### VOD tastes like freedom

VOD platforms offer the freedom to create content with complete control, free from advertisers' guidelines and restrictions. Producing videos-on-demand allows you to share your authentic self with the world. With just an idea, a camera, and an internet connection, you can craft the perfect video content for your product or service, ready to be showcased on your app or website.


giphy (1).gif

### VOD offers better opportunities at lesser cost

Video-on-demand proves more budget-friendly than hosting a virtual event or live streaming content. As opposed to livestreaming where you can be online for just a defined time — like a day or a week — video-on-demand has no restriction on the availability of your content and that allows people access to your content for a larger duration of time.


## What makes a great VOD platform

There are various aspects of a good VOD streaming platform. Let’s see what they are.

1. ### Customization with a white-label video player

The foremost focus of your product lies on branding. It is always great to have logos, images, and colors to maintain your brand's prominence by white-labeling your videos — and a good VOD platform should let you do that with ease. 

&nbsp;

At api.video, you get complete control to showcase your brand and [stand out with our customizable video streaming API](https://api.video/blog/product-updates/white-labeling-api-video/).

### 2. Content delivery network (CDN)

A content delivery network (CDN) is like the backbone of a VOD platform. A CDN plays a crucial role in delivering videos with minimal buffer time to your users across the globe, making sure they can enjoy smooth and speedy streaming.

### 3. Digital rights management

Digital Rights Management (DRM) is a tech tool that safeguards your content from piracy and unauthorized sharing. A good VOD platform usually has a DRM solution that lets you create videos and restrict their viewership to private or public. 

### 4. Multi-user access

A multi-user access feature provides custom access controls and user permissions within your business and for each target audience group. With the [help of built-in safeguards, a good VOD platform](https://api.video/blog/product-updates/workspace/) lets you share your workspaces with other members and collaborate on a project. 

## How is VOD different from live streaming?

The best way to describe the difference between VOD and live streaming is to understand real acting vs. reel acting. In theater, there are no second chances; what happens on stage is the final act. On the other hand, movies and series permit multiple takes, extensive editing, and color correction before producing the final video. Similarly, VOD empowers you to shoot, edit, and upload videos at your pace, granting you the freedom to pause, play, rewind and fast forward. 


giphy (2).gif

On the other hand, live streaming lacks such options since it takes place in real-time, untouched by editing. If you see the broader aspect, live streaming is a subset `of VOD as live videos can be watched on demand by the viewers at a later date. 

If you are wondering which one’s better, we would say both of them can be combined for a wholesome business package. While VOD offers convenience and accessibility, live streaming is more engaging for the user. 

## Is VOD the right option for you?

In a word, YES. There can be a lot to do in this era of online marketing, but video-on-demand can change your brand in a lot of ways. It is attractive because it grants you complete control over your videos without adhering to advertisers' guidelines. With the ability to shoot, edit, and upload at your own pace, VOD caters to diverse needs and audiences. Viewers can indulge in on-demand content, pause, play, and revisit their favorite moments at their convenience. 

&nbsp;

In a nutshell, VOD is an excellent way to connect with your audience and make a meaningful impact that can go a long way in your business’ growth but you need to evaluate your content goals, target audience, and desired level of control to be able to decide if it is the right option for your business. 

&nbsp;

_If you are looking for an API that lets you integrate videos seamlessly to your product, checkout [api.video](https://api.video/). With usage based pricing that does not burn a hole in your pocket, lightning fast encoding and a developer friendly API, you get everything you need at api.video to integrate VOD in your app or website._

&nbsp;

_[Sign-up ](https://dashboard.api.video/register)for a free sandbox account or [take a look at our features ](https://api.video/features/)now!_

What is VOD and how does it work?

large_Frame 427319229.jpg

medium_Frame 427319229.jpg

small_Frame 427319229.jpg

thumbnail_Frame 427319229.jpg

Frame 427319229.jpg

Announcements

alexw.png

linkedin Alex W

Alexandre Willot

We are excited to introduce Domain Restrictions, a feature that will allow you to restrict your videos and live stream playback to specific domains or subdomains, providing an additional layer of security for your videos and streams.

## 1. What does ‘Domain Restrictions’ do?

&nbsp;

With Domain Restrictions, you can now specify which domains or subdomains are allowed to stream your videos or live streams. This means that even if someone gets a hold of your API credentials, or video and live stream links, they won't be able to use them to watch or stream your content from an unauthorized domain.
&nbsp;

## 2. How it works

&nbsp;

1. Log in to your [api.video account](https://dashboard.api.video) and navigate to [Domains](https://dashboard.api.video/domains).
2. Click on "Set your allowed domains"

    

set your allowed domains api.video.png

3. In the conversation popup, input the domains or subdomains you want to allow.
4. Our customer care team will evaluate your request and provide you access as soon as possible 
5. You are all set! Your videos will only play from the list of domains you have listed.  

&nbsp;

## 3. Pricing

&nbsp;

As an api.video customer, you can use this feature at no additional cost for now. This will be a paid feature in the future. 
&nbsp;

## 4. Documentation

&nbsp;

If you need more information, you can explore our docs [here](https://docs.api.video/delivery-analytics/domain-referrer)

&nbsp;

## 5. What are the other ways to secure your videos?

&nbsp;

Domain Restrictions is just one of the many privacy and security features that api.video offers to help you protect your videos and streams. We take security seriously and are constantly working to improve our platform. 

For instance, our infrastructure provides safe, replicated video storage.

Also, in addition to domain restrictions, [api.video](http://api.video) offers multiple solutions to secure your online videos:

1. [Private videos](https://docs.api.video/delivery-analytics/video-privacy-access-management) will allow you to secure videos individually, you can select which videos are private and which are public. This is a very powerful feature that will help you control and manage access to video in a granular way. Get started with Private Videos [here](https://docs.api.video/delivery-analytics/video-privacy-access-management).

2. The [custom domain](https://dashboard.api.video/domains) feature lets you white-label the video experience you offer to your users, and also bypass firewalls that are configured to display content only from a finite list of approved domains. 

3. [api.video](http://api.video) offers a [video watermark functionality](https://docs.api.video/vod/add-a-permanent-watermark). It allows you to embed any watermark you want into your video to protect your content. For example, it is useful to apply watermarks if you are streaming copyrighted videos. 

4. Last but not least, if you use api.video’s player, you can also add your own [player themes](https://docs.api.video/delivery-analytics/player-customization). Among the options, you can [add your own brand logo](https://docs.api.video/reference/api/Player-Themes#upload-a-logo) on top of your player. While the video watermark gets burnt onto the video, this player feature only creates a front-end overlay on top of your video.

If you have any questions or feedback, please don't hesitate to reach out to our support team, at hello@api.video. Now time to set up your own playback restrictions based on your domains 😀

And if you don't have an api.video account yet but want to test the product, remember that api.video offers a [free signup option](https://dashboard.api.video/register), where you can test all of the product features.

Happy video day!

Restrict playback to specific domain with Domain Restriction

small_restrict_playback_cover.jpg

thumbnail_restrict_playback_cover.jpg

restrict_playback_cover.jpg

webhooks

Doug Sillars

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

* 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.


* 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.



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

bumperavideo-1.png

Restrict playback to specific domains with Domain Restrictions 

thumbnail_Arushi_.png

thumbnail_giphy.gif

thumbnail_giphy (1).gif

thumbnail_giphy (2).gif

thumbnail_thibault_rond.png

This article presents a new way to upload files to api.video from an Android application. It is based on a specific Android component called: WorkManager. To simplify the usage for developers, we added dedicated methods to the [Android API client](https://github.com/apivideo/api.video-android-client) and the [Android API uploader](https://github.com/apivideo/api.video-android-uploader) that we are going to discover in this paper.

On a previous article, we demonstrated how to use an Android service: the [UploadService](https://api.video/blog/tutorials/how-to-easily-upload-videos-on-your-android-app/). The WorkManager is an even easier and more powerful way to upload files. 🚀🚀👌👌

## 👷‍♀️👷‍♂️ Android WorkManager

The [WorkManager](https://developer.android.com/topic/libraries/architecture/workmanager) is a component of the Android Jetpack. It is a library that makes it easy to schedule deferrable, asynchronous tasks that are expected to run even if the app exits or the device restarts. The tasks could be constraint to specific device state before it is launched. For example, the WorkManager will execute the task only when the network is available.

For these reasons, it is perfect to perform long running tasks on background such as uploads.

To simplify the usage, we have developed dedicated API available in our [Android API client](https://github.com/apivideo/api.video-android-client) and in the [Android API uploader](https://github.com/apivideo/api.video-android-uploader).

## 👌 api.video for WorkManager

With the API provided by api.video with the WorkManager, you can:

- upload with video id
- upload with upload token
- upload with progressive upload
- display the progress notification of the upload of the current file
- get the progress of the upload of the files
- get the state of the upload of the files: success, error,…
- multiple uploads: it uploads files from an internal queue
- cancel the upload of a specific file or all files
- upload only when your device is connected

### 🛠️ Implementation

Before uploading a video, you have to create a video client with the `VideosApiStore`:

You also have to set notification Ids with the `NotificationConfigurationStore`. The `NotificationConfigurationStore` is a singleton store that contains configuration for the notification. We will have a look on the customization further.

You can now call methods to upload your files. The easiest way is to use [api.video](http://api.video) WorkManager extensions.

To upload a file with a video Id in your `Activity`:

And to upload a file with an upload token:

### 👂 Listen to Worker events

To listen the upload worker, use the `WorkInfo` . Get it with:

To listen to the upload status, use `workInfo.state`. You can also get the `Video` object with the `toVideo()` when the upload succeeds:

To listen to the progress of your upload, use `WorkInfo.progress` with the `toProgress()` extension.

### 🎨 Notifications customization

A light customization of the notifications could be performed with the `NotificationConfigurationStore`. 

For example, you can set the notification icon:

To have more controls over the notifications (such as changing messages), you can extend both `UploadWorker` and `ProgressiveUploadWorker` and overwrite the `onUploadStarted, onUploadError` and `onUploadProgressNotification`.

With this article, you should be able to quickly add a state of the art upload to api.video feature in your application 💪 

To start building right now with the WorkManager, check out this [example](https://github.com/apivideo/api.video-android-uploader/tree/main/examples/workmanager) and **[sign up for a free account](https://dashboard.api.video/register).**

Video on demand

Live streaming

Analytics

Video infrastructure

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

Blog

Huge pricing update! Introducing video encoding at zero cost