next.js

Normal

large_img_8063-min-1.jpg

medium_img_8063-min-1.jpg

small_img_8063-min-1.jpg

thumbnail_img_8063-min-1.jpg

img_8063-min-1.jpg

github-brands.svg

GitHub Yohann

5a22d420c9a5a7-416105621512231968826.png

LinkedIn Yohann

Yohann Martzolff

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

Next.js

Typescript

React

There’s no doubt that Next.js is a leading solution for creating a full-stack web application. Some of the biggest and finest companies around the world are using this React framework such as Twitch, Nike, and Notion.

On October 2022, Vercel released one of its biggest updates in a brand new version: Next.js 13. This new release ships React 18 with it and some big new features. 

*Read the full [Next.js 13](https://nextjs.org/blog/next-13) / [React 18](https://reactjs.org/blog/2022/03/29/react-v18.html) release notes to learn more.*

Let’s see how we can manage videos in a Next.js 13 and React 18 web application with [api.video](https://api.video) 🧘🏽‍♂️

## Create a Next.js 13 application 🚀

If you already have a Next.js project with a version under 13, you can upgrade it to v13 by [following this guide](https://nextjs.org/docs/upgrading). To keep this article simple, we will create a new application.

1. Run one of the following commands in a new terminal and follow the command prompts

We will name our brand new application videos_app. We will use TypeScript, ESLint (not mandatory), the src/ directory, and the app/ directory (since there is a new V13 feature available). 
Don’t configure any alias yet.

large_screenshot-2023-02-07-at-16-30-34.png

medium_screenshot-2023-02-07-at-16-30-34.png

small_screenshot-2023-02-07-at-16-30-34.png

thumbnail_screenshot-2023-02-07-at-16-30-34.png

nextjs-prompt.png

3. Check it out on `http://localhost:3000` and edit `src/app/page.tsx` to see the updated result in your browser.
Next.js 13 introduces the `app/` directory that can be used pretty much as the `pages/` directory. [More information available on their documentation.](https://beta.nextjs.org/docs/upgrade-guide#migrating-from-pages-to-app)

Everything is working fine? Good job! 🎉

💡 *Too long for you? Create a video-ready Next.js app with all api.video tools already installed in seconds with our official Next.js boilerplate! Read our short tutorial [here](https://api.video/blog/tutorials/api-video-next-js-boilerplate-start-your-video-project-the-easy-way/)* 🤓

## Our video application structure 🏗️

Our goal here is to build a basic but fully operational video application. To do so, we will divide it into 3 pages:

- Our landing page to upload a video ⬆️
- A player view where you can playback a video 📺
- A videos list view where all of your videos will be displayed 🏄🏽‍♂️

Next.js provides a perfect navigation and page system that will help us build our project easily.

## Get your API key 🔑

To be able to upload and playback videos from [api.video](https://api.video), create and customize video players, and do many more things, you need an API key.
Get it from your [dashboard](https://dashboard.api.video/login) or [create a free account](https://dashboard.api.video/register) (yes, it’s free, really).

## A minimal layout first 💅🏽

The goal of this tutorial is to make a working video app without any great design.
But we need a minimal layout: top navigation, and a little CSS to keep things readable.
We will also create a loading component that is automatically displayed while the content of a route segment loads 😲

1. Replace your `src/app/layout.tsx` code with the following one.

Next.js 13 `app` directory allows you to declare layout globally (root layout) and for specific pages (nested layouts). The `src/app/layout.tsx` file also replaces the previous `pages/_app.js` and `pages/_document.js`. *[Read more about it here.](https://beta.nextjs.org/docs/routing/pages-and-layouts#layouts)*

2. Create a new file `src/app/loading.tsx` and add a simple component.

In Next.js 13, a `loading.[tsx,js]` file in the `app` directory is globally and automatically used by your whole application for loading state. How great it is! *[Read more about it here.](https://beta.nextjs.org/docs/data-fetching/streaming-and-suspense)*

## Upload a video with Next.js 13 ⬆️

In this section, we will create a page that allows a user to select a video file and upload it to [api.video](https://api.video).

We will keep this view as our home page, the `src/app/page.tsx` file.

1. We need to use the [api.video TypeScript video uploader](https://github.com/apivideo/api.video-typescript-uploader#readme) package to upload a video to your project. Install it by running one of the following commands

As you can see, you will need an upload token to upload a new video. You can create and find yours [here](https://dashboard.api.video/project-settings/upload-tokens).

⚠️ *You can also decide to use an API key or an access token in the TypeScript video uploader, but it’s strongly discouraged because you’re exposing sensitive information*

Few things to notice here:

- `'use client'` : By default, the app directory’s components are [server components](https://beta.nextjs.org/docs/rendering/server-and-client-components). These components are great for rendering non-interactive content. 
However, if you want to allow client interaction in your component (React hooks, event listeners, browser-only APIs), you need to add the `'use client'` directive at the top of your component file.
- Next `<Link />` component: In Next.js 13, you don’t need to pass a `<a>` tag as children to the Link component.
- `onProgress` and `onPlayable` events: our TypeScript video uploader allows you to track upload progress whenever the uploaded video is playable.

Congratulations! You now have implemented a video upload solution into a Next.js application 👏🏽
Pretty easy right? Let’s move on to the next part: display your video list.

## Display a videos list with Next.js 13 🏄🏽

You can now upload videos to your [api.video](https://api.video) project. You can [watch and edit them through your dashboard](https://dashboard.api.video/videos). You can also implement this feature in your application. Let’s implement it together 🧑🏽‍💻

1. We need to use the [api.video Node.js client](https://github.com/apivideo/api.video-nodejs-client) to access our videos. Install it by running one of the following commands

2. Create a new videos directory under src/app/ and create a page.tsx file in it.
In Next.js 13, pages that are created under the app directory need to be named page.[tsx,js]. Read more about it here.

thumbnail_screenshot-2023-02-08-at-11-12-11.png

nextjs13-app-directory.png

3. Edit your new src/app/videos/page.tsx file with the following code

This component is a perfect example of a Server Component. Instead of using Next.js `api` directory or `getServerSideProps` to fetch our videos from [api.video](https://api.video), we can directly do this from our component.

Congratulations! You displayed all your videos in seconds 🏎️

## Playback a video with Next.js 13 📺

In any application, a video needs a container to be played, which is often called a player. In our video app, we will use the [api.video React player](https://github.com/apivideo/api.video-react-player) to playback our videos.

We want to access and playback a video in two different ways:

- Once a new video is uploaded and playable, we want to display a player in the same view to playback it directly.
- If we go through our videos list, each item is a clickable link that redirects us to the video view, and thus the player.
1. Install the React player package by running one of the following commands

2. Replace your src/app/page.tsx (the uploader page) code with the one bellow

A video player will now appear when your uploaded video is ready to be played.

3. Create a new directory `src/app/videos/[videoId]` and a file `page.tsx` in it, and add the following code to it

The new `app` directory lets you create dynamic routes as previously. Here, we are reading the `videoId` URL parameter with the reserved `params` Next.js parameter and sending it to our React player.

4. Go back to your videos list view and try to click on one of them. You should be redirected to the player view where your video can be read  🎉

We are excited to see the creative solutions built with [api.video](https://api.video) and Next.js 13!
[Join our community](https://community.api.video/) to share anything about video with other passionate people 💬

Create a Next.js 13 & React 18 video app

How to create a Next.js 13 & React 18 video app

small_Nextjs&React.png

thumbnail_Nextjs&React.png

Nextjs&React.png

video api

api video plugin

JavaScript

No doubt, Next.js is one of the best React framework for full-stack web applications.

What if you want to create your own video application? A Next.js boilerplate with all [api.video](https://api.video) features is ready for you to begin your journey 🧑‍💻 

## What’s a boilerplate 🤔

A boilerplate is a unit of writing that can be reused without change. The idea is sometimes applied to reusable programming, and that’s the case here: our Next.js boilerplate is a starter pack containing all [api.video](https://api.video) features that anybody can use, without having to change anything in it to start a new project. 

Of course, you are free to modify anything once your application is running!

## What can I achieve with this boilerplate 🥇

After the boilerplate has been bootstrapped, you can run your brand-new application and enjoy [api.video](https://api.video) features!

Upload videos, display them as a list, and play any video in a fully customizable player.

[api.video](https://api.video) proposes many more endpoints to manage and create a complete video application.
Check [our documentation](https://docs.api.video/) to learn about this.

## Get started 🏁

Find out about ***[how to use our boilerplate](https://github.com/vercel/next.js/tree/canary/examples/with-apivideo)*** on the README file, or follow the guide bellow 👇 

1. Create a new Next.js application by running one of the following commands in a new terminal and following the command prompts.

2. Rename the `.env.local.example` file with `.env`.
3. Find your API key in the [api.video](https://api.video) dashboard [API keys section](https://dashboard.api.video/project-settings/api-keys) and add its value to the API_KEY environment variable in the `.env` file.

💡 If you don’t already have an api.video account, create a free one [here](https://dashboard.api.video/register).

4. Start your application by running `yarn dev` in your terminal, and voilà!

You should be able to see a basic sample app from where you can upload videos and see them as a list.

large_screenshot-2023-01-31-at-17-24-04.png

medium_screenshot-2023-01-31-at-17-24-04.png

small_screenshot-2023-01-31-at-17-24-04.png

thumbnail_screenshot-2023-01-31-at-17-24-04.png

api-video-next-js-boilerplate-preview.png

Everything in this application is set up to build a complete video application, from Next.js to api.video, enjoy coding! 

Find the full boilerplate in the official Next.js repository [right here](https://github.com/vercel/next.js/tree/canary/examples/with-apivideo).

Start your video project with api.video Next.js boilerplate

large_NextjsBoilerplate.png

medium_NextjsBoilerplate.png

small_NextjsBoilerplate.png

thumbnail_NextjsBoilerplate.png

NextjsBoilerplate.png

api.video Next.js boilerplate: start your video project the easy way

strapi

large_logo_avatar.webp

medium_logo_avatar.webp

small_logo_avatar.webp

thumbnail_logo_avatar.webp

logo_avatar.webp

Github Mathieu Thiry

linkedin_logo_initials.png

LinkedIn Mathieu Thiry

Mathieu Thiry

[Strapi](https://strapi.io/) is a headless CMS used to develop websites, mobile applications, eCommerce sites, and APIs. Strapi allows you to create an API without knowing anything about backend development or databases. 

Today, we're pleased to announce our new plugin on the Strapi marketplace 🎊. A powerful, easy, and secure way to bring video content to your websites and applications using the Strapi interface. 

In this tutorial, we will focus on how to use the [api.video](https://api.video) plugin, and provide a basic example on how to integrate the api.video plugin into your project. 

## Install the api.video plugin for Strapi

Take a look at the following video which goes through the following:

* How to install the api.video uploader on your Strapi CMS with a few simple steps.
* How to add your api.video key to the Strapi CMS to connect your accounts.




You will need to have your instance of Strapi installed. If you haven’t installed a Strapi project yet follow this [guide](https://docs.strapi.io/dev-docs/quick-start). 

We are going to install the [api.video uploader](https://www.npmjs.com/package/@api.video/strapi-uploader-plugin) Strapi plugin in this step. Run the following command from within the project root of Strapi.

🎉 Congrats, the *api-video-uploader* plugin should appear in the **Plugins** section of Strapi sidebar after you run app again.

## Connect your api.video API Key

Before getting started, you will need to obtain an **API Key** which can be generated from the [api.video dashboard.](https://dashboard.api.video/)

On your Strapi dashboard, you will see the api.video uploader on the left side. Click on the api.video uploader and you will see the *Go to settings* button. Enter your API Key you have obtained on your api.video dashboard and copy it here. 

Now you are all set to upload your videos 🎖️

large_api-video-uploader-strapi.png

medium_api-video-uploader-strapi.png

small_api-video-uploader-strapi.png

thumbnail_api-video-uploader-strapi.png

api-video-uploader-strapi.png

## Manage and integrate your videos 

Take a look at the following video which goes through the following:

* How to add, update, and delete your videos on the api.video uploader in your Strapi CMS.
* How to integrate your videos into your application using the Postman application for testing.



## Upload your first video

As you can see, you have two options to add a video. Click any of the buttons, and a pop-up window will appear.

large_api-video-uploader-strapi-1.png

medium_api-video-uploader-strapi-1.png

small_api-video-uploader-strapi-1.png

thumbnail_api-video-uploader-strapi-1.png

api-video-uploader-strapi-1.png

You can choose to upload your video file by either clicking on the Select a video box or drag and drop your video file into the boxed area. As you can see, the video must have a title. Once you select a video and enter a title, you can go ahead and click the Upload button. Wow! You have just uploaded your first video 🎈

large_api-video-uploader-strapi-2.png

medium_api-video-uploader-strapi-2.png

small_api-video-uploader-strapi-2.png

thumbnail_api-video-uploader-strapi-2.png

api-video-uploader-strapi-2.png

Before clicking the *Upload* button, you can also add several video attributes that would help you or your business to organize and rank your videos in a more efficient way. You can write a description of the video, list a number of tags to categorize your video, and add metadata. 

By default, the metadata sends the value Strapi as upload source and can’t be deleted. However, you can add as many other metadata as needed.

medium_api-video-uploader-strapi-3.png

small_api-video-uploader-strapi-3.png

thumbnail_api-video-uploader-strapi-3.png

api-video-uploader-strapi-3.png

It’s worth mentioning that behind the scenes, it uses our home made [`typescript uploader`](https://github.com/apivideo/api.video-typescript-uploader) for fast uploading.

### Edit or delete your videos

You can edit and update your videos at any time. The information modified will be applied and visible on the Strapi dashboard. The delete option is available on the thumbnail.

### Configure the external resources**

large_api-video-uploader-strapi-4.png

medium_api-video-uploader-strapi-4.png

small_api-video-uploader-strapi-4.png

thumbnail_api-video-uploader-strapi-4.png

api-video-uploader-strapi-4.png

If you encounter an issue in visualising the thumbnail and the video like the image above, please add those 2 external resources `embed.api.video` and `cdn.api.video`. Modify the `middlewares.js` file like below:

## Permissions

With the Community Edition of [Strapi](https://strapi.io/), any user with the role of super administrator can configure and use the plugin.

With *Strapi Enterprise* the permissions can be fine tuned according to the role of the users. This is done in the **Roles** view in the **Administration Panel**.

large_api-video-uploader-strapi-5.png

medium_api-video-uploader-strapi-5.png

small_api-video-uploader-strapi-5.png

thumbnail_api-video-uploader-strapi-5.png

api-video-uploader-strapi-5.png

## Integrate the api.video uploader with your application

The `api-video-asset` collection type gives users a way of easily integrate [api.video](https://api.video) assets in their front-end application thanks to custom api call. 

The info that is stored on the `api-video-asset` collection type is the following: 


large_graphic_strapi.png

medium_graphic_strapi.png

small_graphic_strapi.png

thumbnail_graphic_strapi.png

graphic_strapi.png


The endpoint is protected, so you need a token to authenticate. Go to the *Settings* section on your Strapi dashboard and then select *API Tokens*. Click on Create new *API Token*. Select *Custom*  as your *Token type* and then scroll down to *Api-video-uploader* and choose what type of permission you want.

large_api-video-uploader-strapi-6.png

medium_api-video-uploader-strapi-6.png

small_api-video-uploader-strapi-6.png

thumbnail_api-video-uploader-strapi-6.png

api-video-uploader-strapi-6.png

After clicking on the Save button, copy the bearer token published. We are going to test it on Postman. Copy the following URL address ```http://localhost:1337/api/api-video-uploader/api-video-asset``` and paste it next to your request type. Go to Authorization, select the Type Bearer and paste the copied token. Click send and you will get your videos details! 

medium_api-video-uploader-strapi-7.png

small_api-video-uploader-strapi-7.png

thumbnail_api-video-uploader-strapi-7.png

api-video-uploader-strapi-7.png

## Final thoughts

We're super excited to see what folks will build with the api.video and Strapi 🤩 

If you're looking for an easy way to integrate video into your application, check out our **[docs](https://docs.api.video/)** and **[sign up for a free account](https://dashboard.api.video/register).**

api.video Strapi Plugin: Add videos to your headless CMS

large_api-video-strapi-plugin.png

medium_api-video-strapi-plugin.png

small_api-video-strapi-plugin.png

thumbnail_api-video-strapi-plugin.png

api-video-strapi-plugin.png

api-video-blog-product-updates.png

Product updates

As we all know, WordPress is an excellent platform to use for building your own website because it is easy to you. The variety of plugins at your disposal is a game-changer, especially if you do not code. 

We're pleased to announce our new WordPress integration on the [Wordpress plugins directory](https://wordpress.org/plugins/api-video/). 
If you have a WordPress website or blog, our plugin will allow you in a few clicks to:
* embed any of your videos in your WordPress content using our HTML5 video player
* manage your videos from your WordPress admin interface: list all your videos, upload a new one, and edit existing ones

All you need is: 

1. A WordPress website 🤓
2. An api.video API key (get a free sandbox key [here](https://dashboard.api.video/register))


## Installing the api.video WordPress plugin

### Adding the plugin from the plugins library

The easiest way to install the plugin is to use the plugin search. Log in to your WordPress administration area, and go to the **Plugins » Add New** page. 

Plugin installation from the plugins directory

plugin-installation-from-directory.jpg

You'll see a screen like the one above. In the top-right search area, type "api.video". You should see the api.video plugin appear. 

Click on the **Install now** button on the api.video plugin card. After a few seconds (or minutes, depending on your connection), the **Install now** button changes to **Activate**. Click on **Activate** to activate the plugin. That's it; the plugin is installed!

### Setting up the plugin

There is one last step before using the plugin: you have to enter your api.video API key in the plugin settings.

A new entry called **api.video** automatically appeared in your administration menu after you installed the plugin. Go to the **api.video » Settings** page.

Enter your API key in the plugin settings

plugin-installation-api-key.jpg

Copy your API key from your [api.video dashboard](https://dashboard.api.video) and paste it in the dedicated field, as shown in the above screenshot. Finally, click on the Save button. If an error message appears, double-check your API key. 

## Usage

### Uploading a video

To upload a new video, go to the **api.video » Add new** page. From here, you'll be able to select the video file you want to upload by clicking on the **Select files** button.

plugin-add-new-video.jpg

Once the video file has been selected, the upload starts automatically. Once the upload is complete, a link is provided to the video editing page ("Watch the video here" link). By clicking on this link, you'll be redirected to the video editing page (see bellow [Editing a video](#editing-a-video)). 

### Listing your videos

You can find the list of all the videos you have uploaded to your api.video account by clicking on **api.video » Library**. For each of your videos, you will see the associated thumbnail and its title.

plugin-videos-list.jpg

If you want to integrate one of the videos into an article and then modify it, click on the associated thumbnail. You will be redirected to the **video editing page**. 

### Editing a video

You can access the video editing page right after uploading a video or selecting an entry in the videos list.

plugin-edit-video.jpg

From here, you'll be able:
- to update the video title, description, and tags
- to decide whether the video is private or not, panoramic or not, and downloadable or not 

Don't forget to click on the **Save** button after making your changes!

Another essential element on this page is the **"shortcode"**. This is what will allow you to embed the video on your website.

### Embedding a video in a post/page

The first step is to copy the **shortcode** associated with the video you want to embed. This shortcode can be found on the [video editing page](#editing-a-video). 

Once you have copied this shortcode, go to the editing page of the article where you want to embed the video. 

At the spot where you want the video to appear, insert a "shortcode" block into your article. One way to do that is to show the **block inserter** by clicking on the big **+** at the top left of the page. Then type "shortcode" in the search input and click on the **Shortcode** element. 

plugin-shortcode.jpg

Once the block has been added in your article, you now have to paste the value you copied in the video editing page (it should look like **[api.video video_id=123456789]**).

Paste the shortcut value into the dedicated input

plugin-shortcode-paste.jpg

In most cases (but it depends on your WordPress theme), you will get a better result if you transform the block to "Columns." To do so, click on the first icon above the block and select **Columns**.

plugin-shortcode-columns.jpg

And that's it! Once your article is saved, you will see the video appear where you inserted it. 

Your video is now embedded in your article

plugin-player.jpg

## Conclusion

If you have any questions, please ask us on our [community forum](https://community.api.video/).

For any feature request or bug report, don't hesitate to open an issue on the [Wordpress plugin Github repository](https://github.com/apivideo/api.video-wordpress-plugin).

The New api.video WordPress Plugin

large_wordpress-andapi-video.jpg

medium_wordpress-andapi-video.jpg

small_wordpress-andapi-video.jpg

thumbnail_wordpress-andapi-video.jpg

wordpress-andapi-video.jpg

Uploading a video to api.video just got easier!

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


## JS Uploader Widget

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

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

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

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

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

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

```

### Walking through the code

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

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

```

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

The retry count defaults to 5.  

#### During Upload

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


```

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

#### Upload complete

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

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

```


## Conclusion

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

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

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


New video uploader JavaScript library

large_new-video-uploader-javascript-library.png

medium_new-video-uploader-javascript-library.png

small_new-video-uploader-javascript-library.png

thumbnail_new-video-uploader-javascript-library.png

new-video-uploader-javascript-library.png


Here at [api.video](https://api.video), we love making video delivery easy for our customers. We take care of doing all the video transcoding and [video streaming](https://api.video/product/live-stream/) so that you can focus on all the other facets of your product. Using our APIs (and our SDKs) is a straightforward and easy way to add video to your service. In this post, we’ll walk through the steps to create a website where you can upload videos.

> Note: Use NodeJS in the middle results in a "double upload" - the video is uploaded to the Node server - then to api.video.  You can avoid this with a [delegated token](https://api.video/blog/endpoints/delegated-upload/) and our [JS library](https://api.video/blog/tutorials/new-video-uploader-javascript-library/).

You can also check out our API reference documentation here: [API Reference documentation](https://docs.api.video/reference)

## Overall Architecture

![Overall architecture api.video](https://cdn-images-1.medium.com/max/800/1*Vje7Cz76uC0VTHLkrAmGFQ.png)

1.  Starting with a web form, a video is submitted to the Node server.
2.  The video is immediately uploaded to api.video for processing
3.  api.video acknowledges the video upload, returns the videoId, and begins encoding the video.
4.  The node server polls api.video to obtain the playable status (confirming that encoding is completed).
5.  As long as the result is “false”, the polling continues.
6.  When the video is playable, the Node server returns a page with the video. The video autoplays to show that the video is ready to play. The page also returns the timings for upload & for video processing.
7.  The video link is e-mailed to the user (optional).

### Getting Started

### Node & Dependencies

There are a number of required Node dependencies:

``` 
npm install express dotenv @api.video/nodejs-sdk fs pug serve-favicon formidable email-validator
```

This tutorial also optionally connects to Intercom to send emails to your users. This will require:

``` 
npm install intercom-client
```

### Building the Site

### Starting index.js

You can clone the GitHub repository to follow along, but here is the code that builds your video uploader:

In the src/index.js file, copy the following code:

In this snippet, Node imports Express (and dotenv for environmental variables). The first big chunk of code creates and sets up an express app. It will use Pug to build the views. Static files are saved in the ‘public/’ directory, and serve-favicon adds the favicon to the site. You can use the default favicon in the public directory on GitHub, or create your own.

Next we have app.get — on the default entry point of the site. If a request occurs at the “/upload-demo” directory of the web server, we’ll deliver the start.pug file that is saved in the views directory.

Finally, the app listens on port 3000 for requests. If you run npm start from the terminal, you should get a response of “Example app listening on port 3000!” You can now enter “localhost:3000/upload-demo” into your browser, and if you have added the views directory — you’ll see the form. If you have not yet added the view, you’ll probably get an error.

### Start.pug

The landing page is simply an introductory text describing the upload and a form to select the file. This page is created with Pug. Pug is really persnickety about indentation spaces, so it might be best to copy the code (or just use the code) from GitHub rather than copy and paste from this post.

In the head tag, we load some CSS and the favicon.

test-out-api-video.png

The body loads descriptive text on api.video, and the submission form. The form takes 4 inputs: video name, e-mail, true/false mp4 support and the video file. You may notice that the form action will reload the root directory of the server. Since the data submission is a POST, it will be easy to identify the 2nd request.

### POST Form Processing

Add these additional lines to the index.js. At the top of the file, we need to add dependencies:

api.video is our backend where uploaded videos are transcoded into video streams. We add the SDK, and then I store my API key in a .env file. I have added the .env file to my .[gitignore](https://git-scm.com/docs/gitignore) file so that when I post my code on GitHub, my key is not uploaded and remains secure.

We also add formidable to read the form data and save the video locally on the Node server. The e-mail validator does what it sounds like it might do, and finally I add three variables to measure how quickly the service handles the video processing.

In the body of index.js, add the following:

We are now building the POST response. Formidable saves the video in the directory specified in the .env variable videoDir (this doesn’t have to be private, but it is nice to save all configurable variables in one place). When the upload requests mp4 support, the variable must be a boolean, so we use the string from the response to create the corresponding boolean value. The email validator validates the email, and if the email is valid  -  we use production credentials at api.video (permanent video hosting). If there is no e-mail, or it is not valid, the video is instead processed in the Sandbox, meaning that it will be watermarked & deleted after 24 hours. For your use — you probably just want to post to production, so you can simplify this logic.

Finally, we begin the upload of the video to api.video (and capture the time of the upload start).

If you try to run this code now, it will hang — we are not yet listening for the response from api.video. However, adding:

```
console.log(result);
```

Will show the JSON response from api.video:

The videoID is important to display and playback the video, as are the assets. We also can see useful metadata about the video — Mp4Support, Panoramic, public/private, etc. Note that there is no mp4 url — the video must be encoded to receive that url, so we’ll grab it later.

### Video Upload Response

After the “let result = client.videos.upload(files.source.path, {title: fields.title, mp4Support: mp4Support});” paste in the lines below.

We listen for the result from the upload. This allows us to mark upload completed (to measure the elapsed upload time). If the video has successfully been uploaded to api.video, we now have 2 copies of the video: one on the node server, and the other at api.video. Fs.unlink deletes the file on the node server. The JSON response gives us the videoId at api.video, and links to the iframe and player video urls (which we assign to variables). The mp4 url is only presented in this response when encoding is finished.

Even though we have the urls to the videos, they have not been processed yet. To determine if the video is playable, we call the videoStatus function. This sends a request to api.video to obtain the video status. The response is a JSON with lots of details about upload status, file size, and metadata like the dimensions and bitrate (you can learn more about these parameters in the [documentation](https://docs.api.video/reference/api/Videos#retrieve-video-status-and-details)):

Reading the videoStats.encoding.playable value tells us if it is ready to play or not. If it is not ready, we call videoStatus again recursively until we get the affirmative response. When we receive that ‘playable’ is true (as in the example above), the function can then query for the MP4 url, and return the view to the user: return res.render(‘video’, {iframe, player, uploadSeconds,processSeconds});

This means that video.pug will be displayed to the end user with some variables (the urls of the video, and timings on upload and processing). We’ll discuss that view in the next section.

### Displaying the Video

The Video.pug file is a simple html file that simply adds an iframe for the video, and reports the elapsed times for upload and processing of the video. The variables are ensconced in #{} tags. One other interesting thing to note is adding #autoplay to the url tells the video player to autoplay the video (you can also add #loop to loop the video).

And there we have it, a working video upload tool, where the response page shows the encoded video, along with the time for upload and for processing! Pretty cool!



webpage-video-upload-screenshot.jpg

### Optional Step: Email integration

In the video upload response section, there is a line of code that calls the intercom integration:

We first create a lead (or a contact) inside Intercom. This will come back with an id that uniquely IDs the user. If the email address already exists, Intercom returns an error message that says “There is already a user with the id=<idnumber>.” So, if the user already exists, we can parse the error message to grab the user id.

Then we can add a tag to Intercom to show that the user has used the video upload tool, and we send an email to the user’s email address with links to the videos, and the time it took to upload and process the videos. The text of the email is right in the code, so easy to modify.


### Update (2022)
	
We have a new version of a video uploader that uses a delegated token. It is live at [upload.a.video](https://upload.a.video), and you can read a post on [delegated token upload](https://api.video/blog/tutorials/uploading-large-files-with-javascript/). Delegated tokens remove the "double upload" to Node and then to api.video: videos are directly uploaded to api.video.
	
	
### Conclusion

We’ve built a video uploader using Node.js and api.video. The easy to build tool now gives us the ability to easily share our videos across our internet properties. Using Node and api.video, the entire process creates an easy to use interface to take regular videos, and convert them into video streams. If this tutorial has inspired you (or if you have any questions), let us know by posting in our [community forum](https://community.api.video/). 

Building a video upload demo with Node.js and api.video

medium_githubsocialnodejs.png

small_githubsocialnodejs.png

thumbnail_githubsocialnodejs.png

github-social-nodejs.png

api.video Strapi Plugin: Add videos to your headless CMS.

Player SDK

video create

Video list

Video upload

Player

Mobile

This tutorial will show how quick and straightforward it is to build a TikTok clone as a progressive web app (PWA) with [api.video](https://api.video/use-cases/short-form/) and Next.js. A PWA is a website that looks and behaves like a mobile app. It can have all the capabilities of a native mobile app, like design and functionality, and you can even install it on your phone!

TikTok’s core functionality is to create and share short-form content. So today, we will focus on these crucial features:
- **Get** videos with [@api.video-node.js-client](https://github.com/apivideo/api.video-nodejs-client) package
- **Display** videos with [@api.video/react-player](https://github.com/apivideo/api.video-react-player) package
- **Upload** videos with [@api.video-typescript-uploader](https://github.com/apivideo/api.video-typescript-uploader) package
    
Thanks to these 3 easy-to-use api.video tools, you will have everything you need to build a **smooth scrolling** TikTok feed. Let's start 🎬
    

*NB: You can see the demo [here](https://api-video-tiktok-demo.vercel.app) and the complete code [here](https://github.com/apivideo/tiktok_clone). We invite you to clone the project, insert your free-to-use API key from our Sandbox environment and start testing it with your videos!*

Video on demand

Live streaming

Analytics

Video infrastructure

Video player

AI features

See all features

Online learning & Corporate training

Social & Entertainment

Marketplace & E-commerce

Communication & UGC

Generative AI

Quickstart guides

Documentation

Ecosystem catalog

Clients & SDKs

Community

Blog

Demos

Customer success stories

Help center

Typescript