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

Tutorials

Python

Sometimes you just want to upload a smaller piece of a video you have, but you don't want to take the time to edit it with FFMPEG or FinalCut Pro. If you just need a shorter clip and you know the start and end timecode, you can use api.video's clip feature. Today we'll walk through how to upload a clip from a video you have on your computer and how to take a clip from an online, publicly available mp4 link or a video you have stored with api.video.

## # Pre-requisites 

For this tutorial, you will need: 

* api.video account - [Sign up here](https://dashboard.api.video/register)
* api.video Python client - [Python client](https://github.com/apivideo/api.video-python-client)
* A video you can upload a clip from

## Installation 

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

## Code sample for uploading a clip from a video on your computer
Our code sample today is this:

### Video clip code walkthrough

What we'll be doing is a normal video upload. If you're new to uploads, with api.video it's a two step process. First you create a video container with all your metadata, and in this case, you'll also include the information needed to clip your video. Then you retrieve the video ID and use that to upload your video into the container. In this case, you will upload just the video clip into the container. When you're done, you'll have a new, shortened clip to display. 

1. First initialize the client and VideoApi and connect.

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

client.connect()

videos_api = VideosApi(client)`

2. Prepare the video payload with metadata that you'll use as the container. 

`video_create_payload = {
    "title": "My sample clip from a new source",
    "description": "test",
    "clip": {
        "start_timecode": "1",
        "end_timecode": "2",
    },
}`

3. Send a request with your payload to create the new video container, and retrieve the video ID. 

` response = videos_api.create(video_create_payload)
print("Video Container", response)

video_id = response["video_id"] `

4. Now it's time to upload your video. Open your video file in binary to get it ready to send, then send a request to upload it.

` file = open("test_vid45.mp4", "rb") 
video_response = videos_api.upload(video_id, file)

print("Uploaded Video", video_response)`

You can check your dashboard to see that you've successfully uploaded a short video clip! 

## Upload a clip from a link or video source

To take a clip from an online .mp4 link or a video source you have with api.video is easier than the process we just walked through. All you need to do is create a video and the clip will be created for you. If you use a link, make sure it's a .mp4 link. You can't, for example, grab a YouTube link and get a clip from that. 

If you're uploading a clip from an online .mp4 source, you specify the complete link, as a string for the **source** parameter. And if you're uploading a clip from a video you have stored with api.video, you can specify the **video ID** for the video you want to grab a clip from. 

In the example, I've put an .mp4 link in for the source. You don't need to do the second step that we did in the earlier walkthrough. Everything is handled with one call to the api.video API. 

## Conclusion 

Video clipping is great in situations where you wanted to grab one or more clips from a longer video, or you just wanted to edit a bit of content off the front and end of your video clip. Now, it's possible to do with the api.video API. Find all the information in [our Docs](https://docs.api.video/reference/post-video) (in the "Body params" section) or ask questions in [our Community](https://community.api.video/). Happy building!

large_clipping.png

medium_clipping.png

small_clipping.png

thumbnail_clipping.png

clipping.png

How to create a video clip with api.video

Video watermarking

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

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

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

## Pre-requisites 

For this tutorial, you will need: 

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

## Installation 

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

## Code sample 

The code sample we're using is this: 

## Code walkthrough

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

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

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

large_watermark.png

medium_watermark.png

small_watermark.png

thumbnail_watermark.png

watermark.png

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

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

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

client.connect()
`

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

`watermarks_api = WatermarksApi(client)

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

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

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

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

`videos_api = VideosApi(client)

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

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

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

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

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

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

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

## Retrieve watermarks 

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


## Conclusion 

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

How to add watermarks to your videos

Video upload

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

## Prerequisites

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

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

In this sample we do the following: 

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

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

Happy coding!

Progressive uploads with the api.video Python client

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

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

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

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

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

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

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

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

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

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

1. Retrieving a token using your API key. 

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

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

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

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

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

large_progressive-upload.png

medium_progressive-upload.png

small_progressive-upload.png

thumbnail_progressive-upload.png

progressive-upload.png

Progressively upload large video files without compromising on speed

Wouldn't it be great if you could localize video ads with voice overs that are specific to each location for your business? Well now you can! With the walkthrough I put together with Aflorithmic.ai, you can create a set of customized voice overs that you generate automatically. Then, you can add the voice overs to your video ad and store each version of the ad with api.video! 

The tool displayed in the walkthrough is a wizard that helps you set up and check your first video ad. You'll go through setting up and checking an audio file, checking that when paired with your video the sound matches up, then if everything's okay you'll create fifty videos automatically and store them with api.video! 

NOTE: You need to install ffmpeg-python as one of the tools. 
`pip install ffmpeg-python`

The blog post walking you through the content is here: [Api.video + api.audio: Localize Advertisement Videos with Personalized Voice Overs](https://www.aflorithmic.ai/post/api-video-aflorithmic-ai-localize-advertisement-videos-with-personalized-voice-overs)

The repository for the project is here: [api.audio and api.video - AD Localizer
](https://github.com/apivideo/python-api-client/tree/master/examples/video_audio)

small_ivan-torres-mquqbmszggm-unsplash.jpg

thumbnail_ivan-torres-mquqbmszggm-unsplash.jpg

ivan-torres-mquqbmszggm-unsplash.jpg

Localize ads by combining personalized voice overs from Aflorithmic with api.video

Sometimes you have a video that won't play easily on your system. One example that comes immediately to mind is when you have a **.mkv** (Matroska) video on a Mac. Google around, and you'll learn you need to download a particular player, or a QuickTime plug-in called [Perian](https://en.wikipedia.org/wiki/Perian). There are lots of players and even though Perian is discontinued, you could certainly download what you need to play your file. But there's another easy option you could try that won't require a new player or plug-in! You can use [transmuxing](https://api.video/what-is/transmuxing) to change the video container, resulting in a playable video. Another use case might be editing. Many editing tools won't let you use an **.mkv** file, requiring **.mp4** or similar instead. You may want to do the conversion without losing video quality, then convert back. In this situation, transmuxing can help you preserve video quality, while still making your video usable for your project.

## What is transmuxing? 
Transmuxing is where you change the video container without re-encoding the entire video. It's fast, maintains the current quality of your video and often doesn't use a lot of processing power. Sometimes it's the solution to all your problems. And sometimes it makes more problems. But today, we'll learn a little bit about how to transmux using FFmpeg. Then for Python users, we'll go over how to do the same FFmpeg commands using the [ffmpeg-python](https://github.com/kkroening/ffmpeg-python) library.

## Installation
Ffmpeg CLI can be a pain to install. If you have a Mac, there's an easy way to install with homebrew though, and we detail that in the start of the 
[Live Stream to the Browser with FFMPEG CLI and Python](https://api.video/blog/tutorials/live-stream-to-the-browser-with-ffmpeg-cli-and-python).

After you have it installed, test it works by checking the version:

`ffmpeg -version`

## Getting started with FFprobe
Something you can try to see what happens, is to change the ending of your video file. Some containers are interchangeable, and you can get away with just changing the file ending manually, though this isn't best practice. It also won't work to move from **.mkv** to any of mov, mp4, m4a, 3gp, 3g2, or mj2. Typically, whatever file formats are listed when you ffprobe your video are the endings you can manually change your file ending to. 

After you have FFprobe installed, run this command on your video:

`ffprobe video.mp4`

Instead of **video.mp4** put the complete title of your video file. As an example, I tried examining a video I have called **test_vid.mov**. Here's what the results look like: 

`
ffprobe version 4.4 Copyright (c) 2007-2021 the FFmpeg developers
  built with Apple clang version 12.0.5 (clang-1205.0.22.9)
  configuration: --prefix=/usr/local/Cellar/ffmpeg/4.4_2 --enable-shared --enable-pthreads --enable-version3 --cc=clang --host-cflags= --host-ldflags= --enable-ffplay --enable-gnutls --enable-gpl --enable-libaom --enable-libbluray --enable-libdav1d --enable-libmp3lame --enable-libopus --enable-librav1e --enable-librubberband --enable-libsnappy --enable-libsrt --enable-libtesseract --enable-libtheora --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxml2 --enable-libxvid --enable-lzma --enable-libfontconfig --enable-libfreetype --enable-frei0r --enable-libass --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopenjpeg --enable-libspeex --enable-libsoxr --enable-libzmq --enable-libzimg --disable-libjack --disable-indev=jack --enable-avresample --enable-videotoolbox
  libavutil      56. 70.100 / 56. 70.100
  libavcodec     58.134.100 / 58.134.100
  libavformat    58. 76.100 / 58. 76.100
  libavdevice    58. 13.100 / 58. 13.100
  libavfilter     7.110.100 /  7.110.100
  libavresample   4.  0.  0 /  4.  0.  0
  libswscale      5.  9.100 /  5.  9.100
  libswresample   3.  9.100 /  3.  9.100
  libpostproc    55.  9.100 / 55.  9.100
Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'test_vid.mov':
  Metadata:
    major_brand     : isom
    minor_version   : 512
    compatible_brands: isomiso2avc1mp41
    encoder         : Lavf57.83.100
  Duration: 00:00:13.35, start: 0.000000, bitrate: 344 kb/s
  Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p, 640x360, 341 kb/s, 29.97 fps, 29.97 tbr, 30k tbn, 59.94 tbc (default)
    Metadata:
      handler_name    : VideoHandler
      vendor_id       : [0][0][0][0]
`

From this we can see the different file formats (mov, mp4, m4a, 3gp, 3g2, mj2), and that it's encoded using the h264 codec. 

Here's another example, for a file called **giant.mkv**: 

`
ffprobe version 4.4 Copyright (c) 2007-2021 the FFmpeg developers
  built with Apple clang version 12.0.5 (clang-1205.0.22.9)
  configuration: --prefix=/usr/local/Cellar/ffmpeg/4.4_2 --enable-shared --enable-pthreads --enable-version3 --cc=clang --host-cflags= --host-ldflags= --enable-ffplay --enable-gnutls --enable-gpl --enable-libaom --enable-libbluray --enable-libdav1d --enable-libmp3lame --enable-libopus --enable-librav1e --enable-librubberband --enable-libsnappy --enable-libsrt --enable-libtesseract --enable-libtheora --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxml2 --enable-libxvid --enable-lzma --enable-libfontconfig --enable-libfreetype --enable-frei0r --enable-libass --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopenjpeg --enable-libspeex --enable-libsoxr --enable-libzmq --enable-libzimg --disable-libjack --disable-indev=jack --enable-avresample --enable-videotoolbox
  libavutil      56. 70.100 / 56. 70.100
  libavcodec     58.134.100 / 58.134.100
  libavformat    58. 76.100 / 58. 76.100
  libavdevice    58. 13.100 / 58. 13.100
  libavfilter     7.110.100 /  7.110.100
  libavresample   4.  0.  0 /  4.  0.  0
  libswscale      5.  9.100 /  5.  9.100
  libswresample   3.  9.100 /  3.  9.100
  libpostproc    55.  9.100 / 55.  9.100
Input #0, matroska,webm, from 'giant.mkv':
  Metadata:
    title           : Jamaica.Inn.1939.720p.BluRay.x264-x0r[FEATURETTE-Shipwrecked in a Studio: A Video Essy with Donald Spoto]
    encoder         : libebml v1.3.0 + libmatroska v1.4.1
    creation_time   : 2015-05-25T15:34:54.000000Z
  Duration: 00:13:06.77, start: 0.097000, bitrate: 2211 kb/s
  Chapters:
    Chapter #0:0: start 0.000000, end 785.614000
      Metadata:
        title           : Chapter 1
  Stream #0:0(eng): Video: h264 (High), yuv420p(tv, bt709, progressive), 1280x720 [SAR 1:1 DAR 16:9], 23.98 fps, 23.98 tbr, 1k tbn, 180k tbc (default)
    Metadata:
      BPS             : 2049790
      BPS-eng         : 2049790
      DURATION        : 00:13:06.765000000
      DURATION-eng    : 00:13:06.765000000
      NUMBER_OF_FRAMES: 18863
      NUMBER_OF_FRAMES-eng: 18863
      NUMBER_OF_BYTES : 201587950
      NUMBER_OF_BYTES-eng: 201587950
      _STATISTICS_WRITING_APP: mkvmerge v7.4.0 ('Circles') 64bit built on Dec 12 2014 15:04:11
      _STATISTICS_WRITING_APP-eng: mkvmerge v7.4.0 ('Circles') 64bit built on Dec 12 2014 15:04:11
      _STATISTICS_WRITING_DATE_UTC: 2015-05-25 15:34:54
      _STATISTICS_WRITING_DATE_UTC-eng: 2015-05-25 15:34:54
      _STATISTICS_TAGS: BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES
      _STATISTICS_TAGS-eng: BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES
  Stream #0:1(eng): Audio: ac3, 48000 Hz, stereo, fltp, 160 kb/s (default)
    Metadata:
      title           : Stereo
      BPS             : 160000
      BPS-eng         : 160000
      DURATION        : 00:13:06.720000000
      DURATION-eng    : 00:13:06.720000000
      NUMBER_OF_FRAMES: 24585
      NUMBER_OF_FRAMES-eng: 24585
      NUMBER_OF_BYTES : 15734400
      NUMBER_OF_BYTES-eng: 15734400
      _STATISTICS_WRITING_APP: mkvmerge v7.4.0 ('Circles') 64bit built on Dec 12 2014 15:04:11
      _STATISTICS_WRITING_APP-eng: mkvmerge v7.4.0 ('Circles') 64bit built on Dec 12 2014 15:04:11
      _STATISTICS_WRITING_DATE_UTC: 2015-05-25 15:34:54
      _STATISTICS_WRITING_DATE_UTC-eng: 2015-05-25 15:34:54
      _STATISTICS_TAGS: BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES
      _STATISTICS_TAGS-eng: BPS DURATION NUMBER_OF_FRAMES NUMBER_OF_BYTES
`

This one contains streams of data for video and audio. We can see its file formats are matroska or webm and it's also encoded using the h264 codec. 

We can convert these files to one another using transmuxing as long as we want to keep using the h.264 codec. If we wanted to use one of these with an h.265 codec, then we'd need to transcode. 

## Transmuxing 

The command to transmux is simple and it looks like this: 

`ffmpeg -find_stream_info -i YOUR_VIDEO.mkv -map 0 -codec copy -codec:s mov_text NEW_VIDEO.mp4`

You're copying the codecs, and you're just changing the file format. You can move back and forth without losing video quality. By adding -map 0, you let ffmpeg know you want to keep all the streams and data in your original video. 

## Transmuxing with ffmpeg-python 

You might want to use ffmpeg with python. In that case you'll need to do the following: 

1. Install ffmpeg-python, with this command: `pip install ffmpeg-python`
2. Import it into your code with **import ffmpeg**. 
3. The basic code sample is really simple, here's all you're doing: 

`
import ffmpeg

(
    ffmpeg
    .input('giant.mkv')
    .output('output_giant.mov')
    .run()
)
`

The movie will contain your metadata and be playable! 

## Conclusion

You can transmux between files that used the same codec for compression. If you want to compress with a different codec, you'll have to do transcoding. Transmuxing can be helpful when you need a different format, want to preserve quality and you are okay with using the same codec. 

medium_peter-stumpf-fhzepxttiy-unsplash.jpg

small_peter-stumpf-fhzepxttiy-unsplash.jpg

thumbnail_peter-stumpf-fhzepxttiy-unsplash.jpg

peter-stumpf-fhzepxttiy-unsplash.jpg

How do I change my video container without re-encoding using FFMPEG and Python?

We now offer a commandline you can use to run api.video commands. Using Click and our Python client, the commandline offers all the features of our API, plus a few extra things: 

* You can upload a video with a single command, the two step process is handled for you. 
* You can get a csv file of the analytics results for player, video or live stream session information. 
* You can bulk delete videos. 
* You can bulk upload videos with details.

The commandline is open to developer suggestions and improvements - if there's something you want to add, we can review your contribution to the GitHub repository, which is available here: [api.video Commandline](https://github.com/apivideo/python-api-client/tree/master/examples/commandline)

## Installation

As always, I'll recommend that you set up a virtual environment to try things out. After you do that (or if you decide to skip that step), you'll need to do these things: 

1. Install click: `pip install click` 
2. Install api.video: `pip install api.video`
3. Get the repository from [GitHub](https://github.com/apivideo/python-api-client/tree/master/examples/commandline).
4. Add a folder at the same level as these files called 'videos' if you want a place to try uploading videos from. 

## Configure the commandline

To use the commandline, the first thing you need to do is add your API key. In the virtual environment / folder you installed everything, in a terminal, type: 

`python av_cli.py config` 

Follow the instructions to add your API key. You should now be able to use all the features of the commandline. 

You can type: `python av_cli.py --help` to get an exhaustive list of available commandline commands. You can also add `--help` after any of the individual commands for more information, like this: `python av_cli.py liststreams --help`. 

Usage is stated at the top to show you how to structure each command. In general, it'll follow this arrangement: 

`python av_cli.py COMMANDNAME [OPTIONS] [REQUIRED ARGUMENT]`

If you're adding a string, make sure you always have quotes at the start and end of the string. If you're using a dictionary as a string, make sure the quotes at the start and end of the entire dictionary are not the same kind as what you use inside the dictionary.

If you're writing a parameter out, always convert the parameter to snake case. For example, if the api.video documentation says camel case 'sortBy' then when you specify it to the commandline you'll put 'sort_by.' 

## Bulk upload files
This section goes over using the bulk upload command. The bulk upload lets you upload a set of videos from a specified folder along with all the details you want for every video, except for tags and metadata, which you must add later. 

The basic command is: 
`python av_cli.py bulkdetailupload 'path_to_video_folder/' 'path_to_csv_folder'`

For the path to the video folder, make sure it ends with a slash. This path is added to each file to create the link to upload from. 

The CSV file should include every field you can add in a header row, like this: 

`filename,title,description,public,panoramic,mp4_support,player_id`

And then following rows should contain information as necessary. You can leave something blank by framing it with a comma on either side: 

`small_vid.mp4,my great title,it's a video,false,true,true, ,` 

Note that in this example above, the , , represent an empty (lack) of a value for a player_id and the line closes with a comma before beginning the next row. 

## Conclusion 

That should be everything! The commandline can help you quickly reference information, upload videos, get csv files for analytics data and bulk delete videos you don't need anymore. 

We are open to submissions, so if you want to add more features please suggest them or submit your ideas for inclusion! 


small_hannah-joshua-46t6nvjrc2w-unsplash.jpg

thumbnail_hannah-joshua-46t6nvjrc2w-unsplash.jpg

hannah-joshua-46t6nvjrc2w-unsplash.jpg

Run api.video commands from the commandline! 

Authenticate

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

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

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

--Insert video here-- 

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

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

## Prerequisites 

For this project, you're going to need: 

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

## Installation

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

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

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

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

```brew install ffmpeg``` 

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

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

```brew remove portaudio```

Then, reinstall this like so: 

```brew install portaudio``` 

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

```brew pyaudio```

and 

```brew pydub```

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

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

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

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

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

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

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

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

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

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

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

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

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

* city
* address
* day_of_week
* offer_time

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

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

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

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

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

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

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

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

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

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

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

```
play(wav_track)
```

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

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

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

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

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

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

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

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

And then you can open the link like this:

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

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

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

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

Thanks for reading! Happy coding. :) 

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

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/post-video)
* [Upload a video](https://docs.api.video/reference/post_videos-videoid-source)

## 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)



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 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)

Featured article

# api.video blog

Blog

Follow the api.video Blog to explore tutorials, video use cases, and learn about on-demand and live-streaming video updates.