Documentation and Tutorials
Features overview...

Image transformations

Overview

Whether your web application supports the upload of dynamic images, you deliver static images, or you display profile pictures from social networks, you probably need to convert them to fit the graphic design of your Web site.

Cloudinary allows you to easily transform your images to any required format and dimension.

You can resize or crop the images in various ways. Doing so is done by simply directing your users to an address URL that includes the transformation instructions. You can change the required transformations at any time and all transformed images will be created on-demand (lazily) and delivered to your users through a CDN.

You can specify the required height and width, define the way to crop the image, and select the image format that fits your needs. You can also use our face detection based cropping techniques. For complex transformations, you can use the Management Console for defining named transformations and even run a set of transformations on your images.

In the future we plan to support additional image transformation features.

Cloudinary's client libraries wrap transformation URL building to simplify the integration further:

Resize Dimensions

Changing the size of an image is easy: simply pass in the width and height parameters. When building a dynamic resource URL, pass the 'w' and 'h' parameters.

For example, the following URL points to a 90x70 dynamically created resized version of an uploaded image with the public ID 'sample':

Here is the same example for adding an image tag using our Ruby on Rails library:

cl_image_tag("sample.jpg", :width => 90, :height => 70, :crop => :scale)
90x70 JPG

You can use any integer values for the width and height. They can be smaller and bigger than the original dimensions of the image. They don't necessarily need to keep the same proportions of the original image. You don't need to predefine the dimensions you need and you can use as many dimensions as you want for each image. If needed, each dimension will create a new derived image resource based on the defined transformations. The original uploaded image never changes while creating transformations.

You can also change the dimension of an image using percents. Simply use a decimal value for defining the required size. You can provide only the width or height parameters instead of both of them.

For example, resizing the 'sample' image to 60% of its original size is done by setting the 'width' parameter to 0.6:

Increasing the image size is also possible. Setting 'width' to 1.5 will scale up the image in 150%:

Crop modes

When creating smaller versions of an uploaded image, you need to decide how to 'crop' the image for fitting into the desired dimension.

For selecting the mode you need, use the 'crop' parameter, which is represented by the 'c' letter in resource URLs. Cloudinary supports all standard crop and resize mode. The default mode is scale. Here are the supported modes and some examples:

scale

Change the size of the image exactly to the given width & height while not retaining original proportions. All original image parts are visible but might be stretched or shrunken.

For example, scaling the sample image (originally 864x576) to 100x150:

Or a view image tag for Ruby on Rails:

cl_image_tag("sample.jpg", :width => 100, :height => 150, :crop => :scale)
100x150 JPG

You can also scale up an image (and stretch it):

fit

Change image size to fit in the given width & height while retaining original proportions. All original image parts are visible. Both width and height dimensions of the transformed image must not exceed the specified width & height. However, they may be smaller than the specified values in order to keep the original proportion.

For example, fitting the sample image 100x150:

Note that the generated image is actually 100x67 in order to keep the original proportions of 864x567 (~1.5).

Fitting the image to 300x100 will actually generate a 150x100 image (retaining the 1.5 aspect ratio):

fill

Create an image with the exact given width and height while retaining original proportions. Use only part of the image that fills the given dimensions. Only part of the original image might be visible if the required proportions are different than the original ones.

For example, filling a 100x150 rectangle based on the sample image:

The generated image is exactly 100x150 while not all flowers are visible.

When using the 'fill' mode, you can specify which part of the original image to use for filling the required dimensions in case the proportions do not match. You can do so by using the gravity parameter (or 'g' in URLs), which defined which part of the image to take.

The supported gravity values are: north_west, north, north_east, west, center (Default), east, south_west, south, south_east, face and faces.

Note: 'face' and 'faces' gravity options are currently supported only for 'fill', 'crop' and 'thumb' crop modes. For more details see Face detection.

In the example above, no gravity was specified, so the default 'center' gravity was used. In the following example we fill a 100x150 rectangle while using south east corner of the sample image:

Or using our Ruby on Rails library:

cl_image_tag("sample.jpg", :width => 100, :height => 150, :crop => :fill, 
             :gravity => :south_east)
100x150 JPG

limit

The limit mode is used for creating an image that does not exceed the given width or height. If the original image is smaller than the given limits, the generated image is identical to the original one. If the original is bigger than the given limits, it will be resized while retaining original proportions (similar to the 'fit' mode in this case).

