Video upload

video create

Normal

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

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

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

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

Erikka Innes

large_api-video-blog-tutorials.png

medium_api-video-blog-tutorials.png

small_api-video-blog-tutorials.png

thumbnail_api-video-blog-tutorials.png

api-video-blog-tutorials.png

Tutorials

Python

If you'd rather watch this tutorial as a video: 

This tutorial is a tweak on the content provided in [Use Flask with Dropzone.js to Upload Videos Under 128MB (No Client)](https://api.video/blog/tutorials/use-flask-with-dropzone-js-to-upload-videos-under-128mb-no-client/). In this version of the tutorial I'm using our new Python client. With api.video's Python client, you can upload videos of any size because chunked uploads are handled for you. 

Flask is a WSGI web application framework. It makes getting started with building a web application quick and easy. It's based on the Werkzeug WSGI toolkit and the Jinja2 template engine. It's very popular for creating backends for webpages, and that's what I'll be using it for today. 

Dropzone.js is an opensource JavaScript library that lets you create drag n' drop file uploads with image previews (when available). It doesn't have dependencies on other libraries, and it does a lot of work for you so you can focus on styling and configuration. I'll use a very simple format in this tutorial, but you will be able to style it however you want.

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

## Prerequisites
For this project you'll need:

* [api.video account](https://dashboard.api.video/register)
* Python installed
* api.video Python client installed
* Virtual environment for your project (optional)
* Flask installed
* Project files - [https://github.com/apivideo/python-api-client/tree/master/examples/flask_and_dropzone](https://github.com/apivideo/python-api-client/tree/master/examples/flask_and_dropzone)
 

## Set up

To get started, you'll need to do these things:

1. Grab the code from GitHub - [flask_and_dropzone](https://github.com/apivideo/python-api-client/tree/master/examples/flask_and_dropzone)

2. Install the api.video client. That's going to be ```pip install apivideo``` 

3. In my version of the project, Dropzone.js is attached using CDNs. You can also reference these using the static folder and placing dropzone.js and dropzone.css there. Just change the references in index.html if you want to do this instead.

Let's roll! 

## What's in index.HTML? 

The HTML file for this project is exactly the same as for [Use Flask with Dropzone.js to Upload Videos Under 128MB (no client)](https://api.video/blog/tutorials/use-flask-with-dropzone-js-to-upload-videos-under-128mb-no-client/). 

EXCEPT FOR ONE THING. I added a very long timeout - it lasts about 45 minutes. If you don't plan to upload giant video files, you don't need to include this (```timeout: 2700000```). By default, Dropzone will wait 30 seconds, then timeout. Everything is in milliseconds, so normally this would be 30000. Even though Dropzone times out, your video file will still continue to upload. But the visual will show a file with a graphic that is X'd out. This might lead you to restart, losing the upload, or assume it's not working. So if you plan to use this sample for giant files, I recommend leaving the timeout. 

## What's in app.py? 

Here's what's set up for the backend:

This sample is based off of Miguel Grinberg's tutorial [Handling File Uploads With Flask](https://blog.miguelgrinberg.com/post/handling-file-uploads-with-flask/page/4). You will recognize some of the security items in the code. MAX_CONTENT_LENGTH is a way you can limit how big the files people upload are. Because this sample is supposed to be for files of any size, the content length is massive. UPLOAD_EXTENSIONS limits what types of files people can upload. 

**NOTE:** While this is set up to handle big files, please be aware that if you drop four or five giant files at once it will take awhile. If you want to be able to do that, you might have to experiment with the timeout setting.  

Next there's an error handler to tell you if a file upload is too big (not likely with the sample settings). 

The main route and definition upload_file() does a few things. First it gets all the files you put in the Dropzone. Then it retrieves the api key. The files are stored as FileStorage objects inside an immutable multidictionary. An easy way to process each file is with a loop, so you can loop through for each one (or just the one) and do a couple of checks. Check that the filename isn't empty (because you can't send it like that). Then check if the file extension is allowed. 

Next you'll set up the api.video client so you can use the videos endpoint. Then you send your file. The chunked upload is handled by the client without showing progress information. Give big files some time to upload. 

If you want a progress bar, there are a lot of easy ways to display progress without the client, but then you have to set up chunked uploads yourself. 

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

## Resources 

* [Flask Documentation](https://flask.palletsprojects.com/en/2.0.x/)
* [Dropzone Documentation](https://www.dropzonejs.com/)
* [Flask and Dropzone Sample App](https://github.com/apivideo/python-api-client/tree/master/examples/flask_and_dropzone)



Use Flask with Dropzone.js and api.video Python client

medium_erol-ahmed-y3kebqlb1zk-unsplash.jpg

small_erol-ahmed-y3kebqlb1zk-unsplash.jpg

thumbnail_erol-ahmed-y3kebqlb1zk-unsplash.jpg

erol-ahmed-y3kebqlb1zk-unsplash.jpg

Use Flask with Dropzone.js and api.video Python client to upload many videos of any size

JavaScript

Hello Pythonistas! Today let's learn how to upload a video using Python's Flask and Dropzone.js. 
In this tutorial, we'll use Python (for a version where you use our new api.video client, please see: ) and Dropzone.js. 

Flask is a WSGI web application framework. It makes getting started with building a web application quick and easy. It's based on the Werkzeug WSGI toolkit and the Jinja2 template engine. It's very popular for creating backends for webpages, and that's what I'll be using it for today.

Dropzone.js is an open source JavaScript library that lets you create drag n' drop file uploads with image previews (when available). It doesn't have dependencies on other libraries, and it does a lot of work for you so you can focus on styling and configuration. I'll use a very simple format in this tutorial, but you will be able to style it however you want. 

## Prerequisites 

For this project you'll need: 

* Python installed
* Virtual environment for your project (optional)
* Flask installed
* Project files - https://github.com/apivideo/python-examples/tree/main/videos/Flask%20with%20Dropzone 
* Api.video account - if you do do have one, you can [create one for free](https://dashboard.api.video/register)

## Set up 
To get started, you'll need to do these things: 

1. Grab the code from [Flask and Dropzone.js](https://github.com/apivideo/python-examples/tree/main/videos/Flask%20with%20Dropzone).

2. In my version of the project, Dropzone.js is attached using CDNs. You can also reference these using the static folder and placing dropzone.js and dropzone.css there. Just change the references in **index.html** if you want to do this instead. 

## What's in index.HTML

1. Let's start by walking through the HTML file **index.html**. It's in the **templates** folder. 

2. First add the scripts and stylesheets you'll need for the project. I'm using Dropzone with bootstrap. So I've added the scripts and stylesheets for that.

3. Next let's skip ahead to the body of the HTML code and look at the way the form is set up. I place the form between the body tags, and I'm using a simple form, so it looks like this:

4. I add a form action to show where I want the information to be sent to. In this case I'm using "/" as the route. Next, I add the class **dropzone**. This tells Dropzone where to add the drag n' drop zone. In the form I add an ID, because I'll have to make some changes to how Dropzone is set up, and I specify that it's going to be a POST request to "/". Along with sending files, I want to send the API key, so I add a field for that, and I want everything to send when I press **Submit** so I add a button for that. 

5. Now let's take a look at customizing the dropzone. By default, Dropzone wants to upload your file the second you drop it in the zone. I don't want that to happen, because I'll get an error. The file (or files) need to be sent with my API key in order to be posted on the api.video servers. So the first thing I'm going to do is set up to configure some Dropzone options. In order to reference my Dropzone, I use the ID written in camelcase. The zone ID I chose is **my-dropzone** so that becomes **myDropzone**. I chose to add the script directly to the HTML in the head tags, but you can reference it from a separate file if you prefer.  

6. To prevent Dropzone from trying to upload files right away, I set **autoProcessQueue** to **false**. I want users to be able to upload multiple files, so I put **true** for uploadMultiple. **parallelUploads** I set to 10 max and I set the total number of files you can add at one time (**maxFiles**) to 10.
 
7. Next I set up the submit button. The code here tells Dropzone to process the files after the user hits **Submit**. And that's it for the script! Let's set up the backend next.

## What's in app.py
Here's what's set up for the backend: 


1. I start with imports for features of Flask, the os library, and the requests library.
 
2. Add limits to what kind of files a user can upload with the line: ```app.config['UPLOAD_EXTENSIONS'] = ['.mov', '.mp4', '.m4v', '.jpm', '.jp2', '.3gp', '.3g2', '.mkv', '.mpg', '.ogv', '.webm', '.wmv' ]``` 

3. This demo only handles files up to 199 MiB so let's add an error handler route (@app.errorhandler(413)). 

4. When you start up the app, I want you to see the **index.html** template. So that template is returned for @app.route('/').

5. To process the file and API key, they must be retrieved from request.files and request.form. request.files can contain more than one file, so I'm assigning the files to my_files. 

6. Assign the API key from the form to api_key. 

7. You'll recognize the set up after this from previous tutorials - it's setting up to retrieve an access token with the API key, then creating the headers with the token so everything is ready to start posting files. 

8. Because my_files could have one or many files and I want to be sure to process them all, I'm using a for loop. The code here creates a video container to upload to and adds the title. It retrieves the video_id so a video can be uploaded to the container. Then it sets up the request and posts the video into the container. It will loop through every video and send it, so long as the video is under 200 MiB. 



That's it! You now have a way to upload videos using Dropzone and Flask without using the Python client. In the next tutorial, we'll upload using the Python client. The client will allow us to automatically handle chunked uploads and handle videos of any size. 
Don't hesitate to reach us on [our Community](https://community.api.video/)!

### Resources 

To build this tutorial, I used this documentation, and it might help you too: 

1. [Handling File Uploads with Flask](https://blog.miguelgrinberg.com/post/handling-file-uploads-with-flask) - A great tutorial that shows how to set up with a basic Dropzone. 
2. [Dropzonejs.com](https://www.dropzonejs.com/) - Details about how to customize Dropzone. 

Use Flask with Dropzone.js to upload videos under 200 MiB

Use Flask with Dropzone.js to upload videos under 128MB

large_use-flask-with-dropzone-js-to-upload-videos-under-128mb-no-client.png

medium_use-flask-with-dropzone-js-to-upload-videos-under-128mb-no-client.png

small_use-flask-with-dropzone-js-to-upload-videos-under-128mb-no-client.png

thumbnail_use-flask-with-dropzone-js-to-upload-videos-under-128mb-no-client.png

use-flask-with-dropzone-js-to-upload-videos-under-128mb-no-client.png

Use Flask with Dropzone.js to upload videos under 200 MiB (no client)

Uploading video with api.video's Python Client is easy. You can use the method described here to upload big files over 199 MiB or small files. The client will handle chunking the upload for you. 

NOTE: If you're wondering how this differs from the previous Python tutorials:
* [Upload a Video From Your Computer wiht 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/) 

It differs in that it uses our new [Python Client](https://github.com/apivideo/python-api-client).  

If you'd prefer to watch a video about how to upload video from your computer with the new client, you can check that out here: 

<iframe width="560" height="315" src="https://www.youtube.com/embed/4kWwSvrLtCA" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

The API reference documentation for the endpoints used in this tutorial can be reviewed here: 
* [Create a video](https://docs.api.video/reference/api/Videos#create-a-video-object)
* [Upload a video](https://docs.api.video/reference/api/Videos#upload-a-video)

If you prefer written walkthroughs, read on. I'll cover all the same information here. 

## Install the Python Client 
Installing api.video's Python Client is easy: 

```pip install api.video``` 

I recommend using a virtual environment to install, but it's not required. 

## How to Upload a Video from Your Computer 

What you'll be doing, is sending a request to the api.video server to create a video container. You'll get back a video ID you can use to reference your container. Then you'll prepare your video for upload and send a request to upload the video to the video ID you specify. 

Be aware that you can only upload to a video ID once. You can change settings and details about your video later using the update feature of the api.video API. 

You can get the code sample I'm using here: 
[https://github.com/apivideo/python-api-client/blob/master/examples/upload_video.py](https://github.com/apivideo/python-api-client/blob/master/examples/upload_video.py)

When you are creating your video, you may want to include more settings and metadata than I show in the walkthrough. A complete list of choices are shown here: 
[https://github.com/apivideo/python-api-client/blob/master/docs/VideoCreationPayload.md](https://github.com/apivideo/python-api-client/blob/master/docs/VideoCreationPayload.md)

And here's the code sample (tweaked a bit from the repository sample):

## Code Sample Walkthrough
To use the api.video Python Client, you'll want to start by making your imports. You need three. The first one you'll need to import is **apivideo**. This will let you use authentication and the client. Next, you want to import **VideosApi** from apivideo.apis. It is best practice to import just the part of the client you'll use, because it improves performance. VideosApi will let us use the create and upload features. Finally, you'll import **ApiAuthException** for error handling. 

Next, we'll add our API key and set up the Client. In the Python Client, authentication is handled for us, including refreshing the access token when needed. All we need to do is add our API key to the Client, then connect. After connecting, we can pass the Client to VideosApi, and we're ready to upload our video! 

To upload our video, we first want to create our video container. The video container contains details about the video as well as any configuration settings like whether you want your video to be public or downloadable. As part of our request to create our container, we'll want to send all those details and settings in a payload. For this walkthrough, I'm adding a title because that's the only required setting for container creation. Then I'm including a description of what my video is, setting my video to be private (make public = false) and then I'm adding tags to search with - bunny and tree. 

If you want to change the settings further, refer to the choices here: [https://github.com/apivideo/python-api-client/blob/master/docs/VideoCreationPayload.md](https://github.com/apivideo/python-api-client/blob/master/docs/VideoCreationPayload.md)

Let's create a request to make our video container and retrieve the video ID:

We grabbed the video ID, so next we prepare our file. To upload files with api.video, we open them in read-only binary format. Then we'll add our file and video ID to our upload request and check out the response! 

If everything works out, you'll get a response showing you all the metadata and configuration details for your upload. You can navigate to [your api.video dashboard](https://dashboard.api.video/overview) to see the video you uploaded there. If you're uploading a big video, give it a few minutes to be ready. 

If you get stuck or have questions, you can write us on our [community forum](https://community.api.video).

Upload a video with the api.video Python Client

doug.jpg

twitter-brands.svg

Doug Twitter

Doug Sillars

We’ve just released [record.a.video](https://record.a.video), a web application that lets you record and share videos. If that were not enough, you can also livestream. The page works in Chrome, Edge, Firefox, Safari (14 and up), and on Android devices. This means that the application will work for about 75% of people using the web today. That’s not great, but since there are several new(ish) APIs in the application, it also isn’t that bad!

This is part 2 of the continuing series of interesting webAPIs that I used to build the application.

* In [post 1](https://api.video/blog/tutorials/grabbing-camera-streams-with-mediadevices-getusermedia/), I talked about the getUserMedia API to record the user's camera and microphone.

* In [post 2](https://api.video/blog/tutorials/building-record-a-video-the-screencapture-api/), I discussed recording the screen, using the Screen Capture API.

Using the video streams created in posts 1& 2, I draw the combined video on a canvas.

* In [post 3](https://api.video/blog/tutorials/building-record-a-video-the-mediarecorder-api/), I'll discuss the MediaRecorder API, where I create a video stream from the canvas to create the output video.  This output stream feeds into the video upload (for video on demand playback) or the live stream (for immediate and live playback).

* In [post 4](https://api.video/blog/tutorials/building-record-a-video-using-the-webspeech-api-for-live-captioning/), I'll discuss the Web Speech API. This API converts audio into text in near real time, allowing to create 'instant' captions for any video being created in the app. This is an experimental API that only works in Chrome, but was so neat, I included it in record.a.video anyway. 

You can also review the api.video API reference documentation for live streaming: [Live streams](https://docs.api.video/reference/api/Live-Streams#list-all-live-streams)

sharing my screen, with camera output as an overlay

medium_screenshot-with-video-overlay.jpg

small_screenshot-with-video-overlay.jpg

thumbnail_screenshot-with-video-overlay.jpg

screenshot-with-video-overlay.jpg

## Sharing the screen

The ```navigator.mediaDevices.getDisplayMedia``` is the command I'll need to use to grab the screen.

When we look at the support for getDisplayMedia on caniuse:


large_screenshot-caniuse.png

medium_screenshot-caniuse.png

small_screenshot-caniuse.png

thumbnail_screenshot-caniuse.png

screenshot-caniuse.png

It is clear that there is good support on desktop browsers, but no support on mobile. This makes sense, as the only thing you'd be able to share would be the webpage that is open.  But, since I'd like the app to work on mobile, we'll block screen sharing,and only allow the camera to be shared:

```
    if("getDisplayMedia" in navigator.mediaDevices){
        console.log("screen capture supported");
    }else{
        console.log("screen capture NOT supported");
        cameraOnly = true;
    }
```

I want the screen display to appear in the videoElem video tag:

```
videoElem = document.getElementById("display");

        //only thing is muting the audio
        //this prevents awful feedback..
        displayMediaOptions = {
        video: {
        },
        audio: false
        };


  if(!cameraOnly){
            //share the screen - it has not been shared yet!
            videoElem.srcObject = await navigator.mediaDevices.getDisplayMedia(displayMediaOptions);    
            screenShared = true;
            }else{
                //screen cannot be shared, so grab the front facing camera.
            videoElem.srcObject = await navigator.mediaDevices.getUserMedia(rearCameraMediaOptions); 
            screenShared = true;

```

When you call getDisplayMedia, you can add constraints to the capture. In my case, I am grabbing the audio from a different stream, so I don't need the audio from the screen. In the comment, I mention awful feedback - even if you have no microphone, you can get awful feedback. For example, if the user is listening to music, the getDisplayMedia captures that, and plays it back (at a very high volume) leading to deafness in your users. 

We ran into this issue with our livestream app on [api.video dashboard](https://dashboard.api.video/register), where I was temporarily deafened when I tested the app (and was listening to music).


When the page asks to share your screen, a popup will appear asking you which window or screen you'd like to share - you can share your entire screen, or just one application.

## Putting the 2 video feeds together 

Now that I have a video feed from the camera and from the screen, the listener for video playing on the videoElem fires:

```
    videoElem.addEventListener('play', function(){
       console.log('video playing');
            //draw the 2 streams to the canvas
            drawCanvas(videoElem, cameraElem,ctx);
    },false);

```

drawCanvas is a function that combines the videos and draws them to the canvas. (It also draws the captions, which I will cover in a future post.


First, we initialize the location of the camera and the screen. I'm only showing the default (camera at bottom right), but these care changed based on the layout requested by the user:

```
         //set xy coordinates for the screen and cameras
         //bottom right camera
            //big screen
            screenX0 = 0;
            screenY0 = 0;
            screenX1 = ctx.canvas.width;
            screenY1= ctx.canvas.height;

            cameraX0 = .625*ctx.canvas.width;
            cameraY0 = .625*ctx.canvas.height;
            cameraX1 = ctx.canvas.width/3;
            cameraY1= ctx.canvas.height/3;    
    
```

When drawCanvas is called, it can grab the screen and the camera, and then place them appropriately on the canvas. 

```

    //once the cameras and views are picked this will draw them on the canvas
    //the timeout is for 20ms, so ~50 FPS updates on the canvas
    function drawCanvas(screenIn, cameraIn,canvas){
        var textLength = 60;
        canvas.drawImage(screenIn, screenX0,screenY0, screenX1, screenY1);
        canvas.drawImage(cameraIn, cameraX0, cameraY0, cameraX1, cameraY1);
       //write transcript on the screen
        if(interim_transcript.length <textLength){
            ctx.fillText(interim_transcript, captionX, captionY);
        }
        else{
            ctx.fillText("no captions", captionX, captionY);
    
        }
        setTimeout(drawCanvas, 20,screenIn, cameraIn,canvas);

    }
```


## Try this in action

At [record.a.video](https://record.a.video), you can see this in action - well, you can test it if you are on a desktop browser (see above).


## Conclusion

The getDisplayMedia is an easy to use API that allows you to share your screen on the browser.  Once you have access to the screen's video feed, you can stream it, or save it using the MediaRecorder API (which will be the next post in this series).
To start building your own, you can [create an account](https://dashboard.api.video/register) on api.video or ask questions on [our community forum](https://community.api.video/). 

Building record.a.video part 2: The screenCapture API

large_building-record-a-video-part-2.png

medium_building-record-a-video-part-2.png

small_building-record-a-video-part-2.png

thumbnail_building-record-a-video-part-2.png

building-record-a-video-part-2.png

live - create

NodeJS


With the explosive growth of remote working in the past year, we’ve all worked to find different ways of communicating. Slack and Zoom have become major tools for communication as we are all no longer in the same building or office.  

Apps like Clubhouse have become ‘places’ to go and hang out and chat with others.

One app that has featured explosive growth over the past year is Loom. Loom is an app that lets you record short video messages - sharing your screen or just using your camera. When you are done, the video is saved on a server, and you are given a link.  This link is easy to share: on social media, on Slack etc. It is a great way to communicate an idea, or to express your point - it’s everything that is great about video, packaged in an easy to use interface.  

It is no wonder that Loom is so successful.  My only issue is that I either have to use an installed app on my Mac (265 MB installed), or a Chrome extension (I did not go this approach, as Chrome eats too much memory already).

## Can I build a Loom-like app - in the browser?

I lead developer relations at api.video.  We offer a full service API for video transcoding, hosting and delivering video streams.  It is incredibly fast, and can be used to share videos in the same way Loom does.  So this raised 2 questions:

1. If I delegate the ‘hard’ bits of the video handling to api.video, can I build a recording app in the browser? 

2. Can I get this app running in all four major modern browsers?  Desktop & mobile?

TL;DR:  

Question 1: Yes - you can build a website to record and share video (screen sharing and camera video). It will even stream live video!

Question 2: Almost all browsers.  On the desktop, the full featured app works great in Chrome, Edge Firefox, and Safari 14.0.3 (there are some support issues that will fail below Safari 14).  

For Mobile: it works on Android (without screen sharing). Unfortunately, the APIs used are not yet in mobile Webkit, so no iOS support at this time.

Try it out! The application is live at [record.a.video](https://record.a.video). You can also check out our [live stream API reference documentation](https://docs.api.video/reference/api/Live-Streams#list-all-live-streams).

## How does it work?


large_screenshot-2021-03-26-at-11-13-30.png

medium_screenshot-2021-03-26-at-11-13-30.png

small_screenshot-2021-03-26-at-11-13-30.png

thumbnail_screenshot-2021-03-26-at-11-13-30.png

screenshot-2021-03-26-at-11-13-30.png

When you open [record.a.video](https://record.a.video), you'll get a menu as above. (You may not get the available cameras and microphones - press "start capture" and allow camera/microphone permissions, then reload the page).

* The top bar allows you to switch between Live streaming and recording a video.
* Choose your camera and mic (if you have more than one).
* Select the screen layout - do you want to show just the camera or screen, or do you want to overlay the camera on the screen?
* Live captions:  If you are using Chrome, we can add live captions to the video being created.  Pick top or bottom for the captions.
* "Show recording" if you leave this checked, you'll see the video being recorded in the browser.  Our CEO dislikes the "vortex effect" you see when sharing the screen, so we added this button for him to disable the view. (👋 Hi Cedric!)

Now that you've chosen all your options, you're ready to start capture!

### Recording

Once you've started recording, you'll see 3 new views appear:

* The screen being shared
* The camera
* The recording (showing screen, camera or both). (Unless you hid the recording).


small_screenshot-2021-03-26-at-11-22-05.png

thumbnail_screenshot-2021-03-26-at-11-22-05.png

screenshot-2021-03-26-at-11-22-05.png



## Record and stream right from your browser!

So it works!  Recording your screen and camera in the browser with live streaming or recording and uploading for asynchronous viewing.  

What completely blows my mind about this application is that leveraging web APIs, this site weighs in at just under 300KB.  There is a NodeJS backend to handle the streaming (we have to convert the format to RTMP for ingestion into api.video), but if you remove the live streaming component, this app runs with just JavaScript (you can even run it locally on your computer!)

## See it in action

##  Curious about the details

I'm really glad you asked!  We've written a series of posts describing the APIs used to collect video streams, how they were cpmbined, and how they are streamed:

* In [post 1](https://api.video/blog/tutorials/grabbing-camera-streams-with-mediadevices-getusermedia/), I talked about the getUserMedia API to record the user's camera and microphone.

* In [post 2](https://api.video/blog/tutorials/building-record-a-video-the-screencapture-api/), I discussed recording the screen, using the Screen Capture API. Using the video streams created in posts 1 & 2, I draw the combined video on a canvas.

* In [post 3](https://api.video/blog/tutorials/building-record-a-video-the-mediarecorder-api/), I'll discuss the MediaRecorder API, where I create a video stream from the canvas to create the output video.  This output stream feeds into the video upload (for video on demand playback) or the live stream (for immediate and live playback).

* In [post 4](https://api.video/blog/tutorials/building-record-a-video-using-the-webspeech-api-for-live-captioning/), I'll discuss the Web Speech API. This API converts audio into text in near real time, allowing to create 'instant' captions for any video being created in the app. This is an experimental API that only works in Chrome, but was so neat, I included it in record.a.video anyway. 



## Conclusion

Record.a.video lets you easily record and share video - live or asynchronously! 


Go give it a shot [record.a.video](https://record.a.video), and if you want to build your own - the code is on [Github](https://github.com/apivideo/recordavideo). In the coming days, we’ll add some technical posts describing how we built it.

If you have any comments or suggestions, please leave us a note in our [community forum](https://community.api.video). 


Building "Loom" in the browser: record a video with api.video

large_loom-app.png

medium_loom-app.png

small_loom-app.png

thumbnail_loom-app.png

loom-app.png

large_api-video-blog-no-code.png

medium_api-video-blog-no-code.png

small_api-video-blog-no-code.png

thumbnail_api-video-blog-no-code.png

api-video-blog-no-code.png

No-code

no code

This tutorial shows you how to configure Zapier so that whenever you add a new video to api.video, an email is sent notifying people. This is a no-code solution, you just follow the configuration steps to combine the applications using Zapier. If you've created an api.video zap before, you can skip ahead to the section 'Configure Gmail as Your Action Event.' 

## Prerequisites 
You'll need these things to successfully complete this project:

* api.video account - if you don't have an accunt, you can create one [here](https://dashboard.api.video/register).
* Gmail account
* Zapier account
* This tutorial assumes familiarity with Zapier

You can check out the webhook used for this project in the api.video API reference documentation: [Webhooks](https://docs.api.video/reference/api/Webhooks#list-all-webhooks)

api.video, gmail, zapier, email notifications when video is uploaded

large_chooseintegration.png

medium_chooseintegration.png

small_chooseintegration.png

thumbnail_chooseintegration.png

chooseintegration.png

## Configure api.video as the Trigger Event
To get started, you need to configure api.video as the trigger event for sending an email. In Zapier, the trigger event is something that occurs with the chosen product that results in you wanting to take action. In this case, whenever a new video is created in api.video, we want something to happen. 

1. Make sure you've added a sample video to your account for testing. You should add it right before trying this tutorial. If you haven't, add something to test with now. We're using production here, so you'll want to add a video to your production environment before starting.
2. You're prompted to choose your account. If you're already connected because you tried out a different zap with api.video, you'll see your account as a choice. Otherwise, you'll see **Sign in to api.video**. Click this option.
3. You're asked if Zapier can have access to your api.video account. Enter your API key to get started. If you choose your production API key, you'll receive an alert whenever you add a new video to production on your account. If you choose your sandbox API key, you'll receive an alert whenever you add a new video to your sandbox. NOTE: You can get the key you want from [api.video dashboard](https://dashboard.api.video/register).
4. After you enter your API key, click **Yes, Continue**.
5. You'll see your account listed with the start of your authorization token if all goes well. Click **Continue**.
6. Now it's time to set up your trigger. From the **Trigger Event** drop-down, select **New Video**. 
7. Click **Continue**.
8. Leave the Title and Tags fields empty. 
9. Click **Continue**.
10. You can now test your trigger. Click **Test trigger**. If all goes well, you get a response saying 'We found a video!' If not, the recommendation is to add a video to your account. Make sure you've added the video to right part of your account! You can add a video and try again. You can also clear your browser cache and try again. If it continues not working, contact us in our [community forum](https://community.api.video/)).

## Configure Gmail as Your Action Event
Gmail is going to provide our action event. In Zapier, an action event is a response to a trigger event. When api.video sends notification that a new video is created, Gmail responds with an action event - which is sending an email to a list of selected recipients stating that the video is now available.

large_gmailsetup.png

medium_gmailsetup.png

small_gmailsetup.png

thumbnail_gmailsetup.png

gmailsetup.png

Thanks for trying out the walkthrough with us today! 
Don't hesitate to ask questions on our [community forum](https://community.api.video/) or [start building](https://dashboard.api.video/register) now and integrate your videos without any code!

Get notified by Gmail when a new video is available (Zapier)

api.video, gmail, zapier, connect api.video with gmail

large_apigmail.png

medium_apigmail.png

small_apigmail.png

thumbnail_apigmail.png

apigmail.png

Authenticate

If you have some videos on your computer that you need to upload to api.video, you're in luck - today's tutorial will show you how to do just that using Python. Your video must be under 200 MiB to use this method. The code sample is available on github in the [api.video python-examples repository](https://github.com/apivideo/python-examples). Let's get started! 

medium_pexels-designecologist-1779487.jpg

small_pexels-designecologist-1779487.jpg

thumbnail_pexels-designecologist-1779487.jpg

pexels-designecologist-1779487.jpg

## Prerequisites
* An [api.video account](https://dashboard.api.video/register) 
* api.video API key 
* You'll need access to Python and you'll need to install the requests library if you don't already have it added

## What You'll Be Doing
This is a quick summary of what you're going to do to upload your video. 

1. You'll authenticate with api.video using your API key and retrieve a token that lasts one hour that you can use to access all of api.video's other endpoints.
2. You'll create a video container for your video and retrieve the videoId. 
3. You'll use the videoId to upload your video from your computer to api.video. You can only upload a video to the videoId once. If you decide you wanted to upload a different video, you'll have to go through the create container and upload video steps again. You don't need to repeat the part where you get a new token unless your token expires (so if you take an hour long break and come back, you'll need to redo that step then). 

## Code Sample 

```
## How to upload a video under 200 MiB using the api.video API

import requests

## Set up variables for endpoints
auth_url = "https://ws.api.video/auth/api-key"
create_url = "https://ws.api.video/videos"

headers = {
    "Accept": "application/json",
    "Content-Type": "application/json"
}

payload = {
    "apiKey": "your API key here"
}

response = requests.request("POST", auth_url, json=payload, headers=headers)
response = response.json()
token = response.get("access_token")

auth_string = "Bearer " + token


## Set up headers for authentication
headers_bearer = {
    "Accept": "application/json",
    "Content-Type": "application/json",
    "Authorization": auth_string
}

## Create a video container
payload2 = {
    "title": "Demo Vid from my Computer",
    "description": "Video upload of Big Buck Bunny to demo how to do an upload from a folder on your computer."
}

response = requests.request("POST", create_url, json=payload2, headers=headers_bearer)
response = response.json()
videoId = response["videoId"]

## Create endpoint to upload video to
upload_url = upload_url + "/" + videoId + "/source"

## Create upload video headers 
headers_upload = {
    "Accept": "application/vnd.api.video+json",
    "Authorization": auth_string
}

file = {"file": open("local/path/to/myvideo.flv", "rb")}
response = requests.request("POST", upload_url, files=file, headers=headers_upload)
json_response = response.json()
print(json_response)
```

## Code Walkthrough

You'll start by adding the requests library, so you can easily make HTTP requests.

<center><iframe src="https://giphy.com/embed/YGlRW1Am9q7e0" width="320" height="480" frameBorder="0" class="giphy-embed" allowFullScreen></iframe><p><a href="https://giphy.com/gifs/books-libraries-shelves-YGlRW1Am9q7e0">How people added libraries before computers did it for you.</a></p><br></center>

```
import requests
```

Next, let's assign a variable to each endpoint we'll use, they'll be a little easier to work with. We're going to assign two of them here, and we'll use the second one later to build the third one: 
* [Authentication](https://docs.api.video/reference/basic-authentication) endpoint - This is where we send our API key to exchange it for a token. It's **auth_url** in the code sample.
* [Videos](https://docs.api.video/reference/api/Videos#create-a-video-object) endpoint - Specifically we'll use the feature on this endpoint that's for creating a video. It's **create_url** in the code sample.
* [Video Upload](https://docs.api.video/reference/api/Videos#upload-a-video) endpoint - It looks a lot like the other endpoint. It's create_url + "/videoId" + "/source". We'll construct this after we get a videoId to work with. 

```
auth_url = "https://ws.api.video/auth/api-key"
create_url = "https://ws.api.video/videos"
```

### Authentication - Get Your Token
We'll prepare our headers and payload for authentication, then send a POST request to api.video. With the api.video API you start authentication by sending a request using your API key to retrieve a token. You can use your sandbox or your production key, the backend will figure out which you are using and handle it accordingly. If you choose to use your sandbox credentials for this walkthrough, your video will be uploaded with the watermark 'FOR DEVELOPMENT PURPOSES ONLY.': 

```
headers = {
    "Accept": "application/json",
    "Content-Type": "application/json"
}

payload = {
    "apiKey": "your API key here"
}
response = requests.request("POST", auth_url, json=payload, headers=headers)
```

Now we need to get the token from our response, so we can authenticate with the rest of api.video's endpoints when we want to do something. To get the token, we'll convert the response to JSON, then retrieve the token out of the JSON dictionary. 

```
response = response.json()
token = response.get("access_token")
```

### Set up a Video Container 
Using the token, we'll get the headers and payload ready for our next request, which will be to ask api.video to create a video container for us.

```
## Set up headers for authentication
headers_bearer = {
    "Accept": "application/json",
    "Content-Type": "application/json",
    "Authorization": auth_string
}

## Create a video container
payload2 = {
    "title": "Demo Vid from my Computer",
    "description": "Video upload of Big Buck Bunny to demo how to do an upload from a folder on your computer."
}
```

api.video endpoints use bearer authentication. Add the authorization header for bearer authentication to your list of headers, and then for the payload we keep it simple, just a title and description. But what about the path to your file? Don't worry we're just creating a container right now. When you upload from your computer, you create a container first, and do your upload second. 

### Send Your Request and Grab the VideoId
For the next part of our walkthrough, we'll send our request, convert the response to JSON, and retrieve the videoId. We need the videoId so we can tell api.video what container we want to upload our video to. 

```
response = requests.request("POST", create_url, json=payload2, headers=headers_bearer)
response = response.json()
videoId = response["videoId"]
```

### Create the Endpoint for Uploading Your Video
Set up the endpoint you'll upload your video to, which is composed of `https://ws.api.video/videos` + `/` + `videoId` + `/source`. You also need to add the headers. For Python, you don't want to use the "Content-Type": `multipart/form-data` header you see listed if you try the API explorer. Because you are doing an upload with only one part, it won't work. Omit this in your headers. Set things up like this: 

```
headers_upload = {
    "Accept": "application/vnd.api.video+json",
    "Authorization": auth_string
}
```

For the payload, you're sending a video file, so you'll have to open the file, attach it to a dictionary, and for readability, we assign the dictionary to a variable. We use "rb" because we want to open the file as read-only binary format. Check it out: 

```
file = {"file": open("sample-flv-file.flv", "rb")}
```

We can assign our variable in our request to upload our video, and then process and print the request response:

```
response = requests.request("POST", upload_url, files=file, headers=headers_upload)
json_response = response.json()
print(json_response)
```

The response provides a lot of detail about your video:

```
{
	'videoId': 'video ID here', 
	'title': 'Demo Vid from my Computer', 
	'description': 'Video Upload From My Computer', 
	'public': True, 
	'panoramic': False, 
	'mp4Support': True, 
	'publishedAt': '2021-02-05T04:25:02+00:00', 
	'createdAt': '2021-02-05T04:25:02+00:00', 
	'updatedAt': '2021-02-05T04:25:02+00:00', 
	'tags': [], 
	'metadata': [], 
	'source': {
		'type': 'upload', 
		'uri': '/videos/video_ID_here/source'
	 }, 
	'assets': {
		'iframe': '<iframe src="https://embed.api.video/vod/video_ID_here" width="100%" height="100%" frameborder="0" scrolling="no" allowfullscreen="true"></iframe>', 
		'player': 'https://embed.api.video/vod/video_ID_here', 
		'hls': 'https://cdn.api.video/vod/video_ID_here/hls/manifest.m3u8',
		'thumbnail': 'https://cdn.api.video/vod/video_ID_here/thumbnail.jpg'
 }
}
```

* **videoId** - the unique identifier for your new video. Before it was just referencing a container, now it's referencing a container that holds your video!
* **title** - the title you provided for your video when you made the container
* **description** - a description of what the video contains
* **public** - by default, your video is public 
* **panoramic** - by default, your video isn't listed as being a 360° (panoramic is the term api.video uses for 360° or immersive video)
* **mp4Support** - whether you have an mp4 version of your video available or not. By default you do. If you turn this off, your video will not be downloadable from a player and there won't be a link to an mp4 version of your file.
* **publishedAt** - the time your video was published, in ISO-8601 format.
* **createdAt** - the time your video was created, in ISO-8601 format.
* **updatedAt** - the time your video was updated in ISO-8601 format.
* **tags** - you can add individual key words to categorize your videos and make them easier to search if you have a lot of them.
* **metadata** - you can add a dictionary of key value pairs that categorize your videos for searches.
* **source** - this lists the video type, which is upload, and the link you add to the api endpoint to get to your video. 
* **assets** - this is a list of links you can use to set up different services with your video. You can embed an iframe using the iframe code, use the player link to add the file to a player, get the manifest file if you need the source for live streaming, and api.video selects a thumbnail for you automatically. 

You can update all of this information should you choose to. That's it for uploading a video from your computer using Python! 

If you have any questions or suggestions, please share them on our [community forum](https://community.api.video/) and if you still haven't created your api.video account, you can do that [here](https://dashboard.api.video/register). Happy building! 

Upload a video with api.video’s API (Python)

Photo by <a href="https://www.pexels.com/photo/silver-imac-displaying-collage-photos-1779487/">Designecologist</a> from Pexels

Upload a video from your computer with the api.video API (Python)

If Python is your programming language of choice, and you want to quickly upload a video to api.video using a public URL, you've come to the right place. The code sample is available on github in the [api.video python-examples repository](https://github.com/apivideo/python-examples). Let's get started! 

<center><iframe src="https://giphy.com/embed/l0IyjiXOXTX6Yemsg" width="480" height="270" frameBorder="0" class="giphy-embed" allowFullScreen></iframe><p><a href="https://giphy.com/gifs/l0IyjiXOXTX6Yemsg"></a></p><br></center>

## Prerequisites

If you would prefer to watch a video that explains the same information as this tutorial, you can watch this:

* [An api.video account](https://dashboard.api.video/register)
* api.video API key 
* URL for a public video you want to try uploading (we'll be using this link here: [https://www.learningcontainer.com/mp4-sample-video-files-download/#Sample_AVI_File](https://www.learningcontainer.com/mp4-sample-video-files-download/#Sample_AVI_File))
* You'll need access to Python and you'll need to install the requests library if you don't already have it added

You can also review the API reference documentation for uploading videos here: [Upload a video](https://docs.api.video/reference/api/Videos#upload-a-video)

## Code Sample

```
import requests

## Set up variables for endpoints
auth_url = "https://ws.api.video/auth/api-key"
create_url = "https://ws.api.video/videos"

## Set up header for first authentication request
headers = {
    "Accept": "application/json",
    "Content-Type": "application/json"
}

payload = {
    "apiKey": "sandbox or production key here"
}

response = requests.request("POST", auth_url, json=payload, headers=headers)
response = response.json()
token = response.get("access_token")

auth_string = "Bearer " + token


## Set up headers for bearer authentication
headers2 = {
    "Accept": "application/json",
    "Content-Type": "application/json",
    "Authorization": auth_string
}

## Upload the video
payload = {
    "title": "My Demo Video",
    "source": "https://www.learningcontainer.com/mp4-sample-video-files-download/#Sample_AVI_File"
}
response = requests.request("POST", create_url, json=payload, headers=headers2)

## Check out the response
print(response.json())

```

## Code Walkthrough
This section walks through the code to give you an idea of what you'll be doing.

### Set up Authentication with Your API Key
You'll start by adding the requests library, so you can easily make HTTP requests.

```
import requests
```

Next, let's assign a variable to each endpoint we'll use, they'll be a little easier to work with. We're going to use two endpoints today: 
* [Authentication](https://docs.api.video/reference/basic-authentication) endpoint - This is where we send our API key to exchange it for a token. It's **auth_url** in the code sample.
* [Videos](https://docs.api.video/reference/api/Videos#create-a-video-object) endpoint - Specifically we'll use the feature on this endpoint that's for creating a video. It's **create_url** in the code sample.

```
auth_url = "https://ws.api.video/auth/api-key"
create_url = "https://ws.api.video/videos"
```

Create the payload for your headers and the payload for your payload. These are for your authentication request. The api.video API requires that you authenticate with your API key to obtain a token. Your token is good for one hour and can be used to authenticate with all other endpoints. 

NOTE: You can use your sandbox or your production key. The backend for api.video will figure out which you selected and route your request appropriately. If you didn't pay for a full account, all of your videos will be watermarked 'FOR DEVELOPMENT PURPOSES ONLY'.

```
headers = {
    "Accept": "application/json",
    "Content-Type": "application/json"
}

payload = {
    "apiKey": "your API key here"
}

```

Send a request with your header and payload information, convert the response to json so you can retrieve information from it, and then grab **access_token**.

```
response = requests.request("POST", auth_url, json=payload, headers=headers)
response = response.json()
token = response.get("access_token")
```

Now you have your token, you need to set new headers that are for Bearer authentication. Create a string with your token for the new Authorization header, and a new header payload. 

```
auth_string = "Bearer " + token

headers2 = {
    "Accept": "application/json",
    "Content-Type": "application/json",
    "Authorization": auth_string
}
```

### Send Your Video Upload Request

And the part you've been waiting for, the code for video upload! By default, your video is public and includes mp4 support, which is a link to a 1080p mp4 of your file. If you want to change these settings so your video is private or mp4 support is turned off (this will make it so no one can download your video from a player) you can [check our docs](https://docs.api.video/reference/api/Videos#create-a-video-object) for details about all the parameters your payload can include. For now, we'll keep the payload simple: 

```
payload = {
    "title": "My Demo Video",
    "source": "https://www.learningcontainer.com/mp4-sample-video-files-download/#Sample_AVI_File"
}
response = requests.request("POST", create_url, json=payload, headers=headers2)
print(response.json())
```

You can use this payload to see the sample run. For your own upload, you may want to use a different title and a different source link.

### Review Video Details in the Response

When you print the response here, you get back a lot of interesting information about your video: 

```
{'videoId': 'vi8PXlHuWN25wPOVtGfBSQkJ', 
'title': 'My Demo Video', 
'description': '', 
'public': True, 
'panoramic': False, 
'mp4Support': True, 
'publishedAt': '2021-02-04T01:50:23+00:00', 
'createdAt': '2021-02-04T01:50:23+00:00', 
'updatedAt': '2021-02-04T01:50:23+00:00', 
'tags': [], 
'metadata': [], 
'source': {
	'type': 'upload', 
	'uri': '/videos/vi8PXlHuWN25wPOVtGfBSQkJ/source'
	}, 
'assets': {
	'iframe': '<iframe src="https://embed.api.video/vod/vi7EVlHuWN05wPOVtGfBSQkJ" width="100%" height="100%" frameborder="0" scrolling="no" allowfullscreen="true"></iframe>', 
	'player': 'https://embed.api.video/vod/vi8PXlHuWN25wPOVtGfBSQkJ', 
	'hls':'https://cdn.api.video/vod/vi8PXlHuWN25wPOVtGfBSQkJ/hls/manifest.m3u8',   'thumbnail': 'https://cdn.api.video/vod/vi8PXlHuWN25wPOVtGfBSQkJ/thumbnail.jpg'
  }
}
```

* **videoId** - a unique ID that identifies your uploaded video
* **title** - the title of your video
* **description** - if you put a description of your video it appears here
* **public** - whether your video is public or not
* **panoramic** - whether your video is 360° or not
* **mp4Support** - whether your video has an mp4 version of it available or not (turn this off if you don't want people to be able to download your video from a player)
* **publishedAt** - when you first published your uploaded video
* **createdAt** - when your uploaded video was created
* **updatedAt** - when you last updated your video
* **tags** - if you added individual tags to categorize your video with, they appear here
* **metadata** - if you added key value pairs to categorize your videos with, they appear here
* **source** - details about your video source 
* **assets** - different ways you can upload or work with your new video, there's a link you can use with a player, the source file for the hls versio of your video, and a thumbnail that's selected for you (you can change it if you like, but that's a different tutorial)

And that's how you do a simple video upload to api.video! Let us know if you have any questions in [our Community](https://community.api.video/)! Happy building!

Upload a video to api.video using a public URL

large_upload-a-video-to-api-video-using-a-public-url.png

medium_upload-a-video-to-api-video-using-a-public-url.png

small_upload-a-video-to-api-video-using-a-public-url.png

thumbnail_upload-a-video-to-api-video-using-a-public-url.png

upload-a-video-to-api-video-using-a-public-url.png

There are lots of reasons you might need to immediately know that a video's been added to a collection. Maybe you're on a tight deadline, and you need to know when a set of videos becomes available so you can start your project. Maybe you're following a TV show, and want to know when the next episode is available. Or maybe you're interested in when the latest news event gets posted. Any of these, or many other reasons could lead to you wanting to receive an SMS alert when a video gets posted. 

Using Zapier, we'll walk through a no code method for receiving an SMS alert when a new video is uploaded to your api.video account. Let's get started! 

## Prerequisites 
You'll need a few things to successfully complete this project:

* api.video [account](https://dashboard.api.video/register)
* Upgraded Twilio account
* Paid for phone number that you can send SMS from
* Verified number (your cellphone) you can receive text messages with

Twilio will walk you through everything and we provide links to the content you'll need to set yourself up with Twilio.

This project uses webhooks, so you can check out the API reference documentation for this here: [Webhooks](https://docs.api.video/reference/api/Webhooks#list-all-webhooks)


## Configure api.video as the Trigger Event
Set up api.video so it will provide a trigger event for Twilio. 

1. Make sure you've added a sample video for testing. We're using production here, so you'll want to add a video to your production environment before starting.
2. Log in to Zapier.
3. Go to [https://zapier.com/apps/apivideo/integrations/twilio](https://zapier.com/apps/apivideo/integrations/twilio). 
4. Next to Send Twilio SMS messages for new videos in api.video click **Try It**. The configuration process starts.

medium_start.jpg

small_start.jpg

thumbnail_start.jpg

start.jpg

5.  You're prompted to choose your account. If you're already connected because you tried out a different zap with api.video, you'll see your account as a choice. Otherwise, you'll see **Sign in to api.video**. Click this option.
6.  You're asked if Zapier can have access to your api.video account. Enter your API key to get started. If you choose your production API key, you'll receive an alert whenever you add a new video to production on your account. If you choose your sandbox API key, you'll receive an alert whenever you add a new video to your sandbox. NOTE: You can get the key you want from [my.api.video](https://dashboard.api.video/register).
7.  After you enter your API key, click **Yes, Continue**.
8.  You'll see your account listed with the start of your authorization token if all goes well. Click **Continue**.
9.  Now it's time to set up your trigger. From the **Trigger Event** drop-down, select **New Video**. 
10.  Click **Continue**.

medium_apitrigger.jpg

small_apitrigger.jpg

thumbnail_apitrigger.jpg

apitrigger.jpg

11. Leave the Title and Tags fields empty.  
12. Click **Continue**.
13. You can now test your trigger. Click **Test trigger**. If all goes well, you get a response saying 'We found a video!' If not, the recommendation is to add a video to your account. Make sure you've added the video to right part of your account! You can add a video and try again. You can also clear your browser cache and try again. If it continues not working, contact us on Intercom (use the chat balloon on our [docs](https://docs.api.video/reference) page or our [website](https://api.video/) or our [community forum](https://community.api.video/)). 

## Configure Twilio as Your Action Event
Now it's time to configure everything for Twilio. 

1. Sign up for a Twilio account. 
2. Upgrade your Twilio account.
3. Buy a phone number with Twilio.
4. Leave your Twilio account open on the dashboard, and go back to Zapier. 
5. Click **Action Send SMS in Twilio**.
6. If you've connected Twilio to something previously, you'll see your account as a choice in the drop-down for an event. Otherwise you'll get **Sign in to Twilio**. 
7. Go to the Twilio dashboard you left open, and grab your authentication information. You'll need your **Account SID** and your **Auth Token**. 
8. Add your Account SID and Auth Token to the appropriate fields in Zapier's prompt. Click **Yes, Continue**. 
9. From the Action Event drop-down, choose **Send SMS**. 
10. Click **Continue**. 
11. In the Set up action section, click under the **From Number** drop-down. The phone number you bought should be listed. Click to select it. Optionally, if you'd like to enter an Alphanumeric Sender ID to receive your message from, you can provide it. However, it's not often this ID is used, so you can also skip it.
12. For **To Number** enter the phone number you set up your Twilio account with. Make sure you put your complete phone number, with no special characters or spaces. NOTE: You can use other numbers as well, but you have to add them to your Twilio account. It's easier for the walkthrough to use the number you signed up with.
13. In the **Message** field, check that the message is alright. You can enter whatever text you like, and then you can dynamically add variables to display from the list provided under the Message field. For our walkthrough, go ahead and leave the message that's provided. 
14. Click **Continue**.
15. Now you'll be asked to test your action. Click **Test & Continue**. If all goes well, you receive a text message on your phone about a new video using the sample we selected for the api.video section. 
16. You're all set, the last thing is to try this out for real. Click **Turn on Zap**.

Now that you've tried creating a zap with some help, maybe you'll want to try something out on your own! 

Upload a Video and Receive an SMS Notification (Zapier)

SMS reminders, upload a video, api.video, zapier

medium_tzap3.jpg

small_tzap3.jpg

thumbnail_tzap3.jpg

tzap3.jpg

We're back with more helpful PHP scripts from Hervé Pita! If you have video content on an FTP server, you can use this script to move your files from there to api.video. 

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

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

Today we're going to learn how to use the script for ingesting videos from an FTP server. Let's get started! 

## Prerequisites for Upload Videos from an FTP Server

For this project, you'll need to ensure that you have: 
* PHP 5.4 or greater with the command-line interface (CLI) and JSON extension installed
* The [Composer](https://getcomposer.org/) dependency management tool (or another way to manage your dependency management). See the Composer website for installation options.
* A GitHub account
* An Api.video account
* Your API key for either production or sandbox
* An FTP server account

You can also check out the API reference documentation for uploading a video here: [Upload a video](https://docs.api.video/reference/api/Videos#upload-a-video)

## Installation 

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

## Try the Script

1. Type ```php import_from_ftp.php``` 
2. You're asked what environment you want to use, prod or sandbox. For our walkthrough, choose **prod**. NOTE: Make sure you have the correct API key, they are different for production and sandbox. Production is better because there is no watermark across your videos. In sandbox mode, all transferred videos will say 'FOR DEVELOPMENT PURPOSES ONLY' across them.
3. You're asked to provide your API key, go ahead and paste in your Production API key. If you weren't sure where to get it from, navigate to [your dashboard](https://dashboard.api.video) and grab the key from the Production section on the Overview page.
4. If authentication is successful, you are next asked if you want to associate a playerID with your videos. You can customise and brand players, then associate them with videos if you like. (View a tutorial about [video player customisation here](https://api.video/blog/tutorials/tutorial-video-player-customisation/).) For the sake of simplicity, we'll skip this. Type **n**.
5. Now you're asked to provide the address for your FTP server. Type the complete address, exactly as it appears, or paste it in. 
6. Enter your FTP username.
7. Enter your FTP password.
8. Provide the path to the video folder on your FTP server that you want to use for the transfer.
9. The script will now step through all your files and upload any videos it finds to api.video. You receive a note after each file is successfully written to api.video. 

That's all for this installment of helpful PHP scripts! More to come! 

Helpful PHP Scripts Pt 2 - Upload Videos from an FTP Server

<a href="https://www.pexels.com/photo/black-laptop-computer-turned-on-showing-computer-codes-177598/">Photo by Markus Spiske from Pexels</a>

medium_php.jpg

small_php.jpg

thumbnail_php.jpg

php.jpg

codec

small_cedric.webp

thumbnail_cedric.webp

cedric.webp

Cédric Montet

Product updates

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

&nbsp;

Yes, you heard me right. 

&nbsp;

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

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


## A step towards making video streaming affordable

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

&nbsp;

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

&nbsp;

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

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

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

&nbsp;

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

&nbsp;

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

&nbsp;

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

&nbsp;

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

## How to get started

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

&nbsp;

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

&nbsp;

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

&nbsp;

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


Huge pricing update: Introducing video encoding at no cost

small_Blog_Zero Cost.webp

thumbnail_Blog_Zero Cost.webp

Blog_Zero Cost.webp

api.video

Video trends

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

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

## What is video encoding?

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

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

## Why is video encoding used?

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

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

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

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

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

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

## Differences between video encoding and video transcoding

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

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

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

## Examples of video codecs

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

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

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

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

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

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

## How do different technologies handle video encoding

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

### Video editing software

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

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

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

### Websites

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

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

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

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

### API

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

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

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

## Conclusion

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

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

A Guide to Video Encoding & Video Codecs

large_poster-3.png

medium_poster-3.png

small_poster-3.png

thumbnail_poster-3.png

poster-3.png

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

&nbsp;

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

## What goes on behind encoding a video?

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

&nbsp;

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

&nbsp;

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


## What are the types of transcoding methods?

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

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

## Codecs for encoding and transcoding

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



## What is transmuxing?

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

&nbsp;

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

## In closing

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

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

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

Encoding and transcoding: what's the difference? 

large_EncodingTranscoding.png

medium_EncodingTranscoding.png

small_EncodingTranscoding.png

thumbnail_EncodingTranscoding.png

EncodingTranscoding.png

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

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

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

## Encoding

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

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

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

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

### Data in the study

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

### Parameters that affect encoding

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

#### Dimensions

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

#### Duration

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

## Analysis

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

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

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

### Short videos - under 5 minutes long

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



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

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

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

### Long videos - 45 - 75 minutes long

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


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

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

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

## Conclusion

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

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

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

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

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

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


Video on demand

Live streaming

Analytics

Video infrastructure

Video player

See all features

Online learning

Short-form videos

Marketplace & E-commerce

Video messaging and recording

Quickstart guides

Documentation

Ecosystem catalog

Clients & SDKs

Community

Blog

Demos

Help center

Video upload