> ## Documentation Index
> Fetch the complete documentation index at: https://cloudinary.com/documentation/llms.txt
> Use this file to discover all available pages before exploring further.

# Transcoding videos to other formats




Videos (and audio files) can be uploaded to Cloudinary in various formats (upload formats). You can  transcode these videos to other formats for displaying in your web site or application (delivery formats). Examples of situations where you might want to change the delivered video format:

* Delivering a video where the original format is not supported for delivery by the browser. For example, you could deliver a 3PG (.3pg) video as an MPEG-4 (.mp4).
* Delivering WebM if your users are on a Chrome browser or on a mobile app you control.

> **TIP**: For video format optimization guidelines, see [How to optimize video format](video_optimization#how_to_optimize_video_format).

## Delivering in a different format

You can transcode and deliver videos in a different format by specifying the required format as the file extension of the delivery URL. You can also convert a video to an audio file by specifying a supported audio format.

When using an SDK to build the URL, you can either append the extension of the new format to the asset's public ID or use the `format` parameter. 

For example, the following example transcodes the uploaded mp4 video with the public ID of `hotel_pool` to WebM format by changing the file extension to `.webm`:

As a URL:
![hotel_pool.mp4 delivered as hotel_pool.webm by changing the file extension](https://res.cloudinary.com/demo/video/upload/hotel_pool.webm "thumb: w_500, width: 500, with_code: false, with_image: false")

Via our SDKs:

```multi
|ruby
cl_video_tag("hotel_pool.webm")

|php_2
use Cloudinary\Tag\VideoTag;

(new VideoTag('hotel_pool.webm'));

|python
CloudinaryVideo("hotel_pool.webm").video()

|nodejs
cloudinary.video("hotel_pool.webm")

|java
cloudinary.url().videoTag("hotel_pool.webm");

|js
cloudinary.videoTag('hotel_pool.webm').toHtml();

|jquery
$.cloudinary.video("hotel_pool.webm")

|react
<Video publicId="hotel_pool.webm" >
</Video>

|angular
<cl-video public-id="hotel_pool.webm" >
</cl-video>

|csharp
cloudinary.Api.UrlVideoUp.BuildVideoTag("hotel_pool.webm")

|go
myVideo, err := cld.Video("hotel_pool")
myVideo.Transformation = "f_webm"
url, err := myVideo.String()

|android
MediaManager.get().url().resourceType("video").generate("hotel_pool.webm");

|swift
cloudinary.createUrl().setResourceType("video").generate("hotel_pool.webm")
```

![hotel_pool.mp4 delivered as hotel_pool.webm by changing the file extension](https://res.cloudinary.com/demo/video/upload/hotel_pool.webm "with_code: false, with_url: false, thumb: w_500")

&nbsp;Another way to transcode the format of an uploaded video is to use the `fetch_format` transformation parameter (`f` for URLs). For example, transcoding the uploaded mp4 video named `hotel_pool` to WebM with a parameter:

![hotel_pool.mp4 delivered as hotel_pool.webm with parameter](https://res.cloudinary.com/demo/video/upload/f_webm/hotel_pool.mp4 "with_image: false, thumb: w_500")

```nodejs
cloudinary.video("hotel_pool", {fetch_format: "webm"})
```

```react
import { format } from "@cloudinary/url-gen/actions/delivery";
import { videoWebm } from "@cloudinary/url-gen/qualifiers/format";

new CloudinaryVideo("hotel_pool.mp4").delivery(format(videoWebm()));
```

```vue
import { format } from "@cloudinary/url-gen/actions/delivery";
import { videoWebm } from "@cloudinary/url-gen/qualifiers/format";

new CloudinaryVideo("hotel_pool.mp4").delivery(format(videoWebm()));
```

```angular
import { format } from "@cloudinary/url-gen/actions/delivery";
import { videoWebm } from "@cloudinary/url-gen/qualifiers/format";

new CloudinaryVideo("hotel_pool.mp4").delivery(format(videoWebm()));
```

```js
import { format } from "@cloudinary/url-gen/actions/delivery";
import { videoWebm } from "@cloudinary/url-gen/qualifiers/format";

new CloudinaryVideo("hotel_pool.mp4").delivery(format(videoWebm()));
```

```python
CloudinaryVideo("hotel_pool").video(fetch_format="webm")
```

```php
use Cloudinary\Transformation\Delivery;
use Cloudinary\Transformation\Format;

(new VideoTag('hotel_pool.mp4'))
	->delivery(Delivery::format(
	Format::videoWebm()));
```

```java
cloudinary.url().transformation(new Transformation().fetchFormat("webm")).videoTag("hotel_pool");
```

```ruby
cl_video_tag("hotel_pool", fetch_format: "webm")
```

```csharp
cloudinary.Api.UrlVideoUp.Transform(new Transformation().FetchFormat("webm")).BuildVideoTag("hotel_pool")
```

```dart
cloudinary.video('hotel_pool.mp4').transformation(Transformation()
	.delivery(Delivery.format(
	Format.videoWebm())));
```

```swift
cloudinary.createUrl().setResourceType("video").setTransformation(CLDTransformation().setFetchFormat("webm")).generate("hotel_pool.mp4")
```

```android
MediaManager.get().url().transformation(new Transformation().fetchFormat("webm")).resourceType("video").generate("hotel_pool.mp4");
```

```flutter
cloudinary.video('hotel_pool.mp4').transformation(Transformation()
	.delivery(Delivery.format(
	Format.videoWebm())));
```

```kotlin
cloudinary.video {
	publicId("hotel_pool.mp4")
	 delivery(Delivery.format(
	Format.videoWebm())) 
}.generate()
```

```jquery
$.cloudinary.video("hotel_pool", {fetch_format: "webm"})
```

```react_native
import { format } from "@cloudinary/url-gen/actions/delivery";
import { videoWebm } from "@cloudinary/url-gen/qualifiers/format";

new CloudinaryVideo("hotel_pool.mp4").delivery(format(videoWebm()));
```

> **NOTES**:
>
> * If the file extension is omitted in a delivery URL, the file is delivered in the originally uploaded format unless a specific format (or the `auto` format is requested using the `fetch_format` (f_) transformation parameter).

> * SDK **major versions** with initial release later than January 2020 have a `format` transformation parameter, instead of the `fetch_format` parameter. See [f (format)](transformation_reference#f_supported_format) in the transformation reference.

## f_auto
You can take advantage of Cloudinary's automatic format selection (`f_auto`) transformation to automatically deliver videos in the most optimized format that's supported by the requesting browser.

For example, if you deliver an MP4 video with `f_auto`, Cloudinary might generate and deliver the video as a VP9-encoded WebM, an HEVC-encoded MP4, or an H.264-encoded MP4, depending on the requesting browser and your account setup. 
For details, see [Automatic format_selection (f_auto)](video_optimization#automatic_format_selection_f_auto).


## Video codec settings

The `video_codec` parameter (`vc` in URLs) is used to determine the video codec, video profile and level to use e.g. `vc_h264:baseline:3.1` or `vc_h264` or `vc_h264:high`. You can set this parameter to `auto` instead, to normalize and optimize the video for web (including audio settings). 

By default, any transformation applied to the video (e.g., resizing) implicitly also uses the `auto` settings when delivering the transformed video, so using the `auto` codec setting is only needed when delivering the same format as originally uploaded but without any additional transformations. See [vc (video\_codec)](transformation_reference#vc_video_codec) in the _Transformation URL API Reference_ for the default settings for each format.
  
Examples with the uploaded mp4 video named `blue_sports_car`:

1. Setting the video codec to h264, the profile to baseline and the level to 3.1:   
![blue_sports_car.mp4 with h264 video codec, baseline profile and level to 3.1](https://res.cloudinary.com/demo/video/upload/vc_h264:baseline:3.1/blue_sports_car.mp4 "with_image: false, thumb: w_500")

```nodejs
cloudinary.video("blue_sports_car", {video_codec: "h264:baseline:3.1"})
```

```react
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { h264 } from "@cloudinary/url-gen/qualifiers/videoCodec";
import { baseline } from "@cloudinary/url-gen/qualifiers/videoCodecProfile";
import { vcl31 } from "@cloudinary/url-gen/qualifiers/videoCodecLevel";

new CloudinaryVideo("blue_sports_car.mp4").transcode(
  videoCodec(
    h264()
      .profile(baseline())
      .level(vcl31())
  )
);
```

```vue
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { h264 } from "@cloudinary/url-gen/qualifiers/videoCodec";
import { baseline } from "@cloudinary/url-gen/qualifiers/videoCodecProfile";
import { vcl31 } from "@cloudinary/url-gen/qualifiers/videoCodecLevel";

new CloudinaryVideo("blue_sports_car.mp4").transcode(
  videoCodec(
    h264()
      .profile(baseline())
      .level(vcl31())
  )
);
```

```angular
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { h264 } from "@cloudinary/url-gen/qualifiers/videoCodec";
import { baseline } from "@cloudinary/url-gen/qualifiers/videoCodecProfile";
import { vcl31 } from "@cloudinary/url-gen/qualifiers/videoCodecLevel";

new CloudinaryVideo("blue_sports_car.mp4").transcode(
  videoCodec(
    h264()
      .profile(baseline())
      .level(vcl31())
  )
);
```

```js
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { h264 } from "@cloudinary/url-gen/qualifiers/videoCodec";
import { baseline } from "@cloudinary/url-gen/qualifiers/videoCodecProfile";
import { vcl31 } from "@cloudinary/url-gen/qualifiers/videoCodecLevel";

new CloudinaryVideo("blue_sports_car.mp4").transcode(
  videoCodec(
    h264()
      .profile(baseline())
      .level(vcl31())
  )
);
```

```python
CloudinaryVideo("blue_sports_car").video(video_codec="h264:baseline:3.1")
```

```php
use Cloudinary\Transformation\Transcode;
use Cloudinary\Transformation\VideoCodec;
use Cloudinary\Transformation\VideoCodecProfile;
use Cloudinary\Transformation\VideoCodecLevel;

(new VideoTag('blue_sports_car.mp4'))
	->transcode(Transcode::videoCodec(
	VideoCodec::h264()
	->profile(
	VideoCodecProfile::baseline())
	->level(
	VideoCodecLevel::vcl31())
	));
```

```java
cloudinary.url().transformation(new Transformation().videoCodec("h264:baseline:3.1")).videoTag("blue_sports_car");
```

```ruby
cl_video_tag("blue_sports_car", video_codec: "h264:baseline:3.1")
```

```csharp
cloudinary.Api.UrlVideoUp.Transform(new Transformation().VideoCodec("h264:baseline:3.1")).BuildVideoTag("blue_sports_car")
```

```dart
cloudinary.video('blue_sports_car.mp4').transformation(Transformation()
	.transcode(Transcode.videoCodec(
	VideoCodec.h264()
	.profile(
	VideoCodecProfile.baseline())
	.level(
	VideoCodecLevel.vcl31())
	)));
```

```swift
cloudinary.createUrl().setResourceType("video").setTransformation(CLDTransformation().setVideoCodec("h264:baseline:3.1")).generate("blue_sports_car.mp4")
```

```android
MediaManager.get().url().transformation(new Transformation().videoCodec("h264:baseline:3.1")).resourceType("video").generate("blue_sports_car.mp4");
```

```flutter
cloudinary.video('blue_sports_car.mp4').transformation(Transformation()
	.transcode(Transcode.videoCodec(
	VideoCodec.h264()
	.profile(
	VideoCodecProfile.baseline())
	.level(
	VideoCodecLevel.vcl31())
	)));
```

```kotlin
cloudinary.video {
	publicId("blue_sports_car.mp4")
	 transcode(Transcode.videoCodec(
	VideoCodec.h264() {
	 profile(
	VideoCodecProfile.baseline())
	 level(
	VideoCodecLevel.vcl31())
	 })) 
}.generate()
```

```jquery
$.cloudinary.video("blue_sports_car", {video_codec: "h264:baseline:3.1"})
```

```react_native
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { h264 } from "@cloudinary/url-gen/qualifiers/videoCodec";
import { baseline } from "@cloudinary/url-gen/qualifiers/videoCodecProfile";
import { vcl31 } from "@cloudinary/url-gen/qualifiers/videoCodecLevel";

new CloudinaryVideo("blue_sports_car.mp4").transcode(
  videoCodec(
    h264()
      .profile(baseline())
      .level(vcl31())
  )
);
```

1. Normalizing the video for web with the default settings:  
![blue_sports_car.mp4 normalized for web with default settings](https://res.cloudinary.com/demo/video/upload/vc_auto/blue_sports_car.mp4 "thumb: w_500, width:500")

```nodejs
cloudinary.video("blue_sports_car", {video_codec: "auto"})
```

```react
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { auto } from "@cloudinary/url-gen/qualifiers/videoCodec";

new CloudinaryVideo("blue_sports_car.mp4").transcode(videoCodec(auto()));
```

```vue
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { auto } from "@cloudinary/url-gen/qualifiers/videoCodec";

new CloudinaryVideo("blue_sports_car.mp4").transcode(videoCodec(auto()));
```

```angular
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { auto } from "@cloudinary/url-gen/qualifiers/videoCodec";

new CloudinaryVideo("blue_sports_car.mp4").transcode(videoCodec(auto()));
```

```js
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { auto } from "@cloudinary/url-gen/qualifiers/videoCodec";

new CloudinaryVideo("blue_sports_car.mp4").transcode(videoCodec(auto()));
```

```python
CloudinaryVideo("blue_sports_car").video(video_codec="auto")
```

```php
use Cloudinary\Transformation\Transcode;
use Cloudinary\Transformation\VideoCodec;

(new VideoTag('blue_sports_car.mp4'))
	->transcode(Transcode::videoCodec(
	VideoCodec::auto()));
```

```java
cloudinary.url().transformation(new Transformation().videoCodec("auto")).videoTag("blue_sports_car");
```

```ruby
cl_video_tag("blue_sports_car", video_codec: "auto")
```

```csharp
cloudinary.Api.UrlVideoUp.Transform(new Transformation().VideoCodec("auto")).BuildVideoTag("blue_sports_car")
```

```dart
cloudinary.video('blue_sports_car.mp4').transformation(Transformation()
	.transcode(Transcode.videoCodec(
	VideoCodec.auto())));
```

```swift
cloudinary.createUrl().setResourceType("video").setTransformation(CLDTransformation().setVideoCodec("auto")).generate("blue_sports_car.mp4")
```

```android
MediaManager.get().url().transformation(new Transformation().videoCodec("auto")).resourceType("video").generate("blue_sports_car.mp4");
```

```flutter
cloudinary.video('blue_sports_car.mp4').transformation(Transformation()
	.transcode(Transcode.videoCodec(
	VideoCodec.auto())));
```

```kotlin
cloudinary.video {
	publicId("blue_sports_car.mp4")
	 transcode(Transcode.videoCodec(
	VideoCodec.auto())) 
}.generate()
```

```jquery
$.cloudinary.video("blue_sports_car", {video_codec: "auto"})
```

```react_native
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { auto } from "@cloudinary/url-gen/qualifiers/videoCodec";

new CloudinaryVideo("blue_sports_car.mp4").transcode(videoCodec(auto()));
```

1. Setting the video codec to av1 for improved optimization:
![blue_sports_car.mp4 with av1 codec](https://res.cloudinary.com/demo/video/upload/vc_av1/blue_sports_car.mp4 "with_image: false, thumb: w_500")

```nodejs
cloudinary.video("blue_sports_car", {video_codec: "av1"})
```

```react
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { av1 } from "@cloudinary/url-gen/qualifiers/videoCodec";

new CloudinaryVideo("blue_sports_car.mp4").transcode(videoCodec(av1()));
```

```vue
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { av1 } from "@cloudinary/url-gen/qualifiers/videoCodec";

new CloudinaryVideo("blue_sports_car.mp4").transcode(videoCodec(av1()));
```

```angular
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { av1 } from "@cloudinary/url-gen/qualifiers/videoCodec";

new CloudinaryVideo("blue_sports_car.mp4").transcode(videoCodec(av1()));
```

```js
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { av1 } from "@cloudinary/url-gen/qualifiers/videoCodec";

new CloudinaryVideo("blue_sports_car.mp4").transcode(videoCodec(av1()));
```

```python
CloudinaryVideo("blue_sports_car").video(video_codec="av1")
```

```php
use Cloudinary\Transformation\Transcode;
use Cloudinary\Transformation\VideoCodec;

(new VideoTag('blue_sports_car.mp4'))
	->transcode(Transcode::videoCodec(
	VideoCodec::av1()));
```

```java
cloudinary.url().transformation(new Transformation().videoCodec("av1")).videoTag("blue_sports_car");
```

```ruby
cl_video_tag("blue_sports_car", video_codec: "av1")
```

```csharp
cloudinary.Api.UrlVideoUp.Transform(new Transformation().VideoCodec("av1")).BuildVideoTag("blue_sports_car")
```

```dart
cloudinary.video('blue_sports_car.mp4').transformation(Transformation()
	.transcode(Transcode.videoCodec(
	VideoCodec.av1())));
```

```swift
cloudinary.createUrl().setResourceType("video").setTransformation(CLDTransformation().setVideoCodec("av1")).generate("blue_sports_car.mp4")
```

```android
MediaManager.get().url().transformation(new Transformation().videoCodec("av1")).resourceType("video").generate("blue_sports_car.mp4");
```

```flutter
cloudinary.video('blue_sports_car.mp4').transformation(Transformation()
	.transcode(Transcode.videoCodec(
	VideoCodec.av1())));
```

```kotlin
cloudinary.video {
	publicId("blue_sports_car.mp4")
	 transcode(Transcode.videoCodec(
	VideoCodec.av1())) 
}.generate()
```

```jquery
$.cloudinary.video("blue_sports_car", {video_codec: "av1"})
```

```react_native
import { videoCodec } from "@cloudinary/url-gen/actions/transcode";
import { av1 } from "@cloudinary/url-gen/qualifiers/videoCodec";

new CloudinaryVideo("blue_sports_car.mp4").transcode(videoCodec(av1()));
```
  
> **NOTES**:
>
> * Supported for: `vp9`, `prores`, `h264` or `h265`. Only the `h264` codec (`mp4`) has profile or level parameters, with profile: `baseline`, `main` or `high` and level: `3.0`,`3.1`,`4.0`,`4.1`, `4.2`, `5.0`, `5.1` or `5.2`.

> * The `prores` parameter value delivers videos encoded with the Apple ProRes 422HQ codec.

> * Client libraries can optionally enter the parameter as a structure. For example, in Ruby: `video_codec: { codec: 'h264', profile: 'baseline', level: '3.1' }`


## HDR video transformations

High Dynamic Range (HDR) video provides expanded color gamut and luminance range, delivering more vivid and lifelike content compared to Standard Dynamic Range (SDR) video. Cloudinary supports HDR10 video transformation and delivery, allowing you to deliver your HDR10/HLG content while preserving the original color-grading and HDR metadata, or properly tone-map HDR to SDR on non-HDR devices. This ensures your original visual intent gets preserved in full HDR or gracefully mapped to SDR.

### Requesting HDR output

To request HDR output of an HDR source video, you must use both the `dynamic_range` parameter set to `high` (`dr_high` in URLs) and the `video_codec` parameter set to `h265` (`vc_h265` in URLs).

> **INFO**: Cloudinary currently supports HDR10 and HLG formats only. When delivering these videos, Cloudinary performs direct transcoding, preserving the color-grading and HDR metadata from the source video. Other HDR formats (such as Dolby Vision and HDR10+) aren't supported directly unless they're compatible with HLG or HDR10, otherwise they're output as SDR.

Examples with an HDR video named `docs/hdr_turtle`:

1. Request HDR output:  
![HDR video output](https://res.cloudinary.com/demo/video/upload/dr_high,vc_h265/docs/hdr_turtle.mp4 "thumb: w_500, width:500, with_code: false")

1. Request HDR output with trimming and resizing:  
![HDR video trimmed to 5 seconds](https://res.cloudinary.com/demo/video/upload/c_scale,w_1200/du_5/dr_high,vc_h265/docs/hdr_turtle.mp4 "thumb: w_500, width:500, with_code: false")

### Supported transformations

When delivering HDR videos, the following transformations are supported:

* Trimming (`so`, `eo`, `du`)
* Scaling (`c_scale`, `w`, `h`)
* Cropping (`c_crop`, `c_fill`)
* Text overlays (`l_text`)
* Subtitles (`l_subtitles`)
* Audio transformations (`e_volume`, codec, frequency, bitrate)

### HDR and SDR output behavior

Understanding when Cloudinary delivers your videos as HDR versus SDR helps you optimize content for different viewing scenarios.

**HDR output requirements**

To deliver HDR video, you must meet all of the following conditions:

* **Compatible HDR input**: The input video must be HLG or HDR10 compatible HDR with proper metadata tagging
* **Request HDR explicitly**: You must explicitly request HDR output using the `dr_high` parameter
* **Set HEVC codec**: You must set the video codec to HEVC (H.265) using `vc_h265`
* **High-quality source**: The input must be a high-quality, progressive master

**SDR output scenarios**

Cloudinary delivers your video as SDR in the following cases:

* **SDR input**: Standard dynamic range videos always output as SDR
* **HDR without explicit parameters**: Cloudinary automatically tone-maps HLG/HDR10 compatible HDR input to SDR when you don't specify `dr_high` and `vc_h265`
* **Unsupported HDR formats**: Cloudinary converts Dolby Vision and HDR10+ content to SDR (unless also compatible with HLG or HDR10)
* **Invalid or missing metadata**: Improperly tagged or partially HDR content defaults to SDR processing
* **Incompatible transformations**: If the requested transformation combination can't preserve HDR, Cloudinary returns an error and you need to adjust the transformation parameters to explicitly request SDR output.

> **NOTES**:
>
> * Cloudinary processes HDR transformations asynchronously. The first request for an HDR derivative returns a `423` status code while Cloudinary generates the video. Subsequent requests return the processed HDR video once generation completes. To ensure that even the first customer request returns your HDR video, we recommend generating your HDR video transformations [eagerly](eager_and_incoming_transformations#eager_transformations)

> * Most modern displays and devices support HDR playback, but SDR fallback ensures compatibility with all devices.

> * If you're using the [Cloudinary Video Player](cloudinary_video_player), you can enable [HDR video delivery](video_player_customization#hdr_video_delivery) to automatically detect HDR-capable devices and apply the appropriate transformations.

> **INFO**: For HDR transformation pricing details, see [HDR videos](transformation_counts#video_counts) in _How are transformations counted?_.

## Supported video formats

The table below summarizes the supported video formats. 

Format | Extensions | Supported for Upload1| Supported for Delivery | Default Codec
--- | --- | --- | --- | ---
3G2 | 3g2| Yes |  |
3GP (3rd Generation Partnership) | 3gp| Yes |  |
AVI (Audio Video Interleave) | avi | Yes |  |
FLV (Flash Video) | flv | Yes | No 2|
HLS adaptive streaming | m3u8 | Yes (as raw file only)  | Yes 3 | Defined by streaming profile
MPEG-2 Transport Stream | ts, m2ts, mts | Yes | Yes | Defined by streaming profile
MOV | mov | Yes | Yes | h264
MKV (Matroska Multimedia Container) | mkv | Yes | Yes | 
MP4 | mp4 | Yes | Yes | h264
MPEG-2 | mpeg | Yes |  | 
MPEG-DASH adaptive streaming | mpd | Yes (as raw file only) | Yes 3 | Defined by streaming profile
MXF (Material eXchange Format) | mxf | Yes| | 
OGV (Ogg Video) | ogv | Yes | Yes |  
WebM | webm | Yes | Yes | VP9 4
WMV (Windows Media Video) | wmv | Yes | No |  | 

> **NOTES**:
>
> :title=Footnotes
> 1. If a format is only supported for upload, then the delivery URL enables a user to download the **original** file in its original format, but you cannot apply transformation parameters. If you want to apply transformations, you can transcode the video to a different format for delivery.
> 2. The FLV format has been deprecated by Adobe, however you can [deliver existing FLV files as other formats](video_transcoding#delivering_in_a_different_format). 
> 3. For adaptive streaming manifest files (m3u8 and mpd), only those generated using Cloudinary can be used for delivery. See [Adaptive Bitrate streaming](adaptive_bitrate_streaming) for more information.
> 4. The default codec for WebM is VP9. For older accounts the default is VP8. [Submit a support request](https://support.cloudinary.com/hc/en-us/requests/new) to change this default.

**See also**: [supported audio formats](audio_transformations#supported_audio_formats).