For example, limiting the sample image to 100x150 will generate an image identical to the 'fit' mode:

Specifying width & height bigger than the original 864x576 will simply return the original 864x576 image:

The limit mode is useful for making sure that a user uploaded image is not too big (you can run a 'limit' transformation as part of the upload process to prevent storing the original too-big image at all).

pad

Resize the image to fill the given width & height while retaining original proportions.

If proportions of the originals image do not match the required ones, pad the image for reaching exactly the required size. You can specify the 'gravity' to selecting which part of the original image to use for filling the rectangle.

For example, creating a 100x150 image with padding:

crop

The 'crop' mode is used to extract only part of a given width & height out of the original image. The original proportions are retained and so is the size of the graphics. You can specify the gravity to use for selecting which image part to take.

For example, generating a 100x150 image based on the 100x150 top left pixels of the original image:

Another example for generating a cropped version of the original image with 40% of its center content:

Fixed coordinates cropping

In addition to the crop modes listed above, Cloudinary also supports custom/fixed coordinates cropping. Use this method when you know beforehand what the correct absolute cropping coordinates are. For example, this method is helpful when your users manually select the region to crop out of the original image. Many excellent Javascript libraries (such as Jcrop) allow for client-side cropping region selection. Simply send the coordinates to Cloudinary and get the desired cropped image.

For example, the picture below shows many white sheep and one brown sheep. We want to crop the picture in a way that only the brown sheep is visible.

Specify the fixed coordinates using the 'x' and 'y' parameters. The following example generates a 300x200 image starting at the 355x410 pixels corner:

Same example using our Ruby on Rails library:

cl_image_tag("brown_sheep.jpg", 
             :width => 300, :height => 200, :x => 355, :y => 410, :crop => :crop)

After you have the fixed coordinates for cropping the relevant part of the original image, you probably want to generate smaller versions of the cropped part (e.g., thumbnails). You can use chained transformations to achieve that.

The following example generates a 150x100 thumbnail of the brown sheep out of the 300x200 cropped version:

Face detection

When cropping or resizing images you sometimes want to focus on a certain element of the picture. The most common example is creating a thumbnail with a close-up of the face of the person in the image.

Cloudinary provides smart image cropping based on face detection algorithms. You can automatically get a cropped version of an uploaded image or a Facebook profile picture, while centering on a single or multiple faces.

Single face detection

Cloudinary can automatically crop a clear picture of a person in a way that the face of the person is in the center of the derived picture.

For example, the image below of a woman with a Blue Morpho butterfly was uploaded to Cloudinary:

In order to embed a 90x90 thumbnail with only the face of the woman, simply select the 'thumb' crop mode and the 'face' gravity:

Or using our Ruby on Rails library:

cl_image_tag("butterfly.jpg", :width => 90, :height => 90, 
             :crop => :thumb, :gravity => :face)
90x90 JPG

You can also request Cloudinary to crop to the requested dimensions without resizing the original image. The following example uses the 'crop' mode and the 'face' gravity for cropping the original image to a 90x90 box while centering on the face of the woman:

If you want to use the 'fill' crop mode to keep as much as possible of the original image, you can still use the 'face' gravity parameter to correctly fill the requested 90x90 box:

Just for comparison, the default center gravity without face detection would have cropped the image in a less elegant way:

Multiple faces detection

Sometimes you have a picture with more than one person and you want to resize the image to correctly fit your web site's graphic design. Cloudinary can automatically crop images while detecting multiple faces and centering the image on the bounding box of all faces.

For example, the following image, showing a nice couple, was uploaded to Cloudinary:

You can specify the 'thumb' crop mode and 'face' gravity to create a 90x90 thumbnail with the face of one of them:

In order to create a thumbnail showing the faces of both of them, simply specify 'faces' as the gravity:

You can also use the 'fill' mode with 'faces' gravity to correctly fill an image with your desired dimensions:

Format conversion

Static or dynamic image are uploaded to Cloudinary in various formats. You might want to convert them for displaying in your web site in your desired format.

If you know you display photos and you want them to load quickly, you might want to use a low quality JPG format. If you know the image contains a drawing with only a few colors, then the GIF format might suite you best. When you need to display high quality illustrations with a transparent background the PNG (24 bit) format is the best choice.

You can dynamically convert images to your desired format. Cloudinary currently supports the following formats: JPG, PNG, GIF, BMP, TIFF, ICO, PDF, EPS, PSD, SVG and WebP

