Whether your web or mobile application delivers your organization's own carefully selected images, images uploaded by your end users (UGC), or both, you probably need to adjust the originals to fit the graphic design of your website or mobile application.
Cloudinary's dynamic URL transformations enable you to achieve those goals programmatically and on the fly without the need for graphic designers and fancy editing tools.
You can build these URLs manually in your code, or take advantage of Cloudinary's SDKs, which enable you to write your transformation code using intuitive syntax designed for your preferred programming language or framework and let the SDK automatically build these URLs for you.
Important
Your account's pricing plan is in part dependent on the total number of transformation operations performed during a billing cycle. These are primarily counted when Cloudinary generates a new 'derived resource' from an asset based on a transformation URL. For complete details, see How are transformations counted?
Here are just a few examples of some popular use cases that you can accomplish on the fly by combining Cloudinary transformations. Click each image to see the URL parameters applied in each case:
Convert format, round, change aspect ratio & crop to face, add outlines & shadowsPlace, style, and format image and text layersApply special effects like cartoonify and brightness, rotate to any angle
Cloudinary allows you to easily transform your images on the fly to any required format, style and dimension, and apply effects and other visual enhancements. You can also optimize your images to deliver them with minimal file size alongside high visual quality for an improved user experience and minimal bandwidth. You can do all of this by implementing dynamic image transformation and delivery URLs. Your transformed images are then delivered to your users through a fast CDN with optimized caching.
With image transformations, you can:
Deliver images using the image format that fits your needs.
Resize and crop your images to the required dimensions using different scaling and cropping techniques, or use our smart cropping techniques, including face-detection or auto-gravity for cropping to focus on the most relevant parts of a photo.
Generate a new image by layering other images or text on your base image.
Below you can see the transformation URL and corresponding SDK code for generating an image with several transformation parameters applied. This transformation generates and delivers an image that is initially cropped to a 400x400 image that automatically focusses on the face, then rounded to a circle and finally, scaled down to a width of 200 pixels.
Your Cloudinary media assets are accessed using simple delivery HTTP or HTTPS URLs, which are then delivered to users via a worldwide fast CDN. The URL contains the public ID of the requested asset plus any optional transformation parameters. The public ID is the unique identifier of the asset and is either defined when uploading the asset to your Cloudinary account, or automatically assigned by Cloudinary (see Uploading Assets for more details on the various options for specifying the public ID).
Cloudinary's SDKs automatically build the transformation URL for you. They allow you to continue working in your preferred developer framework and also provide helper methods to simplify building image tags and image transformation URLs.
Tip
You can also create your transformation URLs using the Transformation Editor or new Transformation Builder (Beta). Alternatively, you can take one of our Cookbook recipes as a starting point and then further modify it in the Transformation Editor to fit your needs. The editor and builder generate the URL and SDK code for the transformation you define so that you can copy it in the language you require.
The name of your Cloudinary account, a unique public identifier for URL building and API access.
Note: Paid customers on the Advanced plan or higher can request to use a private CDN or CNAME to customize the domain name used for your delivery URLs.
asset_type
The type of asset to deliver. Valid values: image, video, or raw.
The image type includes still image and photo formats, animated images, PDFs, layered files, such as TIFF and PSD, and others.
The video type includes video and audio files.
The raw type includes any file uploaded to Cloudinary that does not fit in one of the above categories. In general, transformations cannot be performed on raw assets, but they can be delivered as-is for download purposes, or in some cases, they may be used in conjunction with your image or video transformations.
delivery_type
The storage or delivery type. For details on all possible types, see Delivery types.
transformations
Optional. One or more comma-separated transformation parameters in a single URL component, or a set of chained transformations in multiple URL components (separated by slashes). When the transformation URL is first accessed, the derived media file is created on the fly and delivered to your user. The derived file is also cached on the CDN and is immediately available to all subsequent users requesting the same asset.
version
Optional. You can include the version in your delivery URL to bypass the cached version on the CDN and force delivery of the latest asset (in the case that an asset has been overwritten with a newer file). For simplicity, the version component is generally not included in the example URLs on this page. For details, see Asset versions.
public_id
The unique identifier of the asset, including the folder structure if relevant.
extension
Optional. The file extension of the requested delivery format for the asset. Default: The originally uploaded format or the format determined by f_auto, when used.
In the most general case of simply delivering images that were uploaded to your Cloudinary account without any transformations, the delivery URL will be in the format:
The following shows an example of delivering the same image with transformation parameters, where the image is scaled and cropped to fill a 250x300 pixel size and a blurring effect is applied:
//React SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage("sample.jpg")
.resize(fill().width(250).height(300))
.effect(blur().strength(300));
//Angular SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage("sample.jpg")
.resize(fill().width(250).height(300))
.effect(blur().strength(300));
For customers with a Custom Domain Name (CNAME) - available for Cloudinary's Advanced plan and above - the basic image delivery URL becomes: https://<custom domain name>/image/upload....
You can convert and deliver your image in other supported image formats by simply changing the image format file extension. For details, see Delivering in a different format.
You can append an SEO-friendly suffix to your URL by replacing the image/upload element of the URL with images and then appending the desired suffix with a slash (/) after the public ID and before the extension. For example, if you have a cooking image with a random public ID like: abc1def2, you can deliver your image as:
You can also use shortcut URLs when specifically delivering image files using the default upload type. With Cloudinary’s Root Path URL feature, the <asset_type> and <delivery_type> elements can be omitted from the URL (they automatically default to the values image and upload respectively). For example, the Root Path shortcut delivery URL for the cropped image above is:
The delivery type element of the URL provides an indication about the way the asset will be delivered, although in most cases, the delivery type value is determined at the time that the asset is stored in your account.
The following delivery type values are supported:
Delivery type
Description
Learn more
upload
The default delivery type for uploaded assets. In most cases, this delivery type indicates that the asset is publicly available. However, there are options you can use to restrict access to assets with an upload delivery type. This includes strict transformations and access mode settings)
The URL for the original asset can be accessed only with a signed URL. Transformed versions of the asset are publicly available (unless strict transformations are also defined).
Generates a list of assets that have a specified tag. Note: This isn't a delivery type in the classic sense, in that it doesn't relate to an individual asset. However, to use this feature, you specify list in the delivery type element of the URL.
You can search for assets by delivery type using the Advanced Search in the Media Library. The most common types can be selected directly in the Type section of the General search tab. All other types can be selected from the More types list.
Action parameters: Parameters that perform a specific transformation on the asset.
Qualifier parameters: Parameters that do not perform an action on their own, but rather alter the default behavior or otherwise adjust the outcome of the corresponding action parameter.
It's best practice to include only one action parameter per URL component.
If you want to apply multiple actions in a single transformation URL, apply them in separate chained components, where each action is performed on the result of the previous one.
Note
In some of the Cloudinary SDKs, this action separation rule is enforced.
In contrast, qualifier parameters must be included in the component with the action parameter they qualify.
Most qualifiers are optional, meaning the related action parameter can be used independently, but you can add optional qualifiers to modify the default behavior.
In some cases, an action parameter requires one or more qualifiers to fully define the transformation behavior.
There are a few parameters that can be used independently as action parameters, but can also be used in other scenarios as a qualifier for another action.
For example, the transformation below includes a crop action, a rounding action, and 2 effect actions. The qualifier transformations included in each action define additional adjustments on the transformation action's behavior:
The URL tab above shows the URL as it looks when generated by an SDK. SDKs always generate the parameters within a specific URL component in alphabetical order (thus some qualifiers in the URL may come before the action that they qualify).
Transformation flags alter default transformation behavior. In some cases, they alter the default behavior of the transformation URL as a whole. In other cases, they alter the behavior of one or more specific transformation parameters that must be used together in the same URL component.
In general, tens of flags are available that can alter delivery and format, cropping and positioning, overlays, metadata and color profiles, as well as PDF and text behaviors, just to name a few.
For example:
fl_attachment alters the normal behavior of the overall transformation. Instead of delivering an asset in a web page, it causes the transformed media file to be downloaded as an attachment. This flag can be used independently of other transformations.
fl_relative modifies the way overlay resize parameters are evaluated. This flag can only be used in conjunction with the overlay (l_) parameter.
fl_layer_apply tells Cloudinary to apply all chained transformations, until a transformation component that includes this flag, on the last added overlay or underlay asset instead of applying them on the base asset. This flag acts as an indictor to close the layer section of the transformation, similar to a closing bracket. Placement definitions for how the layer should be applied, such as gravity and offsets are also defined in the component with this flag.
For details on all available transformation flags, see the flag section of the Transformation Reference.
For backward compatibility reasons, many of Cloudinary's earlier SDK major versions generate http URLs by default. When using one of these SDKs, you can instruct the SDK to generate https URLs by setting the secure parameter to true, either globally as part of your SDK configuration, or locally in each transformation operation. For example, delivering the sample image with HTTPS:
Some transformation parameters with multiple options offer two alternative syntaxes for defining the option values:
Verbose, unordered: Each option of the transformation (whether required or optional) is specified in the verbose format name_value and each option is separated by a colon (:) or semi-colon (;) depending on the transformation.
The options can be specified in any order, and you only need to include those that you want (or are required) to define.
With this syntax, you can also choose to specify only the options for which you don't want to use default values and default values will be applied for the others.
Non-verbose, ordered: Transformation options are specified only by values, and must be entered in the pre-defined option order for that transformation. All values from the syntax to the left of the value you want to supply must also be entered.
Transformations that support both verbose and non-verbose URL syntax are indicated as such in the Transformation Reference. When both are supported, SDKs always output the verbose syntax.
The theme effect supports the color and photosensitivity options, but you can specify them in a different order using verbose syntax. For example:
e_theme:photosensitivity_110:color_black
However, when using non-verbose syntax, you must specify the parameters in order. Therefore, even if you only want to change the default behavior of the photosensitivity (last) option, you must still specify the value to use for the color (first) option:
Cloudinary supports powerful transformations that are applied on the fly using dynamic URLs. You can combine multiple transformation actions together as part of a single delivery request, e.g., crop an image and then add a border to it.
In general, it's best practice to chain each transformation action in your URL as a separate component in the chain.
To support chained transformations, Cloudinary's transformation URLs allow you to include multiple transformation components, each separated by a slash (/), where each of the transformation components is executed on the result of the previous one. Cloudinary's SDKs can apply multiple transformation components by specifying the transformation parameter and setting it to an array of transformation maps.
Examples with the uploaded JPG image named flower:
Two chained transformations: fill to a 150px square and then round to a circle:
Four chained transformations: crop to 150x100 with a custom offset from the center, fill crop to 130x100, rotate by 20 degrees, and then scale down to 80%:
//React SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage("flower.jpg")
.resize(crop().width(150).height(100).x(380).y(250))
.resize(fill().width(130).height(100))
.rotate(byAngle(20))
.resize(scale().width(0.8));
//Angular SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage("flower.jpg")
.resize(crop().width(150).height(100).x(380).y(250))
.resize(fill().width(130).height(100))
.rotate(byAngle(20))
.resize(scale().width(0.8));
A named transformation is a pre-defined set of transformation parameters that has been given a custom name for easy reference. Instead of applying each of the required transformations separately to an asset, you can apply a single named transformation to apply all the transformations defined for it. This makes it easy to:
Reuse transformations on multiple assets
Shorten complex transformation URLs
Hide the details of a transformation in your delivery URL.
Named transformations can include other named transformations, which allows you to define a chain of transformations to run on multiple assets more easily.
Once the named transformation has been defined, you can transform an asset with the transformation parameter (t for URLs) and the name of your named transformation. For example t_instagram-auto-crop.
You can include user-defined variables in your named transformations, and then pass the value for the user-defined variable into the transformation from an external source. This enables creating a named transformation 'template' with a lot of flexibility.
For example, you could define a complex named transformation that includes a text overlay as a named transformation, using a user-defined variable for the text string value.
You can also set named transformations as transformation presets, which enables you to preview how assets from your Media Library will look with different named transformations applied.
Keep in mind that named transformation may be applied to assets by other users and not all asset formats are supported for transformations. If an asset's original format doesn't support transformations, applying a named transformation to it will result in an error. See a list of supported image formats.
Note
Updating the transformation definition for a named transformation via the Admin API does not automatically update assets that were already derived/delivered with that named transformation. To apply the new definition to any already derived assets that use that named transformation, you must specifically invalidate those transformations or otherwise modify the other parameters in that delivery URL, so that the asset will be re-derived using the new definition.
However, when updating the transformation definition of a named transformation via the Management Console, if the named transformation is used in fewer than 1000 existing derived assets, those assets are automatically invalidated and will use the new named transformation definition the next time they are requested. If more than 1000 existing derived assets use the named transformation, then existing derived assets are not updated and only newly generated derived assets will use the new definition.
You can create a named transformation programmatically or using the Transformations UI in your Cloudinary console:
To create a named transformation programmatically, use the Transformations Admin API method. The following example defines a named transformation called small_profile_thumbnail that uses automatic cropping to resize assets to the required size for a particular application's thumbnail display:
api.createTransformation("small_profile_thumbnail",
new Transformation().width(150).height(100).crop("fill").gravity("auto").generate(),
ObjectUtils.emptyMap());
.NET (CloudinaryDotNet 1.x):
Copy to clipboard
var createTransformParams = new CreateTransformParams(){
Name = "small_profile_thumbnail",
Transformation = new Transformation().Width(100).Height(150).Crop("fill").Gravity("auto")};
cloudinary.CreateTransform(createTransformParams);
Must not contain any of these characters: \, /, ?, &, #, %, ., ,, <, >
Once you've saved your named transformations, you can view a list of them on the Named Transformations page of the console. From here, you can edit, copy, or enable/disable Strict Transformations.
The Cloudinary Transformation Builder is a brand new UI designed to help you create and save your transformations in a simple and easy to use way. Here's some of the features and functionality you can get by using the builder:
Simple and intuitive UI for selecting and configuring transformation actions - easily discover actions and parameters as you build.
Transformations built as a series of self-contained actions so you can see the results of each one as you apply it.
URL and SDK code ready to copy and paste directly to your code.
Ability to update the default preview image to something from your own Media Library.
The builder has support for most common transformation actions. If the transformation action you are trying to apply is not listed, you can add an "Additional Transformation" action and use transformation URL syntax to specify your transformation. Alternatively, you can switch to the legacy editor to create your transformation.
Important
The Transformation Builder is currently in Beta. Some implementation details may change before the official release. The builder is enabled for all new customers. Follow the instructions below to check if it's available to you. If you don't have it enabled and would like access to the Beta, send us a support request and we will enable it for you.
To create a new transformation and verify you have access to the Transformation Builder, head to the transformations page and click Add New. If enabled, you should see the new transformation builder UI where you can start adding actions and building up your transformation. For a taste of what to expect, have a look at the screenshot below:
To create a transformation that applies additional transformations to the jpg_with_quality_30 named transformation, such as fitting it to a 100 pixel width and a 50 pixel height:
//React SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage("sample.jpg")
.namedTransformation(name("jpg_with_quality_30"))
.resize(fit().width(100).height(50));
//Angular SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage("sample.jpg")
.namedTransformation(name("jpg_with_quality_30"))
.resize(fit().width(100).height(50));
new CloudinaryImage("sample.jpg")
.namedTransformation(name("jpg_with_quality_30"))
.namedTransformation(name("crop_400x400"))
.namedTransformation(name("fit_100x150"));
//React SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage("sample.jpg")
.namedTransformation(name("jpg_with_quality_30"))
.namedTransformation(name("crop_400x400"))
.namedTransformation(name("fit_100x150"));
//Angular SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage("sample.jpg")
.namedTransformation(name("jpg_with_quality_30"))
.namedTransformation(name("crop_400x400"))
.namedTransformation(name("fit_100x150"));
Chaining transformations can create long URLs, so instead you could define a named transformation that includes a chain of other transformations, including other named transformations. For example, we can create a named transformation that is a composite of the three named transformations described above. It is now simple to specify a single named transformation instead:
You access uploaded images or their derived transformations with URLs. These URLs can be used as the <src> of the <img> tags in your HTML code or other frontend functions to deliver your media assets.
But the easiest way to deliver them is using Cloudinary’s framework SDKs to automatically generate transformation URLs and embed them using HTML image tags. The SDKs offer two main helper methods: the URL helper and the image tag helper.
The Cloudinary URL helper method (e.g., cloudinary_url in Ruby on Rails) automatically generates the image source URL itself. For example, using the URL helper method to return the URL of the sample image, padded to a scaled width and height of 300 pixels with a blue background for the padding:
//React SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage("sample.jpg").resize(
pad()
.width(300)
.height(300)
.background(color("blue"))
);
//Angular SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage("sample.jpg").resize(
pad()
.width(300)
.height(300)
.background(color("blue"))
);
By default, the Cloudinary image tag helper method (e.g., cl_image_tag in Ruby on Rails) automatically generates an HTML image tag including the image source URL.
The following shows the same transformations as above, but this time using the image tag to generate a complete HTML image tag.
The Cloudinary Image Tag helper method allows you to not only specify any Cloudinary transformations parameters, but also to specify regular HTML image tag attributes (e.g., alt, title, width, height). For example, using the Image Tag helper method to create an HTML image tag for the sample image, with the 'alt' attribute set to "A sample photo" and the 'className' attribute set to "Samples":
@Model.Cloudinary.Api.UrlImgUp.BuildImageTag("sample.jpg", new CloudinaryDotNet.StringDictionary("alt=A sample photo", "className=Samples"));
Go (cloudinary-go 1.x):
Copy to clipboard
Not supported by this SDK
For more information on these SDK helper methods, see the transformation documentation in the relevant SDK guide.
Tip
In general, when using an SDK, you will probably take advantage of the SDK parameter names for improved readability and maintenance of your code. However, you can also optionally pass a raw transformation parameter, whose value is a literal URL transformation definition. Note that the string you pass as the raw transformation value will be appended as is (with no processing or validation) to the end of any other transformation parameters passed in the same component of the transformation chain.
Images can be uploaded to Cloudinary in various formats (input formats), and you can easily convert these images to other formats for displaying in your web site or application (output formats). Examples of situations where you might want to change the delivered image format:
Delivering JPEGs for photos that you want to load quickly (or AVIF or WebP if your users are on a browser that supports these or on a mobile app you control).
Delivering a PNG (24 bit) for high quality illustrations with a transparent background.
Delivering an image where the original format is not supported for delivery by the browser. For example, you could deliver a Photoshop (.psd) image as a JPG.
You can convert and deliver images in a different format by specifying the required format as the file extension of the delivery URL. 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, to display a GIF version of the uploaded sample JPEG file:
You can combine other image transformations with format conversion. Just make sure the format you use is supported for transformations, as per the Supported image formats table. For example, to deliver a scaled down 150x100 GIF version of the sample image:
Another option for changing the format is to explicitly call the fetch_format transformation parameter (f in URLs). This can be useful in situations where you cannot change the file extension, for example, when fetching remote images that already have a different file extension (format) as part of their URLs.
For example, to fetch a remote image from Wikimedia in PNG format, and deliver the image in JPG format (also scaled down to a width of 400 pixels):
//React SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage(
"https://upload.wikimedia.org/wikipedia/commons/1/13/Benedict_Cumberbatch_2011.png"
)
.resize(scale().height(400))
.delivery(format(jpg()))
.setDeliveryType("fetch");
//Angular SDK transformations are created using @cloudinary/url-gen.new CloudinaryImage(
"https://upload.wikimedia.org/wikipedia/commons/1/13/Benedict_Cumberbatch_2011.png"
)
.resize(scale().height(400))
.delivery(format(jpg()))
.setDeliveryType("fetch");
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).
When converting from one multi-page or multi-layer image format (PDF, GIF, WebP, TIFF, PSD) to another, only the first 100 pages are included in the new file.
SDK major versions with initial release later than January 2020 have a format transformation parameter, instead of the fetch_format parameter. See f (format) in the transformation reference.
You can take advantage of Cloudinary's automatic format selection (f_auto) transformation to automatically deliver images in the most optimized format that's supported by the requesting browser.
For example, if you deliver a JPG image with f_auto, Cloudinary might generate and deliver the image as a WebP, AVIF or JPEG-2000 file, depending on the requesting browser and your account settings. The f_auto algorithm will similarly deliver the best format when the original asset is a PNG (with or without transparency), an animated GIF, etc.
If a format is supported only 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 a format is supported for transformations, but the browser doesn't support displaying that format, you can either provide the transformation URL with the original format to enable users to download the file, or you can provide the URL with a different delivery format specified. In that case, Cloudinary applies the transformation to the original format and then converts the image to the requested format for delivery. For example, you could provide a transformation URL for a PhotoShop (.psd) image stored in your account and specify jpg as the delivery format to display the resulting transformation in the browser.
You can transform an InDesign file if you deliver it as an image format, such as jpg or png, but you cannot deliver an indd file with transformations.
By default, when you request a jp2 image with a quality value less than 90, chroma sub-sampling (420) is automatically applied using Kakadu. You can also explicitly request chroma sub-sampling as part of your quality parameter. For example: q_90>:420.
All layers are flattened into a single image if no page parameter is specified.
The 3D format types are uploaded as a zip file. Some transformations, such as converting to a video or image, are supported on the bundle as a whole. No transformations are currently supported on its contained assets. For further information see Transformations on 3D models.
Transformations cannot be applied to USDZ files, but you can deliver any uploaded 3D model as a USDZ file.
Images converted to AVIF from other formats use additional quota. Images exceeding 9 megapixels cannot be encoded to AVIF - ensure you scale them down first. If enabled, AVIF may be delivered when automatic format selection (f_auto) is used.
This page walked you through the basics of how image transformations work. The rest of the pages in this guide provide details, use cases and examples of the many different types of transformations you can apply to the images you deliver:
Create animated images from multiple images in your account, convert them to video, convert between animated formats, and apply animation-specific transformations.
In addition to changing the appearance of your media assets by transforming them, you can also use Cloudinary URLs and a variety of parameters to control how they are delivered:
Deliver your media assets with the smallest possible file size while maintaining visual quality, saving bandwidth and improving performance for your website. This includes automatic quality and format selection optimizations (q_auto and f_auto).
Deliver your images to perfectly fit any device, window size, orientation, or resolution at any pixel density (DPR). Upload a single high resolution image and let Cloudinary automatically transform it.
Grab media assets from anywhere on the web or pull social media profile pictures from a variety of popular social media networks, including support for on-the-fly transformation and optimized delivery via a CDN.
Deliver content from assets with multiple pages or layers such as PDFs or Photoshop files, including options for delivering or transforming only selected pages or layers.
Control who can access your media, both the originals and transformed assets, including enabling strict transformations, using signed delivery URLs, uploading images as private or authenticated, and using access_control or access_mode to control who can access an asset without adjusting the URL.
Take advantage of advanced options that make your URLs more SEO-friendly, deliver assets using private CDNs or multi-CDN solutions, use custom domain names (CNames) for your URLs, define custom favicons, work with asset versions, and more.
Related topics
While learning about transformations, you may also want to check out:
Transformation URL API Reference: Details all available transformation parameters. Icons indicate which parameters are supported for each asset type.
Video transformations guide: Provides details and examples of the transformations you can apply to video assets.
Convert format, round,
Place, style, and format
Apply special effects like 
Original