You can specify the format as part of the resource name.

For example, if you want to display a GIF version of the uploaded sample JPG file:

Or using our Ruby on Rails library:

cl_image_tag("sample.gif")

Note that 'sample' is the Public ID of the resource and '.gif' is the extension that represents the format you need.

You can of course combine resize instructions with format conversion. For example, creating a GIF version of 100x150 of the original larger sample.jpg image:

To create a JPG file with a lower quality (when you prefer a smaller file that can be quickly downloaded over quality), you can use the 'quality' parameter (or 'q' in URLs). It accepts a value between 0 (lowest quality) and 100 (best quality).

For example, if you want to create a JPG version of quality 12 of the sample image scaled to 60%:

You can easily notice that this transformed image is of lower quality.

Rounded corners and circular image cropping

Many website designs call for images with rounded corners, while some websites require images with a complete circular or oval (ellipse) crop. Twitter, for example, uses rounded corners for its users' profile pictures.

Programmatically, rounded corners can be achieved using the original rectangular images combined with modern CSS properties or image masking overlays. However, it is sometimes very useful to generate images with rounded corners in the first place. This is particularly helpful when you want to embed images inside an email (most mail clients can't add CSS based rounded corners), a PDF or a mobile application. Having images with rounded corners is also great if you want to simplify your CSS and markup or when you need to support older browsers.

Transforming an image to a rounded version is done using the 'radius' parameter. It accepts the number of pixels the radius of all four corners should be.

The following example transforms an uploaded JPG to a 150x100 PNG with rounded corners of 20 pixels. Note that the conversion to PNG is needed for supporting a transparent background.

And the same example in Ruby on Rails:

cl_image_tag("sample.png", :width => 150, :height => 100, 
             :crop => :fill, :radius => 20)

Rounded corners can also be applied to Facebook or Twitter profile pictures. As shown in the following example, face detection based cropping also helps to achieve a better looking result:

Cloudinary supports cropping images to a shape of an ellipse or a circle (if the requested width and height are the same). Simply pass 'max' as the value of the 'radius' parameter.

The following example transforms an uploaded JPG to a 150x100 PNG with max radius cropping, which generates the ellipse shape with a transparent background:

As the following example shows, displaying pictures of your Web site's users as nice looking circles is very easy to achieve with Cloudinary using the 'face' gravity and the 'max' radius:

Named transformations

Cloudinary allows you to define named image transformations through our Management Console. It is useful when you have relative complex transformations that you use often and you want to reference them by name from your client application.

Named transformations can also be based on other named transformations. This allows you to define a chain of transformations to run on uploaded images very easily.

Let's say you define the following named transformations through the Management Console:

  • jpg_with_quality_30: Convert to a JPG with 30% quality.
  • crop_400x400: Crop the image to 400x400 (mode=crop) with center gravity.
  • fit_100x150: Fit into a 100x150 rectangle.

Using named transformations is done using the 'transformation' parameter, or the 't' parameter of URLs.

For example, creating a version of the sample image based on the fit_100x150 transformation:

Or using our Ruby on Rails library:

cl_image_tag("sample.jpg", :transformation => 'fit_100x150')

You can chain transformations. For example, based on the fit_100x150 transformation, you can crop it again to 50x50 with center gravity:

You can also chain named transformations. Simply concatenate their names separated with '.'.

For example, chaining the three named transformations we defined above:

But this is quite a long URL. You can define a named transformation that is a chain of other transformations. For example, let's name the transformation 'demo_combined' which is a chain of the three transformations described above.

Now you can simply specify the 'demo_combined' name for applying the chain of three transformations:

Transformations reference

The table below lists all transformation parameters currently supported by Cloudinary. For each parameter you can see the short name that you can use for manually building transformation URLs and the longer name that is accepted by the relevant methods of all our client libraries. You can see the possible values for each parameter and a usage example with a sample image for an illustration. You can reach plenty more effects and transformations by chaining together any combination of the parameters listed below.

Library Parameter URL Param Value Example Description
cropcmodeA crop mode that determines how to transform the image for fitting into the desired width & height dimensions.
scale(default)Face_topChange the size of the image to match the given width & height. All original image parts will be visible but might be stretched or shrunken.
fillFace_topCreate an image with the exact given width and height while retaining original proportions. Uses only a portion of the original image that fills the given dimensions.
lfillFace_topSame as the 'fill' mode but doesn't expand the image if your requested dimensions are larger than the original image's.
fitFace_topChange image size to fit in the given width & height while retaining original proportions. All original image parts are visible. Both width and height dimensions of the transformed image must not exceed the specified width & height.
mfitFace_topScale the image up to fit the given width & height while retaining original proportions.
limitFace_topUsed for creating an image that does not exceed the given width or height.
padFace_topResize the image to fill the given width & height while retaining original proportions. Padding will be added if the original image proportions do not match the required ones.
lpadFace_topSame as the 'pad' mode but doesn't scale the image up if your requested dimensions are larger than the original image's.
mpadFace_topSame as the 'pad' mode but doesn't scale the original image.
cropFace_topUsed to extract a given width & height out of the original image. The original proportions are retained and so is the size of the graphics.
thumbFace_topGenerate a thumbnail using face detection in combination with the 'face' or 'faces' gravity.
 
widthwpixels or percentsThe required width of a transformed image or an overlay. Can be specified separately or together with the height value.
80Face_topResize width to 80 pixels while maintaining aspect ratio.
0.2Face_topResize image to 20% of its original size.
 
heighthpixels or percentsThe required height of a transformed image or an overlay. Can be specified separately or together with the width value.
40Face_topResize height to 40 pixels while maintaining aspect ratio.
0.3Face_topResize image to 30% of its original size.
 
gravitygdirectionDecides which part of the image to keep while 'crop', 'pad' and 'fill' crop modes are used. For overlays, this decides where to place the overlay.
north_westFashion_gravityNorth west corner (top left).
northFashion_gravityNorth center part (top center).
north_eastFashion_gravityNorth east corner (top right).
westFashion_gravityMiddle west part (left).
center(default)Fashion_gravityThe center of the image.
eastFashion_gravityMiddle east part (right).
south_westFashion_gravitySouth west corner (bottom left).
southFashion_gravitySouth center part (bottom center).
south_eastFashion_gravitySouth east corner (bottom right).
xy_centerFashion_gravitySet the crop's center of gravity to the given x & y coordinates"
faceFace_topAutomatically detect the largest face in an image and aim to make it the center of the cropped image. Alternatively, use face coordinates specified by API if available. Defaults to the 'north' gravity if no face was detected.
face (thumb)Face_topAutomatically detect the largest face in an image and use it to generate a face thumbnail.
facesCoupleAutomatically detect multiple faces in an image and aim to make them the center of the cropped image.
face:centerFace_topSame as the 'face' gravity, but with fallback to 'center' gravity instead of 'north' if no face is detected.
faces:centerCoupleSame as the 'faces' gravity, but with fallback to 'center' gravity instead of 'north' if no face is detected.
customFace_topUse custom coordinates that were specified by the upload or admin API and aim to make it the center of the cropped image. Defaults to the 'center' gravity if no custom coordinates available.
 
xxpixelsHorizontal position for custom-coordinates based cropping, overlay placement and certain region related effects.
130Face_topCrop image to an 80x80 square starting 130 pixels from the left.
 
yypixelsVertical position for custom-coordinates based cropping and overlay placement.
340Face_topCrop image to an 80x80 square starting 340 pixels from the top.
 
qualityqpercentsControl the JPG compression quality. 1 is the lowest quality and 100 is the highest. The default is the original image's quality or 90% if not available. Reducing quality generates JPG images much smaller in file size.
100Face_topGenerate a thumbnail using highest image quality (9.15KB)
20Face_topGenerate a thumbnail using a low 20% quality (1.48KB)
 
radiusrpixels or maxRound the corners of an image or make it completely circular or oval (ellipse).
20White_chickenGenerate a small image with rounded corners of 20 pixels radius.
maxWhite_chickenGenerate an image with a circular crop using the 'max' radius value.
 
angleadegrees or modeRotate or flip an image by the given degrees or automatically according to its orientation or available meta-data. Multiple modes can be applied by concatenating their names with a dot.
90SheepRotate image by 90 degrees clockwise.
10SheepRotate image by 10 degrees clockwise.
-20SheepRotate image by 20 degrees counterclockwise.
auto_rightSheepRotate image 90 degrees clockwise only if the requested aspect ratio does not match the image's aspect ratio.
auto_leftSheepRotate image 90 degrees counterclockwise only if the requested aspect ratio does not match the image's aspect ratio.
exifSheepAutomatically rotate the image according to the EXIF data stored by the camera when the image was taken.
vflipSheepVertical mirror flip of the image.
hflipSheepHorizontal mirror flip of the image.
 
effectename and valueApply a filter or an effect on an image. The value includes the name of the effect and an additional parameter that controls the behavior of the specific effect.
grayscaleHorsesConvert image to gray-scale (multiple shades of gray).
blackwhiteHorsesCovert image to black and white.
oil_paintHorsesApply an oil painting effect.
negateHorsesNegate image colors (negative).
vignetteHorsesApply a vignette effect.
sepiaHorsesChange the color scheme of the image to sepia. (default level: 80).
sepia:50HorsesApply the sepia effect with strength of '50'.
brightness:60HorsesIncrease image brightness by 60% (default: 80)
brightness:-40HorsesDecrease image brightness by 40%.
auto_brightnessHorsesAutomatically adjust brightness.
fill_lightHorsesAdjust the fill light of an image. (level range: -100-100, default value: 0)
saturation:70HorsesIncrease the image's color saturation by 70% (default: 80).
saturation:-50HorsesDecrease the image's color saturation by 50%.
hue:40HorsesAlter the image's hue by 40 (default: 80).
pixelateHorsesApply a pixelate effect on the image.
pixelate:3HorsesApply a pixelate effect using 3 pixels wide pixelation squares.
pixelate_regionHorsesPixelate only a certain region of the image based on the given x, y, width and height.
pixelate_region:20HorsesPixelate only a certain region of the image using 20 pixels wide pixelation squares.
pixelate_facesCoupleAutomatically pixelate all detected faces in the image.
pixelate_faces:3CoupleAutomatically pixelate all detected faces in the image using 3 pixels wide pixelation squares.
gradient_fadeHorsesApply a gradient fade effect on the image.
blurHorsesApply a blurring filter on the image. (level range: 1-2000, default level: 100)
blur:300HorsesApply a strong blurring filter of level 300 on the image.
blur_regionHorsesApply a blurring filter on a certain region of an image, specified by x, y, width and height. (level range: 1-2000, default level: 100)
blur_facesCoupleAutomatically blur all detected faces in the image. (level range: 1-2000, default level: 100)
sharpenHorsesSharpen the image. (level range: 1-2000, default level: 100)
sharpen:400HorsesApply a strong sharpening filter of level 400.
unsharp_maskHorsesSharpen the image using the unsharp mask filter. (level range: 1-2000, default level: 100)
unsharp_mask:400HorsesApply a strong unsharp mask filter of level 400.
contrast:90HorsesIncrease image contrast by 90%.
contrast:-70HorsesDecrease image contrast by 70%.
auto_contrastHorsesAutomatically adjust contrast.
vibranceHorsesApply a vibrance filter on the image. (level range: -100-100, default level: 20)
vibrance:70HorsesApply a strong vibrance filter of level 70 on the image.
red:50HorsesStrengthen the image's red channel by 50%.
green:50HorsesStrengthen the image's green channel by 50%.
blue:90HorsesStrengthen the image's blue channel by 90%.
auto_colorHorsesAutomatically adjust color balance.
improveHorsesAutomatically adjust image colors, contrast and lightness.
screenHorsesAdd an overlay image blended using the 'screen' blend mode. In this mode, each pixel of the image is made brighter according to the pixel value of the overlayed image.
multiplyHorsesAdd an overlay image blended using the 'screen' blend mode. In this mode, each pixel of the image is made darker according to the pixel value of the overlayed image.
make_transparentFashion_gravityMake the background of the image transparent (or solid white for JPGs). The background is determined as all pixels that resemble the pixels in the image's edges. (level range: 0-100, default level: 10)
trimFashion_gravityDetect and remove image edges whose color is similar to corner pixels. (color similarity tolerance level range: 0-100, default level: 10)
shadowHorsesAdd a bottom right gray shadow. (level range: 0-100, default level: 40)
shadow:50HorsesAdd a colored shadow with offset specified by x & y and blurring level.
 
opacityopercentsAdjust the opacity of the image and make it semi-transparent. 100 means opaque, while 0 is completely transparent.
30Autumn_leavesReduce image opacity to 30%.
 
borderbostyleAdd a solid border around the image. The value has a CSS-like format: width_style_color. When using Cloudinary's client integration libraries, you can set the border values programmatically (e.g., :border => { :width => 4, :color => 'black' })
4px_solid_blackAutumn_leavesAdd a 4 pixels wide black border to the image.
3px_solid_rgb:00390bAutumn_leavesAdd a 3 pixels wide border of the color #00390b. When using the client libraries you can set the color parameter to '#00390b' instead of adding 'rgb:00390b'.
6px_solid_rgb:00390b60Autumn_leavesAdd a 6 pixels wide border of a semi transparent RGB color. The last 2 digits are the hex value of the alpha channel.
 
backgroundbcolorDefines the background color to use instead of transparent background areas when converting to JPG format.
blueBadgeFill transparent background with blue.
rgb:9090ffBadgeFill transparent background with the color #9090ff.
 
overlaylidentifierAdd an overlay image over the base image. You can control the dimension and position of the overlay using the width, height, x, y and gravity parameters. The identifier can be a public ID of an uploaded image or a specific image kind, public ID and settings.
badgeFace_topAdd the overlay with the public ID 'badge' 10, 20 pixels from the south east corner of the base image while resizing the overlay to have a width of 30 pixels.
text:default:Hello+WorldFace_topAdd a 'Hello World' text overlay using the 'default' text style that was predefined using our API.
 
underlayuidentifierAdd an underlay image below a base partially-transparent image. You can control the dimensions and position of the underlay using the width, height, x, y and gravity parameters. The identifier can be a public ID of an uploaded image or a specific image kind, public ID and settings.
site_bg.jpgSmartphoneAdd the underlay with the public ID 'site_bg' and 'jpg' format, while resizing the underlay to match the size of the base image.
 
default_imagedidentifierSpecify the public ID of a placeholder image to use if the requested image or social network picture does not exist.
avatar.pngNon_existing_idReturn the image with the 'avatar' public ID if an image with the ID of 'non_existing_id' does not exist. The requested transformations are applied on the placeholder image as well.
 
pagepgnumberGiven a multi-page PDF document, generate an image of a single page using the given index.
2Multi_page_pdfGenerate a JPG thumbnail of the second page of a PDF.
 
densitydndpiControl the density to use while converting a PDF document to images. (range: 50-300, default: 150)
10Multi_page_pdfGenerate a JPG thumbnail using a density of 10.
 
fetch_formatfformatForce format conversion to the given image format for remote 'fetch' URLs and auto uploaded images that already have a different format as part of their URLs.
autoSampleAutomatically convert delivered images to WebP and JPEG-XR on supported browsers to save bandwidth and optimize delivery time.
pngJennifer_lawrence_at_the_83rd_academy_awardsConvert a remote JPG image to the PNG format.
 
flagsflname or namesSet one or more flags that alter the default transformation behavior. Separate multiple flags with a dot ('.').
keep_iptcWithout this flag, Cloudinary's default behavior is to strip all meta-data when generating new image transformations.
attachmentDeliver the image as an attachment. When the image's URL is accessed, tells the browser to save the image instead of embedding it in a page.
relativeModify percentage-based width & height parameters of overlays and underlays (e.g., 1.0) to be relative to the containing image instead of the added layer.
region_relativeModify percentage-based width & height parameters of overlays and underlays (e.g., 1.0) to be relative to the overlaid region. Currently regions are only defined when using gravity 'face' or 'faces'.
progressiveGenerate a JPG image using the progressive (interlaced) JPG format. This format allows the browser to quickly show a low-quality rendering of the image until the full-quality image is loaded.
png8Generate PNG images in the PNG8 format instead of the default PNG24 format.
force_stripTells Cloudinary to clear all image meta-data (IPTC, Exif and XMP) while applying an incoming transformation.
cutterTrim pixels according to the transparency levels of a given overlay image. Whenever the overlay image is opaque, the original is shown, and wherever the overlay is transparent, the result will be transparent as well.
clipTrim pixels according to a clipping path included in the original image (e.g., manually created using PhotoShop).
awebpWhen converting animated GIF images to the WebP format, generate an Animated WebP file instead of the first still frame of the GIF.
layer_applyApply all chained transformations, until a transformation component that includes this flag, on the last added overlay or underlay instead of applying on the the containing image.
ignore_aspect_ratioAllow specifying only either width or height so the value of the second axis remains as is and is not calculated to maintain aspect ratio of the original image.
 
transformationtnameApply a pre-defined named transformation of the given name. When using Cloudinary's client integration libraries, the 'transformation' parameter accepts an array of transformation parameters to be chained together.
media_lib_thumbSampleApply the named 'media_lib_thumb' transformation.