Admin API reference

The Admin API is a rate-limited API that provides full control of all uploaded media assets (resources), fetched social profile pictures, generated transformations and more.

On this page:

API Overview
Resources
Transformations
Upload mappings
Upload presets
Metadata
Folders
Adaptive streaming profiles
Tags
Usage
Ping

API Overview

The Admin API endpoints are accessed using HTTPS. By default, the API endpoints use the following format:

https://api.cloudinary.com/v1_1/:cloud_name/:action

For example, to list all video assets in the 'demo' account:

GET https://api.cloudinary.com/v1_1/demo/resources/video

The API uses Basic Authentication over secure HTTP. Your Cloudinary API Key and API Secret (which can be found on the Dashboard page of your Cloudinary console) are used for the authentication.

You can experiment with returning a list of the images on your own Cloudinary account by replacing the API_KEY, API_SECRET, and CLOUD_NAME in the cURL command below:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/resources/image

For most actions, request parameters are appended to the URL. In a few cases, they are passed as JSON objects. The response is in a JSON snippet. The response includes information about the action that was performed as well as data about the relevant assets.

The following sections provide additional details on working with the Admin API:

Using SDKs with the Admin API
Using the CLI to access the Admin API
Error handling
Usage limits
Pagination
Alternative data centers and endpoints (premium feature)

Using SDKs with the Admin API

Our backend SDK libraries provide a wrapper for the Admin API, enabling you to use your native programming language of choice. When using an SDK, request building and authentication are handled automatically, and the JSON response is parsed and returned.

For example, you can use the following SDK command to return a listing of all image (the default resource_type) assets:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources

PHP (cloudinary_php v1.x (legacy)):

$api->resources();

Library:

PHP (cloudinary_php v2.x):

$api->assets();

Library:

Python:

cloudinary.api.resources()

Node.js:

cloudinary.v2.api.resources(
function(error, result) {console.log(result, error); });

Java:

api.resources(ObjectUtils.emptyMap());

.NET:

cloudinary.ListResources();

Go:

resp, err := cld.Admin.Assets(ctx, admin.AssetsParams{})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources

CLI:

cld admin resources

Using the CLI to access the Admin API

You can use the Cloudinary CLI (Command Line Interface) to interact with the admin API. This can provide an easy way to add automation to your workflows and manage your assets without the need for a formal coding environment or having to access your management console.

You can find instructions for setting up and using the CLI in the CLI reference.

Error handling

The Admin API returns the status of requests using HTTP status codes:

200: OK | Success.
400: Bad request.
401: Authorization required.
403: Not allowed.
404: Not found.
409: Already exists.
420: Rate limited.

The SDKs report errors by raising applicative exceptions. Additionally, an informative JSON message is returned. For example:

{ "error": { "message": "Resource not found - 5traNge_nam3" } }

Usage limits

You can use the Admin API quite extensively, but it is a rate limited API. The specific limits depend on the plan your account is registered to. If you require more flexible limits, don’t hesitate to contact us.

Note

This limit refers only to Admin API requests, and not to requests that use the Upload API, which is not rate-limited. In some cases, you may be able to use certain methods of the Upload API to achieve some administration goals. For example, you can modify or remove tags for one or multiple resources using the tags method. You can modify many attributes of an individual resource using the explicit method, and you can return most details about a single (original) resource in response to any upload or explicit method call.

For each Admin API call, standard HTTP headers are returned with details on your current usage statistics, including your per-hour limit, remaining number of actions and the time the hourly count will be reset.

The header might look something like this:

X-FeatureRateLimit-Limit: 500
X-FeatureRateLimit-Remaining: 499
X-FeatureRateLimit-Reset: Wed, 03 Oct 2012 08:00:00 GMT

You can use the SDKs to retrieve this data as follows:

Ruby PHP Python Node.js Java .NET Go All

Ruby:

result = Cloudinary::Api.resources
result.rate_limit_allowed
=> 500
$ result.rate_limit_remaining
=> 499
$ result.rate_limit_reset_at
=> 2019-10-03 10:00:00 +0200

PHP (cloudinary_php v1.x (legacy)):

$result = $api->assets();
var_dump($result->rate_limit_allowed);
php > int(500)
var_dump($result->rate_limit_remaining);
php > int(499)
var_dump($result->rate_limit_reset_at);
php > int(1570089600)

Library:

PHP (cloudinary_php v2.x):

$result = $api->assets();
var_dump($result->rateLimitAllowed);
php > int(500)
var_dump($result->rateLimitRemaining);
php > int(499)
var_dump($result->rateLimitResetAt);
php > int(1570089600)

Library:

Python:

result = cloudinary.api.resources()
result.rate_limit_allowed
>>>500
result.rate_limit_remaining
>>>499
result.rate_limit_reset_at
>>>(2019, 10, 3, 08, 0, 0, 0, 1, -1)

Node.js:

cloudinary.v2.api.resources(
function(error, result) {
  console.log(result.rate_limit_allowed,
              result.rate_limit_remaining,
              result.rate_limit_reset_at);
});

> 500 499 Sun, 03 Oct 2019 08:00:00 GMT

Java:

ApiResponse result = api.resources(ObjectUtils.emptyMap());
System.out.println(result.apiRateLimit().getLimit());
=> 500
System.out.println(result.apiRateLimit().getRemaining());
=> 499
System.out.println(result.apiRateLimit().getReset());
=> 2019-10-03 10:00:00 +0200

.NET:

var result = cloudinary.ListResources();
result.Limit
// returns 500
result.Remaining
// returns 499
result.Reset
//returns  2019-10-03 10:00:00 +0200

Go:

Not supported by this SDK

Tip

You can also retrieve rate limits details as well as transformation, bandwidth, and storage limits, and a variety of additional account usage data with the GET /usage method.

Pagination

The GET methods of the API return a limited set of results, ordered by the creation time of the relevant entities. You can control the number of results returned in a single request by specifying the max_results parameter. The default is 10 for most methods. There is also a maximum number of results you can request for a single API call (either 100 or 500 as documented for each of the relevant methods). DELETE methods also operate in chunks.

When a GET request has more results to return than max_results or when a DELETE request has more than 1000 entities to delete, the next_cursor value is returned as part of the response. You can then specify this cursor value as the next_cursor parameter of the following GET or DELETE request. For example, this enables you to iterate through the full list of uploaded resources, transformations, or tags in your Cloudinary account or to delete an entire set of entities that matches your deletion request.

Alternative data centers and endpoints (premium feature)

By default, Cloudinary accounts use US-based data centers. In these cases, the endpoint format is as shown at the beginning of this Overview.

If the majority of your users are located in Europe or Asia, Cloudinary can set up your account to use our Europe (EU) or Asia Pacific (AP) data center. In that case, your endpoints will take the form:

https://api-eu.cloudinary.com/v1_1/:cloud_name/:action

https://api-ap.cloudinary.com/v1_1/:cloud_name/:action

Note

This is a premium feature that is supported only for our Custom plans and must be arranged when the account is created. Contact support for more information.

Resources

Enables you to manage all the resources (assets) stored in your account.

Method	Description
GET`/resources/:resource_type(/:type)`	Get resources
GET`/resources/:resource_type/tags/:tag`	Get resources by tag
GET`/resources/:resource_type/context/`	Get resources by context
GET`/resources/:resource_type/moderations/:moderation_kind/:status`	Get resources in moderation queues
GET`/resources/:resource_type/:type/:public_id`	Get the details of a single resource
GET`/resources/search`	Search for resources
POST`/resources/:resource_type/:type/:public_id`	Update details of an existing resource
POST`/resources/:resource_type/:type/restore`	Restore resources
POST`/resources/:resource_type/upload/update_access_mode`	Update access mode
DELETE`/resources/:resource_type/:type`	Delete resources
DELETE`/resources/:resource_type/tags/:tag`	Delete resources by tags
DELETE`/derived_resources`	Delete derived resources

Get resources

Lists resources (assets) uploaded to your account.

Syntax

GET /resources(/:resource_type)(/:type)

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.resources(options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->resources($options = []);

Library:

PHP (cloudinary_php v2.x):

$api->assets($options = []);

Library:

Python:

cloudinary.api.resources(**options)

Node.js:

cloudinary.v2.api.resources(options, callback);

Java:

api.resources(Map options);

.NET:

cloudinary.ListResources(ListResourceParams params);

Go:

resp, err := cld.Admin.Assets(ctx, admin.AssetsParams{})

CLI:

cld admin resources

Optional parameters

Parameter	Type	Description
resource_type	String	The type of asset. Relevant as a parameter only when using the SDKs (the `resource_type` is included in the endpoint URL when using the REST API). Note: use `video` for all video and audio assets, such as .mp3. Possible values: `image` (default), `raw`, `video`.
type	String	The delivery type, relevant as a parameter only when using the SDKs (the `type` is included in the endpoint URL when using the REST API). Possible values: `upload`, `private`, `authenticated`, `facebook`, `twitter`, `gravatar`, `youtube`, `hulu`, `vimeo`, `animoto`, `worldstarhiphop`, `dailymotion`. Default: all.
prefix	String	Find all assets with a public ID that starts with the given prefix. The assets are sorted by public ID in the response. Note: use this parameter to find public IDs with a `+` character in them.
public_ids	String[]	An array of public IDs. Get assets with the given public IDs (up to 100). Note: Not supported for SDKs. Instead use the `resources_by_ids` SDK method. This parameter does not support public IDs with a `+` character in them (use the `prefix` parameter to find the assets instead).
max_results	Integers	Maximum number of assets to return (up to 500). Default: `10`.
next_cursor	String	When a request has more results to return than `max_results`, the `next_cursor` value is returned as part of the response. You can then specify this value as the `next_cursor` parameter of a following request.
start_at	String	Get assets that were created since the given timestamp (ISO 8601 format). Supported unless `prefix` or `public_ids` were specified. For example: `2020-12-01`
direction	String/Integer	Control the order of returned assets, according to the `created_at` date. Note: if a `prefix` is specified, this parameter is ignored and the results are sorted by public ID. Possible values: `desc` or `-1` (default), `asc` or `1`.
tags	Boolean	Whether to include the list of tag names assigned to each asset. Default: `false`.
context	Boolean	Whether to include key-value pairs of contextual metadata associated with each asset. Default: `false`.
moderation	Boolean	Whether to include the image moderation status of each asset. Default: `false`.
metadata	Boolean	Whether to include the metadata fields and values set for each asset. Default: `false`.

Examples

Get all images:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources

PHP (cloudinary_php v1.x (legacy)):

$api->resources();

Library:

PHP (cloudinary_php v2.x):

$api->assets();

Library:

Python:

cloudinary.api.resources()

Node.js:

cloudinary.v2.api.resources(
  function(error, result) {console.log(result, error); });

Java:

api.resources(ObjectUtils.emptyMap());

.NET:

cloudinary.ListResources();

Go:

resp, err := cld.Admin.Assets(ctx, admin.AssetsParams{})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image

CLI:

cld admin resources

Get uploaded images, up to a maximum of 30 results:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources(
  :type => :upload,
  :max_results => 30)

PHP (cloudinary_php v1.x (legacy)):

$api->resources(
  ["type" => "upload", "max_results" => 30]);

Library:

PHP (cloudinary_php v2.x):

$api->assets(
  ["type" => "upload", "max_results" => 30]);

Library:

Python:

cloudinary.api.resources(type = "upload", max_results = 30)

Node.js:

cloudinary.v2.api.resources(
  { type: 'upload', max_results: 30 }, 
  function(error, result) {console.log(result, error); });

Java:

api.resources(
  ObjectUtils.asMap("type", "upload", "max_results", 30));

.NET:

var listResourcesParams = new ListResourcesParams(){
  Type = "upload",
  MaxResults = 30};
var listResourcesResult = cloudinary.ListResources(listResourcesParams);

Go:

resp, err := cld.Admin.Assets(ctx, admin.AssetsParams{
        DeliveryType:   "upload",
        MaxResults:     30})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload

CLI:

cld admin resources type=upload

Get all uploaded images with a given prefix:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources(
:type => :upload, 
:prefix => "sample")

PHP (cloudinary_php v1.x (legacy)):

$api->resources([
  "type" => "upload", 
  "prefix" => "sample"]);

Library:

PHP (cloudinary_php v2.x):

$api->assets([
  "type" => "upload", 
  "prefix" => "sample"]);

Library:

Python:

cloudinary.api.resources(
type = "upload", 
prefix = "sample")

Node.js:

cloudinary.v2.api.resources(
{ type: 'upload', 
  prefix: 'sample' }, 
function(error, result) {console.log(result, error); });

Java:

api.resources(
ObjectUtils.asMap(
  "type", "upload", 
  "prefix", "sample"));

.NET:

var listResourcesByPrefixParams = new listResourcesByPrefixParams(){
  Type = "upload",
  Prefix = "sample"};
var listResourcesResult = cloudinary.ListResources(listResourcesByPrefixParams);

Go:

resp, err := cld.Admin.Assets(ctx, admin.AssetsParams{
        DeliveryType: "upload",
        Prefix:       "sample"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload?prefix=sample

CLI:

cld admin resources type=upload prefix=sample

Get Facebook images:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources(:type => :facebook)

PHP (cloudinary_php v1.x (legacy)):

$api->resources(["type" => "facebook"]);

Library:

PHP (cloudinary_php v2.x):

$api->assets(["type" => "facebook"]);

Library:

Python:

cloudinary.api.resources(type = "facebook"))

Node.js:

cloudinary.v2.api.resources(
  { type: 'facebook' }, 
  function(error, result) {console.log(result, error); });

Java:

api.resources(
  ObjectUtils.asMap("type", "facebook"));

.NET:

var listResourcesParams = new ListResourcesParams(){
  Type = "facebook"};
var listResourcesResult = cloudinary.ListResources(listResourcesParams);

Go:

resp, err := cld.Admin.Assets(ctx, admin.AssetsParams{
        DeliveryType: "facebook"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/facebook

CLI:

cld admin resources type=facebook

Get raw uploaded files:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources(
  :resource_type => :raw)

PHP (cloudinary_php v1.x (legacy)):

$api->resources(["resource_type" => "raw"]);

Library:

PHP (cloudinary_php v2.x):

$api->assets(["resource_type" => "raw"]);

Library:

Python:

cloudinary.api.resources(resource_type = "raw")

Node.js:

cloudinary.v2.api.resources(
  { resource_type: 'raw' }, 
  function(error, result) {console.log(result, error); });

Java:

api.resources(
  ObjectUtils.asMap("resource_type", "raw"));

.NET:

var listResourcesParams = new ListResourcesParams(){
  ResourceType = "raw"};
var listResourcesResult = cloudinary.ListResources(listResourcesParams);

Go:

resp, err := cld.Admin.Assets(ctx, admin.AssetsParams{
        AssetType:    "raw",
        DeliveryType: "upload"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/raw

CLI:

cld admin resources resource_type=raw

Get all uploaded images with the given IDs:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

resources_by_ids
Cloudinary::Api.resources_by_ids(["user_photo_1", "user_photo_2"])

PHP (cloudinary_php v1.x (legacy)):

$api->resources_by_ids(["user_photo_1", "user_photo_2"]);

Library:

PHP (cloudinary_php v2.x):

$api->assetsByIds(["user_photo_1", "user_photo_2"]);

Library:

Python:

cloudinary.api.resources_by_ids(["user_photo_1", "user_photo_2"])

Node.js:

cloudinary.v2.api.resources_by_ids(["user_photo_1", "user_photo_2"],
  function(error, result) {console.log(result, error); });

Java:

api.resources_by_ids(Arrays.asList("user_photo_1", "user_photo_2"),
  ObjectUtils.emptyMap());

.NET:

var publicIds = new List<string>(){"user_photo_1", "user_photo_2" };
cloudinary.ListResourceByPublicIds(publicIds);

Go:

resp, err := cld.Admin.AssetsByIDs(ctx, admin.AssetsByIDsParams{
      DeliveryType: "upload",
      PubicIDs:     []string{"user_photo_1", "user_photo_2"}})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload?public_ids[]=user_photo_1&public_ids[]=user_photo_2

CLI:

cld admin resources_by_ids user_photo_1,user_photo2

Sample response

{
  "resources": [
    {
      "asset_id": "b1ce1d159bc3696e5a74d8b8aefbe707",
      "public_id": "face_center",
      "format": "jpg",
      "version": 1333013579,
      "resource_type": "image",
      "type": "upload",
      "created_at": "2012-03-29T09:32:59Z",
      "bytes": 128891,
      "width": 283,
      "height": 424,
      "backup": true,
      "access_mode": "public",
      "url": "http://res.cloudinary.com/demo/image/upload/v1333013579/face_center.jpg",
      "secure_url": "https://.../image/upload/v1333013579/face_center.jpg"
    },
    {
      "asset_id": "835d1cf89bd7c1b84dc4f53d35bc235f",
      "public_id": "12208495",
      "format": "jpg",
      "resource_type": "image",
      "type": "facebook",
      "created_at": "2012-10-06T17:18:52Z",
      "bytes": 0,
      "access_mode": "public",
      "url": "http://res.cloudinary.com/demo/image/facebook/12208495.jpg",
      "secure_url": "https://.../image/facebook/12208495.jpg"
    },
  ]
}

Get resources by tag

Lists resources (assets) with a specified tag. This method does not return deleted assets even if they have been backed up.

Tip

You can also return a JSON listing of resources (assets) by tag in your front-end code using the client-side asset lists delivery option.

Syntax

GET /resources/:resource_type/tags/:tag

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.resources_by_tag(tag, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->resources_by_tag($tag, $options = []));

Library:

PHP (cloudinary_php v2.x):

$api->assetsByTag($tag, $options = []);

Library:

Python:

cloudinary.api.resources_by_tag(tag, **options)

Node.js:

cloudinary.v2.api.resources_by_tag(tag, options, callback);

Java:

api.resourcesByTag(String tag, Map options);

.NET:

cloudinary.ListResourcesByTag(ListResourcesByTagParams params);

Go:

resp, err := cld.Admin.AssetsByTag(ctx, admin.AssetsByTagParams{})

CLI:

cld admin resources_by_tag (tag)

Required parameters

Parameter	Type	Description
tag	String	The assets to return that have this tag.

Optional parameters

Parameter	Type	Description
resource_type	String	The type of asset. Relevant as a parameter only when using the SDKs (the `resource_type` is included in the endpoint URL when using the REST API). Note: use `video` for all video and audio assets, such as .mp3. Possible values: `image` (default), `raw`, `video`.
max_results	Integer	Maximum number of assets to return (maximum=500). Default: `10`.
next_cursor	String	When a request has more results to return than `max_results`, the `next_cursor` value is returned as part of the response. You can then specify this value as the `next_cursor` parameter of the following request.
direction	String/Integer	Control the order of returned assets, according to the `created_at` date. Note: if a `prefix` is specified, this parameter is ignored and the results are sorted by public ID. Possible values: `desc` or `-1` (default), `asc` or `1`.
tags	Boolean	Whether to include the list of tag names assigned to each asset. Default: `false`.
context	Boolean	Whether to include key-value pairs of contextual metadata associated with each asset. Default: `false`.
moderations	Boolean	Whether to include image moderation status of each asset. Default: `false`.
metadata	Boolean	Whether to include the metadata fields and values set for each asset. Default: `false`.

Examples

Get all images by tag:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources_by_tag('mytag')

PHP (cloudinary_php v1.x (legacy)):

$api->resources_by_tag("mytag");

Library:

PHP (cloudinary_php v2.x):

$api->assetsByTag("mytag");

Library:

Python:

cloudinary.api.resources_by_tag("mytag")

Node.js:

cloudinary.v2.api.resources_by_tag("mytag", 
  function(error, result) {console.log(result, error); });

Java:

api.resourcesByTag("mytag", ObjectUtils.emptyMap());

.NET:

cloudinary.ListResourcesByTag("mytag");

Go:

resp, err := cld.Admin.AssetsByTag(ctx, admin.AssetsByTagParams{Tag: "mytag"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/tags/mytag

CLI:

cld admin resources_by_tag mytag

Get all raw files by tag:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources_by_tag('mytag',
  :resource_type => :raw)

PHP (cloudinary_php v1.x (legacy)):

$api->resources_by_tag("mytag", ["resource_type" => "raw"]);

Library:

PHP (cloudinary_php v2.x):

$api->assetsByTag("mytag", ["resource_type" => "raw"]);

Library:

Python:

cloudinary.api.resources_by_tag("mytag",
resource_type = "raw")

Node.js:

cloudinary.v2.api.resources_by_tag("mytag", 
  { resource_type: 'raw'},
  function(error, result) {console.log(result, error); });

Java:

api.resourcesByTag("mytag", 
  ObjectUtils.asMap("resource_type", "raw"));

.NET:

var listResourcesParams = new ListResourcesByTagParams(){
  Tag = "mytag",
  ResourceType = "raw"};
var listResourcesResult = cloudinary.ListResources(ListResourcesByTagParams);

Go:

resp, err := cld.Admin.AssetsByTag(ctx, admin.AssetsByTagParams{
        Tag:          "mytag",
        DeliveryType: "raw"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/raw/tags/mytag

CLI:

cld admin resources_by_tag mytag resource_type=raw

Get resources by context

Retrieves resources (assets) with a specified contextual metadata key. This method does not return deleted assets even if they have been backed up.

Syntax

GET /resources/:resource_type/context/

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.resources_by_context(key, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->resources_by_context($key, $options = []));

Library:

PHP (cloudinary_php v2.x):

$api->assetsByContext($key, $options = []));

Library:

Python:

cloudinary.api.resources_by_context(key, **options)

Node.js:

cloudinary.v2.api.resources_by_context(key, options, callback);

Java:

api.resourcesByContext(String key, Map options);

.NET:

Not supported by this SDK

Go:

resp, err := cld.Admin.AssetsByContext(ctx, admin.AssetsByContextParams{})

CLI:

cld admin resources_by_context $key $options

Required parameters

Parameter	Type	Description
key	String	Only assets with this contextual metadata key are returned.

Optional parameters

Parameter	Type	Description
resource_type	String	The type of asset. Relevant as a parameter only when using the SDKs (the `resource_type` is included in the endpoint URL when using the REST API). Note: use `video` for all video and audio assets, such as .mp3. Possible values: `image` (default), `raw`, `video`.
value	String	Only assets with this value for the contextual metadata key are returned. If this parameter is not provided, all assets with the given contextual metadata key are returned, regardless of the actual value of the key.
max_results	Integer	Maximum number of assets to return (maximum=500). Default: `10`.
next_cursor	String	When a request has more results to return than `max_results`, the `next_cursor` value is returned as part of the response. You can then specify this value as the `next_cursor` parameter of the following request.
direction	String/Integer	Control the order of returned assets, according to the `created_at` date. Note: if a `prefix` is specified, this parameter is ignored and the results are sorted by public ID. Possible values: `desc` or `-1` (default), `asc` or `1`.
tags	Boolean	Whether to include the list of tag names assigned to each asset. Default: `false`.
context	Boolean	Whether to include key-value pairs of contextual metadata associated with each asset. Default: `false`.
moderations	Boolean	Whether to include image moderation status of each asset. Default: `false`.
metadata	Boolean	Whether to include the metadata fields and values set for each asset. Default: `false`.

Examples

Get images by contextual metadata key:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources_by_context('mycontextkey')

PHP (cloudinary_php v1.x (legacy)):

$api->resources_by_context("mycontextkey");

Library:

PHP (cloudinary_php v2.x):

$api->assetsByContext("mycontextkey");

Library:

Python:

cloudinary.api.resources_by_context("mycontextkey")

Node.js:

cloudinary.v2.api.resources_by_context("mycontextkey", 
  function(error, result) {console.log(result, error); });

Java:

api.resourcesByContext("mycontextkey", ObjectUtils.emptyMap());

.NET:

Not supported by this SDK

Go:

resp, err := cld.Admin.AssetsByContext(ctx, admin.AssetsByContextParams{
        Key: "mycontextkey"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/context?key=mycontextkey

CLI:

cld admin resources_by_context "mycontextkey"

Get video files by contextual metadata key and value:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources_by_context('mycontextkey', 'mycontextvalue',
  :resource_type => :video)

PHP (cloudinary_php v1.x (legacy)):

$api->resources_by_context("mycontextkey", "mycontextvalue"
  ["resource_type" => "video"]);

Library:

PHP (cloudinary_php v2.x):

$api->assetsByContext("mycontextkey", "mycontextvalue"
  ["resource_type" => "video"]);

Library:

Python:

cloudinary.api.resources_by_context("mycontextkey", "mycontextvalue"
  resource_type = "video")

Node.js:

cloudinary.v2.api.resources_by_context("mycontextkey", "mycontextvalue", 
  { resource_type: 'video'}, 
  function(error, result) {console.log(result, error); });

Java:

api.resourcesByContext("mycontextkey", "mycontextvalue", 
  ObjectUtils.asMap("resource_type", "video"));

.NET:

Not supported by this SDK

Go:

resp, err := cld.Admin.AssetsByContext(ctx, admin.AssetsByContextParams{
      Key:            "mycontextkey", 
      Value:          "mycontextvalue",
      DeliveryType:   "video"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/video/context?key=mycontextkey&value=mycontextvalue

CLI:

cld admin resources_by_context "mycontextkey" value="mycontextvalue" resource_type="video"

Get resources in moderation queues

Retrieves resources (assets) with a particular status from a specified moderation queue.

Syntax

GET /resources/:resource_type/moderations/:moderation_kind/:status

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.resources_by_moderation(moderation_kind, status, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->resources_by_moderation($moderation_kind, $status, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->assetsByModeration($moderation_kind, $status, $options = []);

Library:

Python:

cloudinary.api.resources_by_moderation(moderation_kind, status, **options)

Node.js:

cloudinary.v2.api.resources_by_moderation(moderation_kind, status, options, callback);

Java:

cloudinary.api().resourcesByModeration(String moderation_kind, String status, Map options);

.NET:

cloudinary.ListResourcesByModerationStatus(ModerationStatus Params);

Go:

resp, err := cld.Admin.AssetsByModeration(ctx, admin.AssetsByModerationParams{})

CLI:

cld admin resources_by_moderation (moderation_kind, status)

Required parameters

Parameter	Type	Description
moderation_kind	String	The type of moderation queue to list. Possible values: `manual`, `webpurify`, `aws_rek`, `metascan`.
status	String	The moderation status of assets to retrieve. Possible values: `pending`, `approved`, `rejected`.

Optional parameters

Parameter	Type	Description
resource_type	String	The type of asset. Relevant as a parameter only when using the SDKs (the `resource_type` is included in the endpoint URL when using the REST API). Note: use `video` for all video and audio assets, such as .mp3. Possible values: `image` (default), `raw`, `video`.
max_results	Integer	Maximum number of assets to return (maximum=500). Default: `10`.
next_cursor	String	When a request has more results to return than `max_results`, the `next_cursor` value is returned as part of the response. You can then specify this value as the `next_cursor` parameter of the following request.
direction	String/Integer	Control the order of returned assets, according to the `created_at` date. Note: if a `prefix` is specified, this parameter is ignored and the results are sorted by public ID. Possible values: `desc` or `-1` (default), `asc` or `1`.
tags	Boolean	Whether to include the list of tag names assigned to each asset. Default: `false`.
context	Boolean	Whether to include key-value pairs of contextual metadata associated with each asset. Default: `false`.
moderations	Boolean	Whether to include image moderation status of each asset. Default: `false`.
metadata	Boolean	Whether to include the metadata fields and values set for each asset. Default: `false`.

Examples

Get images pending manual moderation:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources_by_moderation("manual", "pending")

PHP (cloudinary_php v1.x (legacy)):

$api->resources_by_moderation("manual", "pending");

Library:

PHP (cloudinary_php v2.x):

$api->assetsByModeration("manual", "pending");

Library:

Python:

cloudinary.api.resources_by_moderation("manual", "pending")

Node.js:

cloudinary.v2.api.resources_by_moderation('manual', 'pending',
  function(error, result) {console.log(result, error); });

Java:

cloudinary.api().resourcesByModeration("manual", "pending",
  ObjectUtils.emptyMap());

.NET:

cloudinary.ListResourcesByModerationStatus("manual", "pending");

Go:

resp, err := cld.Admin.AssetsByModeration(ctx, admin.AssetsByModerationParams{
      Kind:   "manual", 
      Status: "pending"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/moderations/manual/pending

CLI:

cld admin resources_by_moderation manual pending

Get images automatically approved by the WebPurify add-on:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resources_by_moderation("webpurify", "approved")

PHP (cloudinary_php v1.x (legacy)):

$api->resources_by_moderation("webpurify", "approved");

Library:

PHP (cloudinary_php v2.x):

$api->assetsByModeration("webpurify", "approved");

Library:

Python:

cloudinary.api.resources_by_moderation("webpurify", "approved")

Node.js:

cloudinary.v2.api.resources_by_moderation('webpurify', 'approved',
  function(error, result) {console.log(result, error); });

Java:

cloudinary.api().resourcesByModeration("webpurify", "approved",
  ObjectUtils.emptyMap());

.NET:

cloudinary.ListResourcesByModerationStatus("webpurify", "approved");

Go:

resp, err := cld.Admin.AssetsByModeration(ctx, admin.AssetsByModerationParams{
      Kind:   "webpurify", 
      Status: "approved"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/moderations/webpurify/approved

CLI:

cld admin resources_by_moderation webpurify approved

Sample response

{
   "resources":
    [{
      "asset_id": "e590ea35ca6f56ee383e0437e43e1c54",
      "public_id": "q7vcvrfjm9mj4bfp3qc8",
      "format": "jpg",
      "version": 1570976812,
      "resource_type": "image",
      "type": "upload",
      "created_at": "2014-03-02T21:06:43Z",
      "bytes": 120253,
      "width": 864,
      "height": 576,
      "backup": true,
      "access_mode": "public",
      "url":
       "http://res.cloudinary.com/demo/image/upload/v1570976812/q7vcvrfjm9mj4bfp3qc8.jpg",
      "secure_url":
       "https://res.cloudinary.com/demo/image/upload/v1570976812/q7vcvrfjm9mj4bfp3qc8.jpg"
     },
     {
      "asset_id": "53270b5120ab81ede6f570a203677652",
      "public_id": "zp4fgdbabhlwwa7bxu84",
      "format": "jpg",
      "version": 1570977154,
      "resource_type": "image",
      "type": "upload",
      "created_at": "2014-03-02T21:06:39Z",
      "bytes": 120253,
      "width": 864,
      "height": 576,
      "backup": true,
      "access_mode": "public",
      "url":
       "http://res.cloudinary.com/demo/image/upload/v1570977154/zp4fgdbabhlwwa7bxu84.jpg",
      "secure_url":
       "https://res.cloudinary.com/demo/image/upload/v1570977154/zp4fgdbabhlwwa7bxu84.jpg"
     }
   ]
}

Get the details of a single resource

Return details of the requested resource (asset) as well as all its derived assets.

GET /resources/:resource_type/:type/:public_id

Syntax

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.resource(public_id, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->resource($public_id, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->asset($public_id, $options = []);

Library:

Python:

cloudinary.api.resource(public_id, **options)

Node.js:

cloudinary.v2.api.resource(public_id, options, callback);

Java:

api.resource(String public_id, Map options);

.NET:

cloudinary.GetResource(ResourceParams params);

Go:

resp, err := cld.Admin.Asset(ctx, admin.AssetParams{})

CLI:

cld admin resource (public_id)

Required parameters

Parameter	Type	Description
public_id	String	The public ID of the asset.

Optional parameters

Parameter	Type	Description
resource_type	String	The type of asset. Relevant as a parameter only when using the SDKs (the `resource_type` is included in the endpoint URL when using the REST API). Note: use `video` for all video and audio assets, such as .mp3. Possible values: `image` (default), `raw`, `video`.
type	String	The delivery type, relevant as a parameter only when using the SDKs (the `type` is included in the endpoint URL when using the REST API). Possible values: `upload`, `private`, `authenticated`, `facebook`, `twitter`, `gravatar`, `youtube`, `hulu`, `vimeo`, `animoto`, `worldstarhiphop`, `dailymotion`. Default: all.
colors	Boolean	Whether to include color information: predominant colors and histogram of 32 leading colors. Default: `false`.
image_metadata	Boolean	Whether to include IPTC, XMP, and detailed Exif metadata. Default: `false`. Returned metadata by type: - Images: `PixelsPerUnitX`, `PixelsPerUnitY`, `PixelUnits`, `Colorspace`, and `DPI`. - Audio and video: `audio_codec`, `audio_bit_rate`, `audio_frequency`, `audio_profile` ,`channels`, `channel_layout`. - Video: `pix_format`, `codec`, `level`, `profile`, `video_duration`, `video_bit_rate`, `dar`. Note: Using this parameter also returns the asset's ETag value for all asset types, including raw.
exif	Boolean	Deprecated. Use image_metadata instead. Default: `false`.
faces	Boolean	Whether to include a list of coordinates of detected faces. Default: `false`.
quality_analysis	Boolean	Whether to return quality analysis scores for the image. Default: `false`.
accessibility_analysis	Boolean	Whether to return accessibility analysis scores for the image. Default: `false`.
pages	Boolean	Whether to report the number of pages in multi-page documents (e.g., PDF). Default: `false`.
phash	Boolean	Whether to include the perceptual hash (pHash) of the uploaded photo for image similarity detection. Default: `false`.
coordinates	Boolean	Whether to include previously specified custom cropping coordinates and faces coordinates. Default: `false`.
versions	Boolean	Whether to include details of all the backed up versions of the asset. Default: `false`.
max_results	Integer	Maximum number of derived assets to return (maximum=500). Default: `10`.
derived_next_cursor	String	If there are more derived images than `max_results`, the `derived_next_cursor` value is returned as part of the response. You can then specify this value as the `derived_next_cursor` parameter of the following request.

Examples

Uploaded image details:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resource('sample')

PHP (cloudinary_php v1.x (legacy)):

$api->resource("sample");

Library:

PHP (cloudinary_php v2.x):

$api->asset("sample");

Library:

Python:

cloudinary.api.resource("sample")

Node.js:

cloudinary.v2.api.resource('sample',
  function(error, result) {console.log(result, error); });

Java:

api.resource("sample", ObjectUtils.emptyMap());

.NET:

cloudinary.GetResource("sample");

Go:

resp, err := cld.Admin.Asset(ctx, admin.AssetParams{PublicID: "sample"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload/sample

CLI:

cld admin resource sample

Faces, colors, image metadata and versions details:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resource('sample',
  :faces => true, 
  :colors => true, 
  :image_metadata => true,
  :versions => true)

PHP (cloudinary_php v1.x (legacy)):

$api->resource("sample", [
    "faces" => TRUE, 
    "colors" => TRUE, 
    "image_metadata" => TRUE,
    "versions" => TRUE]);

Library:

PHP (cloudinary_php v2.x):

$api->asset("sample", [
    "faces" => TRUE, 
    "colors" => TRUE, 
    "image_metadata" => TRUE,
    "versions" => TRUE]);

Library:

Python:

cloudinary.api.resource("sample",
  faces = True, 
  colors = True, 
  image_metadata = True,
  versions = True)

Node.js:

cloudinary.v2.api.resource('sample', 
  { faces: true, 
    colors: true, 
    image_metadata: true,
    versions: true },
  function(error, result) {console.log(result, error); });

Java:

api.resource("sample", 
  ObjectUtils.asMap(
    "faces", true,
    "colors", true, 
    "image_metadata", true,
    "versions", true));

.NET:

var getResource = new GetResourceParams("sample"){
  Faces = true,

Colors = ImageMetadata = Versions = true };
var info = cloudinary.GetResource(getResource);

Go:

resp, err := cld.Admin.Asset(ctx, admin.AssetParams{
        PublicID:       "sample",
        Faces:          true,
        Colors:         true,
        ImageMetadata:  true,
        Versions:       true})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload/sample?faces=1&colors=1&image_metadata=1&versions=1

CLI:

cld admin resource sample faces=true colors=true image_metadata=true versions=true

Facebook picture details:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resource('4', 
  :type => :facebook)

PHP (cloudinary_php v1.x (legacy)):

$api->resource("4", 
  ["type" => "facebook"]);

Library:

PHP (cloudinary_php v2.x):

$api->asset("4", 
  ["type" => "facebook"]);

Library:

Python:

cloudinary.api.resource("4", 
  type = "facebook")

Node.js:

cloudinary.v2.api.resource('4', 
  { type: 'facebook' },
  function(error, result) {console.log(result, error); });

Java:

api.resource("4", 
  ObjectUtils.asMap("type", "facebook"));

.NET:

var getResource = new GetResourceParams("4"){
Type = "facebook" };
var info = cloudinary.GetResource(getResource);

Go:

resp, err := cld.Admin.Asset(ctx, admin.AssetParams{
        PublicID:       "sample",
        DeliveryType:   "facebook"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/facebook/4

CLI:

cld admin resource "4" type=facebook

Uploaded raw file details:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.resource('rwkaliebnufp3bxyrvyo.txt',
  :resource_type => :raw)

PHP (cloudinary_php v1.x (legacy)):

$api->resource("rwkaliebnufp3bxyrvyo.txt",
  ["resource_type" => "raw"]);

Library:

PHP (cloudinary_php v2.x):

$api->asset("rwkaliebnufp3bxyrvyo.txt",
  ["resource_type" => "raw"]);

Library:

Python:

cloudinary.api.resource("rwkaliebnufp3bxyrvyo.txt",
  resource_type = "raw")

Node.js:

cloudinary.v2.api.resource('rwkaliebnufp3bxyrvyo.txt', 
  { resource_type: 'raw'},
  function(error, result) {console.log(result, error); });

Java:

api.resource("rwkaliebnufp3bxyrvyo.txt",
  ObjectUtils.asMap("resource_type", "raw"));

.NET:

var getResource = new GetResourceParams("rwkaliebnufp3bxyrvyo.txt"){
ResourceType = "raw" };
var info = cloudinary.GetResource(getResource);

Go:

resp, err := cld.Admin.Asset(ctx, admin.AssetParams{
        PublicID:   "rwkaliebnufp3bxyrvyo.txt",
        AssetType:  "raw"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/raw/upload/rwkaliebnufp3bxyrvyo.txt

CLI:

cld admin resource rwkaliebnufp3bxyrvyo.txt resource_type=raw

Sample response

This sample response is from the request including faces, colors, image metadata and versions:

{
    "asset_id": "d86882d7788f5d1d702cb63418f082a6",
    "public_id": "sample",
    "format": "jpg",
    "version": 1312461204,
    "resource_type": "image",
    "type": "upload",
    "created_at": "2011-08-04T12:33:24Z",
    "bytes": 120253,
    "width": 864,
    "height": 576,
    "access_mode": "public",
    "url": "http://res.cloudinary.com/demo/image/upload/v1312461204/sample.jpg",
    "secure_url": "https://.../image/upload/v1312461204/sample.jpg",
    "tags": [
      "flower",
      "plant",
      "naturet"
    ],
    "context": {
      "custom": {
        "alt": "sample flower",
        "caption": "beautiful flower"
      }
    },
    "next_cursor": "041a39fc10971b9eabd4993470f6bfaf",
    "derived": [
      {
        "transformation": "c_fill,w_100,h_100",
        "format": "jpg",
        "bytes": 7112,
        "id": "8267a869b62a93a59248f35d7f124c1f",
        "url": "http://.../demo/image/upload/c_fill,w_100,h_100/v1312461204/sample.jpg",
        "secure_url": "https://.../image/upload/c_fill,w_100,h_100/v1312461204/sample.jpg"
      },
      {
        "transformation": "w_230,h_168,c_fit",
        "format": "jpg",
        "bytes": 19173,
        "id": "383e22a57167445552a3cdc16f0a0c85",
        "url": "http://.../demo/image/upload/w_230,h_168,c_fit/v1312461204/sample.jpg",
        "secure_url": "https://.../image/upload/w_230,h_168,c_fit/v1312461204/sample.jpg"
      }
    ],

    "faces": [[98,74,61,83], [140,130,52,71]],

    "colors": [["#162E02",6.7], ["#385B0C",6.3], ["#F3285C",5.0], ["#B3CB6E",5.0], ["#688F1C",4.4], ["#324D07",4.4], ["#8EAA34",4.3], ["#4F6D0D",4.2], ["#789446",4.1], ["#DF1327",3.9], ["#A10B12",3.7], ["#273804",3.4], ["#0D1802",3.4], ["#D5E191",3.2], ["#646E20",3.1], ["#94AF4D",2.9], ["#FB54A9",2.8], ["#48570B",2.7], ["#ACC655",2.7], ["#FCA2D9",2.7], ["#63110A",2.6], ["#E9B327",2.2], ["#6D644D",2.1], ["#6D8D12",2.0], ["#8F9F27",1.9], ["#C3573E",1.8], ["#CFD76E",1.6], ["#A0B058",1.6], ["#FCD0E9",1.6], ["#728F2D",1.4], ["#F958A1",1.4], ["#D1B694",1.0]],

    "predominant": {
      "google": [
        [
          "yellow",
          52.9
        ],
        [
          "pink",
          13.5
        ],
        [
          "red",
          12.0
        ],
        [
          "black",
          10.1
        ],
        [
          "green",
          6.3
        ]
      ]
    },

    "versions": [
        {
            "version_id": "d214063097a43d1d1293db61a397f60f",
            "version": "1312461204",
            "format": "jpg",
            "size": 109669,
            "time": "2011-08-04T12:33:24+00:00",
            "restorable": false
        }
    ]
}

Search for resources

Search allows you fine control on filtering and retrieving information on all the resources (assets) in your account with the help of query expressions in a Lucene-like query language.

For detailed information on the search method and building expressions, see the Search API documentation.

Note

Request parameters cannot be appended to the endpoint URL as in the other Admin API methods. Search API parameters are passed as JSON data.

Syntax

GET /resources/search

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

result = Cloudinary::Search.execute

PHP:

result = \Cloudinary\search->execute();

Python:

result = cloudinary.Search().expression().execute()

Node.js:

cloudinary.v2.search.execute().then(result=>console.log(result));

Java:

result = cloudinary.search().execute();

.NET:

SearchResult result = cloudinary.Search().Execute();

Go:

resp, err := cld.Admin.Search(ctx, search.Query{})

CLI:

cld search

Note

Cloudinary implements eventual consistency: any changes made to assets will only be reflected in a search made a few seconds after the change is processed.

Optional parameters

All the parameters of the search method are optional. Including no parameters in the method call will return the 50 most recently created resources in descending order of creation time.

Parameter	Type	Description
expression	String	The (Lucene-like) string expression specifying the search query. If this parameter is not provided then all resources are listed (up to `max_results`). For details, see the expressions documentation.
sort_by	String[]	An array of string values representing a key value pair, where the key is the field to sort by and the value is the direction. Valid sort directions are `asc` or `desc`. If this parameter is not provided then the results are sorted by descending creation date. You can specify more than one `sort_by` parameter; results will be sorted according to the order of the fields provided.
max_results	Integer	Maximum number of assets to return (maximum=500). Default: `10`.
next_cursor	String	When a request has more results to return than `max_results`, the `next_cursor` value is returned as part of the response. You can then specify this value as the `next_cursor` parameter of the following request.
with_field	String	The name of an additional asset attribute to include for each asset in the response. You can specify more than one `with_field` parameter. Possible value: `context`, `tags`, and for Tier 2 also `image_metadata`, and `image_analysis`.
aggregate	String	(Tier 2 only) The name of a field (attribute) for which an aggregation count should be calculated and returned in the response. You can specify more than one `aggregate` parameter. Supported values: `resource_type`, `type`, `pixels` (only the image assets in the response are aggregated), `duration` (only the video assets in the response are aggregated), `format`, and `bytes`. For aggregation fields without discrete values, the results are divided into categories. For example: - `bytes` are divided into small (<500 kb), medium (500 kb - 5 mb), large (5 mb - 100 mb), and huge (>100 mb). - Video `duration` is divided into short (< 3 minutes), medium (3-12 min), and long (> 12 min).

Important

A new Search query object should be initialized for every distinct query executed. Please avoid reusing the same instance of a Search query object, as that might lead to unexpected behavior, especially when using the sort_by parameter.
When iterating through the results using the next_cursor parameter, the query should be reused without changing any of the other parameter values.
When making direct calls to the Cloudinary endpoint, make sure to pass any parameters using JSON (with Content-Type: application/json) as in the cURL examples on this page.

Examples

Find assets containing 'cat' in any field (attribute), include context metadata and tags in the details of each resource, and limit the returned results to 10 resources:

Ruby PHP Python Node.js Java .NET Go Endpoint CLI All

Ruby:

result = Cloudinary::Search
  .expression('cat')
  .with_field('context')
  .with_field('tags')
  .max_results(10)
  .execute

PHP:

result = \Cloudinary\search
  ->expression('cat')
  ->with_field('context')
  ->with_field('tags')
  ->max_results(10)
  ->execute();

Python:

result = cloudinary.Search()\
  .expression('cat')\
  .with_field('context')\
  .with_field('tags')\
  .max_results('10')\
  .execute()

Node.js:

cloudinary.v2.search
  .expression('cat')
  .with_field('context')
  .with_field('tags')
  .max_results(10)
  .execute().then(result=>console.log(result));

Java:

result = cloudinary.search()
  .expression("cat")
  .withField("context")
  .withField("tags")
  .maxResults(10)
  .execute();

.NET:

SearchResult result = cloudinary.Search()
  .Expression("cat")
  .WithField("context")
  .WithField("tags")
  .MaxResults(10)
  .Execute();

Go:

resp, err := cld.Admin.Search(ctx, search.Query{
          Expression: "cat",
          WithField:  []string{"tags", "context"},
          MaxResults: 10})

Endpoint:

curl \
  -H "Content-Type: application/json" \
  -d '{
        "expression": "cat",
        "with_field": ["context", "tags"],
        "max_results": 10
      }' \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/search

CLI:

cld search "cat" -f context -f tags -n 10

Find assets containing 'cat' in any field but not 'kitten' in the tags field, sort the results by public_id in descending order, and calculate an aggregation count based on the values of the format field:

Ruby PHP Python Node.js Java .NET Go Endpoint CLI All

Ruby:

result = Cloudinary::Search
  .expression('cat AND -tags:kitten')
  .sort_by('public_id','desc')
  .aggregate('format')
  .execute

PHP:

result = \Cloudinary\search()
  ->expression('cat AND -tags:kitten')
  ->sort_by('public_id','desc')
  ->aggregate('format')
  ->execute();

Python:

result = cloudinary.Search()
  .expression('cat AND -tags:kitten')
  .sort_by('public_id','desc')
  .aggregate('format')
  .execute()

Node.js:

cloudinary.v2.search
  .expression('cat AND -tags:kitten')
  .sort_by('public_id','desc')
  .aggregate('format')
  .execute().then(result=>console.log(result));

Java:

result = cloudinary.search()
  .expression("cat AND -tags:kitten")
  .sortBy("public_id","desc")
  .aggregate("format")
  .execute();

.NET:

SearchResult result = cloudinary.Search()
  .Expression("cat AND -tags:kitten")
  .SortBy("public_id","desc")
  .Aggregate("format")
  .Execute();

Go:

resp, err := cld.Admin.Search(ctx, search.Query{
      Expression: "cat AND -tags:kitten",
      SortBy:     []search.SortByField{{"public_id": "desc"}},
      Aggregate:  []string{"format"},
      MaxResults: 2})

Endpoint:

curl \
  -H "Content-Type: application/json" \
  -d '{
        "expression": "cat AND -tags:kitten",
        "sort_by": [{"public_id": "desc"}],
        "aggregate": ["format"]
      }' \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/search

CLI:

cld search "cat AND -tags:kitten" -s public_id desc -a format

Tip

For more examples, see the expression examples documentation.

Sample response

{
  "total_count": 32,
  "time": 30,
  "aggregations": {
    "format": {
      "png": 4,
      "jpg": 21,
      "mp4": 3,
      "doc": 4
    }
  },
  "next_cursor": "b16b8bd80426df43a107f26b0348",
  "resources": [
  {
    "asset_id": "5f9d30acd36ac3c4f48a82241a37a299",
    "public_id": "sample",
    "folder": "",
    "filename": "sample",
    "format": "png",
    "version": 1492606756,
    "resource_type": "image",
    "type": "upload",
    "created_at": "2017-04-03T09:56:49+00:00",
    "uploaded_at": "2017-04-19T12:59:16+00:00",
    "bytes": 3381,
    "backup_bytes": 16905,
    "width": 241,
    "height": 51,
    "aspect_ratio": 4.7254901960784315,
    "pixels": 12291,
    "access_control": [       
     { access_type: "token" },
     { access_type: "anonymous", start: "2017-12-15T12:00Z", end: "2018-01-20T12:00Z" }],
    "context": {},
    "image_analysis": { 
      "face_count": 0,
      "faces": [],
      "grayscale": true,
      "illustration_score": 1,
      "transparent": false,
      "colors": {
        "gray": 96.7
      }
    },
    "url": "http://res.cloudinary.com/demo/image/upload/v1492606756/sample.png",
    "secure_url": "https://res.cloudinary.com/demo/image/upload/v1492606756/sample.png",
    "status": "active",
    "access_mode": "public"
  },
  {
    "public_id": "dog",
     …
     …
  }
  …
}

Update details of an existing resource

Update one or more of the attributes associated with a specified resource (asset). Note that you can also update many attributes of an existing asset using the explicit method, which is not rate limited.

Syntax

POST /resources/:resource_type/:type/:public_id

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.update(public_id, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->update($public_id, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->update($public_id, $options = []);

Library:

Python:

cloudinary.api.update(public_id, **options)

Node.js:

cloudinary.v2.api.update(public_id, options, callback);

Java:

cloudinary.api().update(String public_id, Map options);

.NET:

cloudinary.Update(UpdateParams params);

Go:

resp, err := cld.Admin.UpdateAsset(ctx, admin.UpdateAssetParams{})

CLI:

cld admin update (public_id)

Required parameters

Parameter	Type	Description
public_id	String	The public ID of the asset to update.

Optional parameters

Parameter	Type	Description
resource_type	String	The type of asset. Relevant as a parameter only when using the SDKs (the `resource_type` is included in the endpoint URL when using the REST API). Note: use `video` for all video and audio assets, such as .mp3. Possible values: `image` (default), `raw`, `video`.
type	String	The delivery type, relevant as a parameter only when using the SDKs (the `type` is included in the endpoint URL when using the REST API). Possible values: `upload`, `private`, `authenticated`, `facebook`, `twitter`, `gravatar`, `youtube`, `hulu`, `vimeo`, `animoto`, `worldstarhiphop`, `dailymotion`. Default: all.
tags	String	A comma-separated list of tag names to assign to the uploaded asset for later group reference.
context	String	A map (using the SDKs) or pipe-separated list (for REST API calls) of key-value pairs of contextual metadata to attach to an uploaded asset. The contextual metadata values of uploaded files are available for fetching using the Admin API. For example: `alt=My image
metadata	String	A map (supported for Java SDK only) or pipe-separated list (for REST API calls) of custom metadata fields (by external_id) and the values to assign to each of them. The =, " and ❘ characters can be supported as values when escaped with a prepended backslash (`\`). For example: `in_stock_id=50❘color_id=[\"green\",\"red\"]`.
face_coordinates	String	List of coordinates of faces contained in an uploaded image. The given coordinates are used for cropping uploaded images using the `face` or `faces` gravity mode. The specified coordinates override the automatically detected faces. Each face is specified by the X & Y coordinates of the top left corner and the width & height of the face. The coordinates are comma separated while faces are concatenated with a pipe (`
custom_coordinates	String	Coordinates of an interesting region contained in an uploaded image. The given coordinates are used for cropping uploaded images using the `custom` gravity mode. The region is specified by the X & Y coordinates of the top left corner and the width & height of the region. For example: `85,120,220,310`.
quality_override	Integer	Sets a quality value for this asset that will override any automatic quality transformations (q_auto) for this specific asset.
moderation_status	String	Manually set image moderation status or override previously automatically moderated images by approving or rejecting. Possible values: `approved`, `rejected`.
auto_tagging	Decimal	Automatically assigns tags to an asset according to detected objects or categories with a confidence score higher than the specified value. Use together with the `detection` parameter for: Cloudinary AI Content Analysis Amazon Rekognition Celebrity Detection Use together with the `categorization` parameter for: Google Automatic Video Tagging Google Auto Tagging Imagga Auto Tagging Amazon Rekognition Auto Tagging Range: 0.0 to 1.0
detection	String	Invokes the relevant add-on to return a list of detected content. Set to: <content-aware model>_[<version>] (e.g. `coco_v1`) to return a list of detected content using the Cloudinary AI Content Analysis add-on. Can be used together with the `auto_tagging` parameter to apply tags automatically. `adv_face` to return a list of facial attributes using the Advanced Facial Attribute Detection add-on. `aws_rek_face` to return a list of detected celebrities and facial attributes using the Amazon Rekognition Celebrity Detection add-on. Can be used together with the `auto_tagging` parameter to apply tags automatically. Relevant for images only.
ocr	String	Set to `adv_ocr` to extract all text elements in an image as well as the bounding box coordinates of each detected element using the OCR text detection and extraction add-on. Relevant for images only.
raw_convert	String	Asynchronously generates a related file based on the uploaded file. Set to `aspose` to automatically create a PDF or other image format from a `raw` Office document using the Aspose Document Conversion add-on. Set to `google_speech` to instruct the Google AI Video Transcription add-on to generate an automatic transcript `raw` file from an uploaded video. Set to `extract_text` to extract all the text from a PDF file and store it in a `raw` file. The public ID of the generated raw file will be in the format: [pdf_public_id].extract_text.json. See also: Converting raw files.
categorization	String	A comma-separated list of the categorization add-ons to run on the asset. Set to `google_tagging`, `google_video_tagging`, `imagga_tagging` and/or `aws_rek_tagging` to automatically classify the scenes of the uploaded asset. Can be used together with the `auto_tagging` parameter to apply tags automatically. See the Google Automatic Video Tagging, Google Auto Tagging, Imagga Auto Tagging and Amazon Rekognition Auto Tagging add-ons for more details.
background_removal	String	Automatically remove the background of an image using an add-on. Set to `cloudinary_ai` to use the deep-learning based Cloudinary AI Background Removal add-on. Set to `pixelz` to use the human-powered Pizelz Remove-The-Background Editing add-on service. Relevant for images only.
access_control	access_types[]	An array of `access_types` for the asset. The asset is accessible as long as one of the access types is valid. Possible values for each access type: `token` - requires either Token-based authentication or Cookie-based authentication for accessing the resource. For example: `access_type: 'token'` `anonymous` - allows public access to the resource. The anonymous access type should also include `start` and `end` dates (in ISO 8601 format) defining when the resource is publically available. For example: `access_type: 'anonymous', start: '2017-12-15T12:00Z', end: '2018-01-20T12:00Z'`

Examples

Update tags and moderation status of an uploaded image:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.update("image1",
  :tags => "important",
  :moderation_status => "approved")

PHP (cloudinary_php v1.x (legacy)):

$api->update("image1", [
    "tags" => "important", 
    "moderation_status" => "approved"]);

Library:

PHP (cloudinary_php v2.x):

$api->update("image1", [
    "tags" => "important", 
    "moderation_status" => "approved"]);

Library:

Python:

cloudinary.api.update("image1",
  tags = "important",
  moderation_status = "approved")

Node.js:

cloudinary.v2.api.update("image1", 
  { tags: "important", 
    moderation_status: "approved"},
    function(error, result) {console.log(result, error); });

Java:

cloudinary.api().update("image1",
  ObjectUtils.asMap(
    "tags", "important",
    "moderation_status", "approved"));

.NET:

var updateParams = new UpdateParams("image1"){
  Tags = "important",
  ModerationStatus = "approved"};
var updateResult = cloudinary.Update(updateParams);

Go:

resp, err := cld.Admin.UpdateAsset(ctx, admin.UpdateAssetParams{
        PublicID:         "image1",
        Tags:              []string{"important"},
        ModerationStatus: "approved"})

cURL:

curl \
 -d "tags=important&moderation_status=approved" \
 -X POST \
 https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload/image1

CLI:

cld admin update image1 tags="important" moderation_status="approved"

Restore resources

Restores one or more resources (assets) from backup.

Syntax

POST /resources/:resource_type/:type/restore

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.restore(public_ids, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->restore($public_ids, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->restore($public_ids, $options = []);

Library:

Python:

cloudinary.api.restore(**public_ids, **options)

Node.js:

cloudinary.v2.api.restore(public_ids, options, callback);

Java:

api.restore(Map public_ids, Map options);

.NET:

cloudinary.Restore(RestoreParams params);

Go:

resp, err := cld.Admin.RestoreAssets(ctx, admin.RestoreAssetsParams{})

CLI:

cld admin restore (public_ids)

Required parameters

Parameter	Type	Description
public_ids	String[]	The public IDs of (deleted or existing) backed up assets to restore (array of up to 100 public_ids). By default, the latest backed up version of the asset is restored. If the `versions` parameter is specified, the corresponding version of each public ID is restored.

Optional parameters

Parameter	Type	Description
resource_type	String	The asset type of the requested assets. Relevant as a parameter only when using the SDKs (the `resource_type` is included in the endpoint URL when using the REST API). Note: use `video` for all video and audio assets, such as .mp3. Possible values: `image` (default), `raw`, `video`.
type	String	The delivery type of the requested assets, relevant as a parameter only when using the SDKs (the `type` is included in the endpoint URL when using the REST API). Possible values: `upload`, `private`, `authenticated`, Default: `upload`.
versions	String[]	The version of each of the assets to restore. Specify the `version_id` for each public ID. Use the resource method to list details of backed up versions of an asset.

Examples

Restore deleted resources by public_ids 'image1' and 'image2':

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.restore(["image1", "image2"])

PHP (cloudinary_php v1.x (legacy)):

$api->restore(["image1", "image2"]);

Library:

PHP (cloudinary_php v2.x):

$api->restore(["image1", "image2"]);

Library:

Python:

cloudinary.api.restore(["image1", "image2"])

Node.js:

cloudinary.v2.api.restore(["image1", "image2"],
  function(error, result) {console.log(result, error); });

Java:

cloudinary.api().restore(Arrays.asList("image1", "image2"),
  ObjectUtils.emptyMap());

.NET:

var publicIds = new List<string>(){"image1", "image2"};
cloudinary.Restore(publicIds);

Go:

resp, err := cld.Admin.RestoreAssets(ctx, admin.RestoreAssetsParams{
          PublicIDs: []string{"api_test_restore_20891", "api_test_restore_94060"}})

cURL:

curl \
 -d "public_ids[]=image1&public_ids[]=image2" \
 -X POST \
 https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload/restore

CLI:

cld admin restore "image1","image2"

Restore specific versions of deleted resources by public_ids 'image1' and 'image2':

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.restore(["image1", "image2"], versions => ["c3fe4be5921eb89acd9af738c892f654", "d214063097a43d1d1293db61a397f60f"])

PHP (cloudinary_php v1.x (legacy)):

$api->restore(["image1", "image2"], "versions" => ["c3fe4be5921eb89acd9af738c892f654", "d214063097a43d1d1293db61a397f60f"]);

Library:

PHP (cloudinary_php v2.x):

$api->restore(["image1", "image2"], "versions" => ["c3fe4be5921eb89acd9af738c892f654", "d214063097a43d1d1293db61a397f60f"]);

Library:

Python:

cloudinary.api.restore(["image1", "image2"], versions = ["c3fe4be5921eb89acd9af738c892f654", "d214063097a43d1d1293db61a397f60f"])

Node.js:

cloudinary.v2.api.restore(["image1", "image2"], versions: ["c3fe4be5921eb89acd9af738c892f654", "d214063097a43d1d1293db61a397f60f"],
  function(error, result) {console.log(result, error); });

Java:

cloudinary.api().restore(Arrays.asList("image1", "image2"), ObjectUtils.asMap("versions", Arrays.asList("c3fe4be5921eb89acd9af738c892f654", "d214063097a43d1d1293db61a397f60f")),
  ObjectUtils.emptyMap());

.NET:

var publicIds = new List<string>(){"image1", "image2"};
var versionIds = new List<string>(){"c3fe4be5921eb89acd9af738c892f654", "d214063097a43d1d1293db61a397f60f" };
var restoreParams = new RestoreParams(){
  PublicIds = publicIds,
  Versions = versionIds};
cloudinary.Restore(restoreParams);

Go:

resp, err := cld.Admin.RestoreAssets(ctx, admin.RestoreAssetsParams{
        PublicIDs: []string{"image1", "image2"},
        Versions:  []string{"c3fe4be5921eb89acd9af738c892f654", "d214063097a43d1d1293db61a397f60f"}})

cURL:

curl \
 -d "public_ids[]=image1&public_ids[]=image2&versions[]=c3fe4be5921eb89acd9af738c892f654&versions[]=d214063097a43d1d1293db61a397f60f" \
 -X POST \
 https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload/restore

CLI:

cld admin restore "image1","image2" versions="c3fe4be5921eb89acd9af738c892f654","d214063097a43d1d1293db61a397f60f"

Sample response

The details of the restored resources (note that when specific versions are restored, they are given new version IDs):

{
  "image1": 
  {
    "asset_id": "9ec64ab330767f4c1e939e2b4fcbaeac",
    "public_id": "image1", 
    "version": 1574260348, 
    "version_id": "8a7d06c83656a2a2d1d559f2ea5661f7",
    "signature": "b7f24977706edff33686e053e5a57a1684ff260b", 
    "width": 5472, 
    "height": 3648, 
    "format": "jpg", 
    "resource_type": "image", 
    "created_at": "2019-11-20T14:32:28Z", 
    "tags": [], 
    "bytes": 3477251, 
    "type": "upload", 
    "placeholder": false,
    "access_mode": "public"
  }
  "image2": 
  {
    "asset_id": "835d1cf89bd7c1b84dc4f53d35bc235f",
    "public_id": "image2", 
    "version": 1574261348, 
    "version_id": "80541d2d17a4485b84a7d264b3e778d0",
    "signature": "1aa2b977b02adffa268ae05a22aa57a1682fa202", 
    "width": 5234, 
    "height": 3234, 
    "format": "jpg", 
    "resource_type": "image", 
    "created_at": "2019-10-20T12:34:18Z", 
    "tags": [], 
    "bytes": 2427151, 
    "type": "upload", 
    "placeholder": false,
    "access_mode": "public"
  }
}

Update access mode

Update the access_mode of resources (assets) by public_id(s), by tag, or by prefix. When access_mode = 'authenticated', uploaded resources of type 'upload' behave as if they are of type 'authenticated'. The resource can later be made public by changing its access_mode to 'public', without having to update any image delivery URLs. In the case where public images are reverted to authenticated by changing their access_mode to 'authenticated', all the existing original and derived versions of the images are also invalidated on the CDN.

Note

You can only update the access_mode of an asset that was already assigned an access_mode when uploaded. For more details, see: Upload method and Access mode.

Syntax

POST /resources/:resource_type/upload/update_access_mode

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.update_resources_access_mode(access_mode, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->update_resources_access_mode($access_mode, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->updateResourcesAccessMode($access_mode, $options = []);

Library:

Python:

cloudinary.api.update_resources_access_mode(access_mode, **options)

Node.js:

cloudinary.v2.api.update_resources_access_mode(access_mode, options, callback);

Java:

api.updateResourcesAccessMode(String access_mode, Map options);

.NET:

cloudinary.UpdateResourceAccessMode(RestoreParams params);

Go:

Not supported by this SDK

CLI:

Not supported by the CLI

Required parameters

Parameter	Type	Description
access_mode	String	The new access mode to be set. Possible values: `public`, `authenticated`.
One of the following:
- public_ids	String[]	Update all assets with the given public IDs (array of up to 100 public_ids).
- prefix	String	Update all assets where the public ID starts with the given prefix (up to a maximum of 100 matching original assets).
- tag	String	Update all assets with the given tag (up to a maximum of 100 matching original assets).

Optional parameters

Parameter	Type	Description
resource_type	String	The type of asset. Relevant as a parameter only when using the SDKs (the `resource_type` is included in the endpoint URL when using the REST API). Note: use `video` for all video and audio assets, such as .mp3. Possible values: `image` (default), `raw`, `video`.

Examples

Update the access mode of uploaded images by public IDs:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.update_resources_access_mode_by_ids('public', 
  ['image1', 'image2'])

PHP (cloudinary_php v1.x (legacy)):

$api->update_resources_access_mode_by_ids("public", 
  ["image1", "image2"]);

Library:

PHP (cloudinary_php v2.x):

$api->updateResourcesAccessModeByIds("public", 
  ["image1", "image2"]);

Library:

Python:

cloudinary.api.update_resources_access_mode_by_ids("public", 
  ["image1", "image2"])

Node.js:

cloudinary.v2.api.update_resources_access_mode_by_ids("public", 
  ['image1', 'image2'],
  function(error, result){console.log(result);});

Java:

api.updateResourcesAccessModeByIds("public", 
  Arrays.asList("image1", "image2"), null);

.NET:

var updateResourceAccessModeParams = new UpdateResourceAccessModeParams(){
  AccessMode = "public",
  PublicIds = new List<string>(){"image1", "image2"}};
cloudinary.UpdateResourceAccessModeByIds(updateResourceAccessModeParams);

Go:

Not supported by this SDK

cURL:

curl \
  -d "access_mode=public&public_ids[]=image1&public_ids[]=image2" \
  -X POST \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload/update_access_mode

CLI:

Not supported by the CLI

Update the access mode of uploaded videos by prefix:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.update_resources_access_mode_by_prefix('public', "to-publish", 
  :resource_type => :video)

PHP (cloudinary_php v1.x (legacy)):

$api->update_resources_access_mode_by_prefix("public", "to-publish", 
  ["resource_type" => "video"]);

Library:

PHP (cloudinary_php v2.x):

$api->updateResourcesAccessModeByPrefix("public", "to-publish", 
  ["resource_type" => "video"]);

Library:

Python:

cloudinary.api.update_resources_access_mode_by_prefix("public", "to-publish", 
  resource_type = "video")

Node.js:

cloudinary.v2.api.update_resources_access_mode_by_prefix("public", "to-publish",
  { resource_type: 'video'}, 
  function(error, result){console.log(result);});

Java:

api.updateResourcesAccessModeByPrefix("public", "to-publish", 
  ObjectUtils.asMap("resource_type", "video"));

.NET:

var updateResourceAccessModeParams = new UpdateResourceAccessModeParams(){
  AccessMode = "public",
  ResourceType = "video"};
cloudinary.UpdateResourceAccessModeByPrefix("to-publish", updateResourceAccessModeParams);

Go:

Not supported by this SDK

cURL:

curl \
  -d "access_mode=public&prefix=to-publish" \
  -X POST \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/video/upload/update_access_mode

CLI:

Not supported by the CLI

Update the access mode of uploaded images by tag:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.update_resources_access_mode_by_tag('public', '20170216')

PHP (cloudinary_php v1.x (legacy)):

$api->update_resources_access_mode_by_tag("public", "20170216");

Library:

PHP (cloudinary_php v2.x):

$api->updateResourcesAccessModeByTag("public", "20170216");

Library:

Python:

cloudinary.api.update_resources_access_mode_by_tag("public", "20170216")

Node.js:

cloudinary.v2.api.update_resources_access_mode_by_tag('public', "20170216", 
  function(error, result){console.log(result);});

Java:

api.updateResourcesAccessModeByTag("public", "20170216", null);

.NET:

var updateResourceAccessModeParams = new UpdateResourceAccessModeParams(){
  AccessMode = "public"};
cloudinary.UpdateResourceAccessModeByTag("20170216", updateResourceAccessModeParams);

Go:

Not supported by this SDK

cURL:

curl \
  -d "access_mode=public&tag=20170216" \
  -X POST \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload/update_access_mode

CLI:

Not supported by the CLI

Sample response

{
    "updated": {
      "image1": "updated",
      "image2": "updated"
    },
    "failed": {
    },
}

Delete resources

Deletes resources (assets) uploaded to your account

Syntax

DELETE /resources/:resource_type/:type

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.delete_resources(public_ids, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->delete_resources($public_ids, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->deleteAssets($public_ids, $options = []);

Library:

Python:

cloudinary.api.delete_resources(**public_ids, **options)

Node.js:

cloudinary.v2.api.delete_resources(public_ids, options, callback);

Java:

api.deleteResources(Map public_ids, Map options);

.NET:

cloudinary.DeleteResources(DelResParams params);

Go:

resp, err := cld.Admin.DeleteAssets(ctx, admin.DeleteAssetsParams{})

CLI:

cld admin delete_resources (public_ids)

Required parameters

One of the following:

Parameter	Type	Description
public_ids	String[]	Delete all assets with the given public IDs (array of up to 100 public_ids).
prefix	String	Delete all assets, including derived assets, where the public ID starts with the given prefix (up to a maximum of 1000 original resources).
all	Boolean	Delete all assets (of the relevant resource_type and type), including derived assets (up to a maximum of 1000 original resources).

Optional parameters

Parameter	Type	Description
resource_type	String	The type of asset. Relevant as a parameter only when using the SDKs (the `resource_type` is included in the endpoint URL when using the REST API). Note: use `video` for all video and audio assets, such as .mp3. Possible values: `image` (default), `raw`, `video`.
type	String	The delivery type, relevant as a parameter only when using the SDKs (the `type` is included in the endpoint URL when using the REST API). Possible values: `upload`, `private`, `fetch`,`authenticated`, `facebook`, `twitter`, `gravatar`, `youtube`, `hulu`, `vimeo`, `animoto`, `worldstarhiphop`, `dailymotion`. Default: all.
keep_original	Boolean	Whether to delete only the derived resources. Default: `false`.
invalidate	Boolean	Whether to also invalidate the copies of the resource on the CDN. It usually takes between a few seconds and a few minutes for the invalidation to fully propagate through the CDN. There are also a number of other important considerations to keep in mind when invalidating files. Note that by default this parameter is not enabled: if you need this parameter enabled, please open a support request. Default: `false`.
next_cursor	String	When a deletion request has more than 1000 resources to delete, the response includes the `partial` boolean parameter set to true, as well as a `next_cursor` value. You can then specify this returned `next_cursor` value as a parameter of the following deletion request.
transformations	String	Only the derived resources matching this hash of transformation parameters will be deleted.

Examples

Delete uploaded images by public IDs:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_resources(['image1', 'image2'])

PHP (cloudinary_php v1.x (legacy)):

$api->delete_resources(["image1", "image2"]);

Library:

PHP (cloudinary_php v2.x):

$api->deleteAssets(["image1", "image2"]);

Library:

Python:

cloudinary.api.delete_resources(["image1", "image2"])

Node.js:

cloudinary.v2.api.delete_resources(['image1', 'image2'],
  function(error, result) {console.log(result, error); });

Java:

api.deleteResources(Arrays.asList("image1", "image2"),
  ObjectUtils.emptyMap());

.NET:

var delResParams = new DelResParams(){
  PublicIds = new List<string>{"image1", "image2"}};
cloudinary.DeleteResources(delResParams);

Go:

resp, err := adminAPI.DeleteAssets(ctx, admin.DeleteAssetsParams{
      PublicIDs: []string{"api_test_restore_20891", "api_test_restore_94060"}})

cURL:

curl \
  -d "public_ids[]=image1&public_ids[]=image2" \
  -X DELETE \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload

CLI:

cld admin delete_resources "image1","image2"

Delete Facebook pictures by public IDs:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_resources(['4'], 
  :type => :facebook)

PHP (cloudinary_php v1.x (legacy)):

$api->delete_resources(["4"], 
  ["type" => "facebook"]);

Library:

PHP (cloudinary_php v2.x):

$api->deleteAssets(["4"], 
   ["type" => "facebook"]);

Library:

Python:

cloudinary.api.delete_resources(["4"], 
  type = "facebook")

Node.js:

cloudinary.v2.api.delete_resources(['4'], 
  { type: 'facebook' },
  function(error, result) {console.log(result, error); });

Java:

api.deleteResources(Arrays.asList("4"),
  ObjectUtils.asMap("type", "facebook"));

.NET:

var delResParams = new DelResParams(){
  PublicIds = new List<string>{"4"},
  Type = "facebook"};
cloudinary.DeleteResources(delResParams);

Go:

resp, err := cld.Admin.DeleteAssets(ctx, admin.DeleteAssetsParams{
        PublicIDs:    []string{"4"},
        DeliveryType: "facebook"})

cURL:

curl \
  -d "public_ids=4" \
  -X DELETE \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/facebook

CLI:

cld admin delete_resources "4" type="facebook"

Delete uploaded images by prefix:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_resources_by_prefix('sunday')

PHP (cloudinary_php v1.x (legacy)):

$api->delete_resources_by_prefix("sunday");

Library:

PHP (cloudinary_php v2.x):

$api->deleteAssetsByPrefix("sunday");

Library:

Python:

cloudinary.api.delete_resources_by_prefix("sunday")

Node.js:

cloudinary.v2.api.delete_resources_by_prefix('sunday', 
  function(error, result) {console.log(result, error); });

Java:

api.deleteResourcesByPrefix("sunday", 
  ObjectUtils.emptyMap());

.NET:

cloudinary.DeleteResourcesByPrefix("sunday");

Go:

resp, err := cld.Admin.DeleteAssetsByPrefix(ctx, admin.DeleteAssetsByPrefixParams{
        Prefix: []string{"sunday"}})

cURL:

curl \
  -d "prefix=sunday" \
  -X DELETE \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload

CLI:

cld admin delete_resources_by_prefix "sunday"

Delete derived images only:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_resources(['image1', 'image2'],
  :keep_original => true)

PHP (cloudinary_php v1.x (legacy)):

$api->delete_resources(["image1", "image2"],
  ["keep_original" => TRUE]);

Library:

PHP (cloudinary_php v2.x):

$api->deleteAssets(["image1", "image2"],
  ["keep_original" => TRUE]);

Library:

Python:

cloudinary.api.delete_resources(["image1", "image2"],
  keep_original = True)

Node.js:

cloudinary.v2.api.delete_resources(['image1', 'image2'], 
  { keep_original: true},
  function(error, result) {console.log(result, error); });

Java:

api.deleteResources(Arrays.asList("image1", "image2"),
<OBJECT></OBJECT>ObjectUtils.asMap("keep_original", true));

.NET:

var delResParams = new DelResParams(){
PublicIds = new List<string>{"image1", "image2"},
  KeepOriginal = true};
cloudinary.DeleteResources(delResParams);

Go:

resp, err := cld.Admin.DeleteAssetsByPrefix(ctx, admin.DeleteAssetsByPrefixParams{
      Prefix:           []string{"image1", "image2"},
      KeepOriginal:     true})

cURL:

curl \
  -d "public_ids[]=image1&public_ids[]=image2&keep_original=1" \
  -X DELETE \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/upload

CLI:

cld admin delete_resources "image1","image2" keep_original=true

Delete all Facebook pictures:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_all_resources(
  :type => :facebook)

PHP (cloudinary_php v1.x (legacy)):

$api->delete_all_resources(
  ["type" => "facebook"]);

Library:

PHP (cloudinary_php v2.x):

$api->deleteAllAssets(
  ["type" => "facebook"]);

Library:

Python:

cloudinary.api.delete_all_resources(
  type = "facebook")

Node.js:

cloudinary.v2.api.delete_all_resources(
  {type: 'facebook'}, 
  function(error, result) {console.log(result, error); });

Java:

api.deleteAllResources(
  ObjectUtils.asMap("type", "facebook"));

.NET:

var delResParams = new DelResParams(){
  Type = "facebook",
  All = true};
cloudinary.DeleteResources(delResParams);

Go:

resp, err := cld.Admin.DeleteAllAssets(ctx, admin.DeleteAllAssetsParams{
      DeliveryType: "facebook",
      All:          true})

cURL:

curl \
  -d "all=true" \
  -X DELETE \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/facebook

CLI:

cld admin delete_all_resources type="facebook"

Sample response

{
    "deleted": {
        "image1": "deleted",
        "image2": "deleted"
    },
    "partial": false
}

Delete resources by tags

Deletes resources (assets) with a specified tag.

Syntax

DELETE /resources/:resource_type/tags/:tag

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.delete_resources_by_tag(tag, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->delete_resources_by_tag($tag, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->deleteAssetsByTag($tag, $options = []);

Library:

Python:

cloudinary.api.delete_resources_by_tag(tag, **options)

Node.js:

cloudinary.v2.api.delete_resources_by_tag(tag, options, callback);

Java:

api.deleteResourcesByTag(String tag, Map options);

.NET:

cloudinary.DeleteResourcesByTag(TagParams params);

Go:

resp, err := cld.Admin.DeleteAssetsByTag(ctx, admin.DeleteAssetsByTagParams{})

CLI:

cld admin delete_resources_by_tag (tag)

Required parameters

Parameter	Type	Description
tag	String	Delete all assets (and their derivatives) with the given tag name (up to a maximum of 1000 original assets).

Optional parameters

Parameter	Type	Description
resource_type	String	The type of asset. Relevant as a parameter only when using the SDKs (the `resource_type` is included in the endpoint URL when using the REST API). Note: use `video` for all video and audio assets, such as .mp3. Possible values: `image` (default), `raw`, `video`.
keep_original	Boolean	Whether to delete only the derived resources. Default: `false`.
invalidate	Boolean	Whether to also invalidate the copies of the resource on the CDN. It usually takes between a few seconds and a few minutes for the invalidation to fully propagate through the CDN. There are also a number of other important considerations to keep in mind when invalidating files. Note that by default this parameter is not enabled: if you need this parameter enabled, please open a support request. Default: `false`.
next_cursor	String	When a deletion request has more than 1000 resources to delete, the response includes the `partial` boolean parameter set to true, as well as a `next_cursor` value. You can then specify this returned `next_cursor` value as a parameter of the following deletion request.
transformations	String	Only the derived resources matching this hash of transformation parameters will be deleted.

Examples

Delete images by tag name:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_resources_by_tag('mytag')

PHP (cloudinary_php v1.x (legacy)):

$api->delete_resources_by_tag("mytag");

Library:

PHP (cloudinary_php v2.x):

$api->deleteAssetsByTag("mytag");

Library:

Python:

cloudinary.api.delete_resources_by_tag("mytag")

Node.js:

cloudinary.v2.api.delete_resources_by_tag('mytag',
  function(error, result) {console.log(result, error); });

Java:

api.deleteResourcesByTag("mytag", ObjectUtils.emptyMap());

.NET:

cloudinary.DeleteResourcesByTag("mytag");

Go:

resp, err := cld.Admin.DeleteAssetsByTag(ctx, admin.DeleteAssetsByTagParams{
      Tag:  "mytag"})

cURL:

curl \
  -X DELETE \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/resources/image/tags/mytag

CLI:

cld admin delete_resources_by_tag mytag

Sample response

{
    "deleted": {
        "image1": "deleted",
        "image2": "deleted"
    },
    "partial": false
}

Delete derived resources

Deletes derived resources (assets) from your account.

Syntax

DELETE /derived_resources

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.delete_derived_resources(derived_resource_ids, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->delete_derived_resources($derived_resource_ids, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->deleteDerivedAssets($derived_resource_ids, $options = []);

Library:

Python:

cloudinary.api.delete_derived_resources(**derived_resource_ids, **options)

Node.js:

cloudinary.v2.api.delete_derived_resources(derived_resource_ids, options, callback);

Java:

api.deleteDerivedResources(Iterable<String> derivedResourceIds, Map options)

.NET:

cloudinary.DeleteDerivedResources(List<string> DerivedResourceIds);

Go:

resp, err := cld.Admin.DeleteDerivedAssets(ctx, admin.DeleteDerivedAssetsParams{DerivedAssetIDs})

CLI:

cld admin delete_derived_resources (derived_resource_ids)

Required parameters

One of the following:

Parameter	Type	Description
derived_resource_ids	String[]	Delete all assets with the given derived_resource_ids IDs (array of up to 100 IDs). The derived resource IDs are returned when calling the Details of a single resource method.

Optional parameters

Parameter	Type	Description
invalidate	Boolean	Whether to also invalidate the copies of the resource on the CDN. It usually takes between a few seconds and a few minutes for the invalidation to fully propagate through the CDN. There are also a number of other important considerations to keep in mind when invalidating files. Note that by default this parameter is not enabled: if you need this parameter enabled, please open a support request. Default: `false`.

Examples

Delete assets by derived resource IDs (8267a869b62a93a59248f35d7f124c1f and 383e22a57167445552a3cdc16f0a0c85):

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_derived_resources(['8267a869b62a93a59248f35d7f124c1f', '383e22a57167445552a3cdc16f0a0c85'])

PHP (cloudinary_php v1.x (legacy)):

$api->delete_derived_resources(["8267a869b62a93a59248f35d7f124c1f", "383e22a57167445552a3cdc16f0a0c85"]);

Library:

PHP (cloudinary_php v2.x):

$api->deleteDerivedAssets(["8267a869b62a93a59248f35d7f124c1f", "383e22a57167445552a3cdc16f0a0c85"]);

Library:

Python:

cloudinary.api.delete_derived_resources(["8267a869b62a93a59248f35d7f124c1f", "383e22a57167445552a3cdc16f0a0c85"])

Node.js:

cloudinary.v2.api.delete_derived_resources(['8267a869b62a93a59248f35d7f124c1f', '383e22a57167445552a3cdc16f0a0c85'],
  function(error, result) {console.log(result, error); });

Java:

api.deleteDerivedResources(Arrays.asList("8267a869b62a93a59248f35d7f124c1f", "383e22a57167445552a3cdc16f0a0c85"),
  ObjectUtils.emptyMap());

.NET:

cloudinary.DeleteDerivedResources(new List<string>{"8267a869b62a93a59248f35d7f124c1f", "383e22a57167445552a3cdc16f0a0c85");

Go:

resp, err := cld.Admin.DeleteDerivedAssets(ctx, admin.DeleteDerivedAssetsParams{
      DerivedAssetIDs: []string{"8267a869b62a93a59248f35d7f124c1f", "383e22a57167445552a3cdc16f0a0c85"}})

cURL:

curl \
  -d "derived_resource_ids[]=8267a869b62a93a59248f35d7f124c1f&derived_resource_ids[]=383e22a57167445552a3cdc16f0a0c85" \
  -X DELETE \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/derived_resources

CLI:

cld admin delete_derived_resources "8267a869b62a93a59248f35d7f124c1f","383e22a57167445552a3cdc16f0a0c85"

Transformations

Enables you to manage stored transformations. See the Image transformations and video transformations documentation for more information.

Method	Description
GET `/transformations`	Get all transformations
GET `/transformations/:transformation`	Get details of a transformation
POST`/transformations/:name`	Create a named transformation
PUT`/transformations/:transformation`	Update a transformation
DELETE`/transformations/:transformation`	Delete a transformation

Get Transformations

List all transformations.

Syntax

GET /transformations

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.transformations(options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->transformations($options = []);

Library:

PHP (cloudinary_php v2.x):

$api->transformations($options = []);

Library:

Python:

cloudinary.api.transformations(**options)

Node.js:

cloudinary.v2.api.transformations(options, callback);

Java:

api.transformations(Map options);

.NET:

cloudinary.ListTransformations(TransformParams params);

Go:

resp, err := cld.Admin.ListTransformations(ctx, admin.ListTransformationsParams{})

CLI:

cld admin transformations

Optional parameters

Parameter	Type	Description
max_results	Integer	Maximum number of transformations to return (up to 500). Default: `10`.
next_cursor	String	When a request has more results to return than `max_results`, the `next_cursor` value is returned as part of the response. You can then specify this value as the `next_cursor` parameter of a following request.
named	Boolean	Whether to return only named (`true`) or unnamed (`false`) transformations. If this parameter is not included, both named and unnamed transformations will be returned.

Examples

List all transformations:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.transformations

PHP (cloudinary_php v1.x (legacy)):

$api->transformations();

Library:

PHP (cloudinary_php v2.x):

$api->transformations();

Library:

Python:

cloudinary.api.transformations()

Node.js:

cloudinary.v2.api.transformations(function(error, result){console.log(result);});

Java:

api.transformations(ObjectUtils.emptyMap());

.NET:

cloudinary.ListTransformations();

Go:

resp, err := cld.Admin.ListTransformations(ctx, admin.ListTransformationsParams{})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/transformations

CLI:

cld admin transformations

Sample response

The response contains an array of transformations. If the number of transformations exceeds the max_results value, the next_cursor parameter is also returned. You can specify this value as the next_cursor parameter of the following listing request.

{
    "transformations": [
    {
        "name": "t_Aspen_LUT",
        "allowed_for_strict": true,
        "used": false,
        "named": true
    },
    {
        "name": "w_110,h_100,c_fill",
        "allowed_for_strict": false,
        "used": false,
        "named": false
    },
    {
        "name": "c_thumb,g_face,h_100,w_80",
        "allowed_for_strict": false,
        "used": true,
        "named": false
    },
    {
        "name": "c_fill,h_75,w_75/jpg",
        "allowed_for_strict": false,
        "used": true,
        "named": false
    }
    ],
    "next_cursor": "8edbc61040178db60b0973ca9494bf3a"
}

Get Transformation details

Get details of a single transformation. Supply either the name of the transformation or the transformation parameters.

Syntax

GET /transformations/:transformation

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.transformation(transformation, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->transformation($transformation, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->transformation($transformation, $options = []);

Library:

Python:

cloudinary.api.transformation(transformation, **options)

Node.js:

cloudinary.v2.api.transformation(transformation,
options, callback);

Java:

api.transformations(String transformation, Map options);

.NET:

cloudinary.GetTransform(TransformParams params);

Go:

resp, err := cld.Admin.GetTransformation(ctx, admin.GetTransformationParams{})

CLI:

cld admin transformation

Required parameters

Parameter	Type	Description
transformation	String	The name of the transformation or the transformation parameters.

Optional parameters

Parameter	Type	Description
max_results	Integer	Maximum number of derived resources to return (up to 500). Default: `10`.
next_cursor	String	When a request has more results to return than `max_results`, the `next_cursor` value is returned as part of the response. You can then specify this value as the `next_cursor` parameter of a following request.

Examples

Get transformation by name:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.transformation('w_150,h_100,c_fill')

PHP (cloudinary_php v1.x (legacy)):

$api->transformation("w_150,h_100,c_fill");

Library:

PHP (cloudinary_php v2.x):

$api->transformation("w_150,h_100,c_fill");

Library:

Python:

cloudinary.api.transformation("w_150,h_100,c_fill")

Node.js:

cloudinary.v2.api.transformation('w_150,h_100,c_fill',
  function(error, result) {console.log(result, error); });

Java:

api.transformations("w_150,h_100,c_fill", ObjectUtils.emptyMap());

.NET:

cloudinary.GetTransform("w_150,h_100,c_fill");

Go:

resp, err := cld.Admin.GetTransformation(ctx, admin.GetTransformationParams{Transformation: "w_150,h_100,c_fill"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/transformations/w_150,h_100,c_fill

CLI:

cld admin transformation "w_150,h_100,c_fill"

Get transformation by parameters:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.transformation(:width => 150, :height => 100,
  :crop => :fill)

PHP (cloudinary_php v1.x (legacy)):

$api->transformation(["width" => 150, "height" => 100,
  "crop" => "fill"]);

Library:

PHP (cloudinary_php v2.x):

$api->transformation(["width" => 150, "height" => 100,
  "crop" => "fill"]);

Library:

Python:

cloudinary.api.transformation(dict(width = 150, height = 100, crop = "fill"))

Node.js:

cloudinary.v2.api.transformation({width: 150, height: 100, crop: 'fill'},
  function(error, result) {console.log(result, error); });

Java:

api.transformation(new Transformation().width(150).height(100).
  crop("fill").generate(), ObjectUtils.emptyMap());

.NET:

Not supported by this SDK

Go:

Not supported by this SDK

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/transformations/c_fill,h_100,w_150

CLI:

cld admin transformation '{"width": 500, "height": 100, "crop": "fill"}'

Sample response

{
  "name": "w_150,h_100,c_fill",
  "allowed_for_strict": false,
  "used": true,
  "named": false,
  "info": [
    {
      "width": 150,
      "height": 100,
      "crop": "fill"
    }
  ],
  "derived": [
    {
      "public_id": "sample",
      "resource_type": "image",
      "type": "upload",
      "format": "jpg",
      "url":
        "http://.../demo/image/upload/w_150,h_100,c_fill/v1341141057/sample.jpg",
      "secure_url":
        "https://.../demo/image/upload/w_150,h_100,c_fill/v1341141057/sample.jpg",
      "bytes": 10202,
      "id": "2adf1841874c7b2326d1f90cbedbc914"
    }
  ]
}

Create a named transformation

Create a new named transformation.

Syntax

POST /transformations/:name

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.create_transformation(name, transformation)

PHP (cloudinary_php v1.x (legacy)):

$api->create_transformation($name, transformation);

Library:

PHP (cloudinary_php v2.x):

$api->createTransformation($name, transformation);

Library:

Python:

cloudinary.api.create_transformation(name, transformation)

Node.js:

cloudinary.v2.api.create_transformation(name,
transformation, callback);

Java:

api.createTransformations(String name, String transformation));

.NET:

cloudinary.CreateTransform(createTransformParams params);

Go:

resp, err := cld.Admin.CreateTransformation(ctx, admin.CreateTransformationParams{})

CLI:

cld admin create_transformation (name, transformation)

Required parameters

Parameter	Type	Description
name	String	The name of the transformation.
transformation	String	The transformation parameters.

Examples

Create named transformation by string:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.create_transformation('small_fill',
  'w_150,h_100,c_fill')

PHP (cloudinary_php v1.x (legacy)):

$api->create_transformation("small_fill", "w_150,h_100,c_fill");

Library:

PHP (cloudinary_php v2.x):

$api->createTransformation("small_fill", "w_150,h_100,c_fill");

Library:

Python:

cloudinary.api.create_transformation("small_fill",
  "w_150,h_100,c_fill")

Node.js:

cloudinary.v2.api.create_transformation('small_fill',
  'w_150,h_100,c_fill',
  function(error, result) {console.log(result, error); });

Java:

api.createTransformation("small_fill", "w_150,h_100,c_fill",
  ObjectUtils.emptyMap());

.NET:

var createTransformParams = new CreateTransformParams(){
  Name = "small_fill",
  Transformation = new Transformation().Width(150).Height(100).Crop("fill")};
cloudinary.CreateTransform(createTransformParams);

Go:

resp, err := cld.Admin.CreateTransformation(ctx, admin.CreateTransformationParams{
      Name:           "small_fill", 
      Transformation: "w_150,h_100,c_fill"})

cURL:

curl \
  -d 'transformation=w_150,h_100,c_fill' \
  -X POST \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/transformations/small_fill

CLI:

cld admin create_transformation "small_fill" "w_150,h_100,c_fill"

Create named transformation by parameters:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.create_transformation('small_fill2',
  {:width => 150, :height => 100, :crop => :fill})

PHP (cloudinary_php v1.x (legacy)):

$api->create_transformation("small_fill2",
  ["width" => 150, "height" => 100, "crop" => "fill"]);

Library:

PHP (cloudinary_php v2.x):

$api->createTransformation("small_fill2",
  ["width" => 150, "height" => 100, "crop" => "fill"]);

Library:

Python:

cloudinary.api.create_transformation("small_fill2",
  dict(width = 150, height = 100, crop = "fill"))

Node.js:

cloudinary.v2.api.create_transformation('small_fill2',
  { width: 150, height: 100, crop: 'fill' },
  function(error, result) {console.log(result, error); });

Java:

api.createTransformation("small_fill2",
  new Transformation().width(150).height(100).crop("fill").generate(),
  ObjectUtils.emptyMap());

.NET:

var createTransformParams = new CreateTransformParams(){
  Name = "small_fill2",
  Transformation = new Transformation().Width(150).Height(100).Crop("fill")};
cloudinary.CreateTransform(createTransformParams);

Go:

Not supported by this SDK

cURL:

curl \
  -d 'transformation=w_150,h_100,c_fill' \
  -X POST \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/transformations/small_fill

CLI:

cld admin create_transformation "small_fill2" '{"width": 150, "height": 100, "crop": "fill"}'

Sample response

{
 "message": "created"
}

Update transformation

Update a specific transformation.

Important

Before you modify the transformation parameters of a named transformation that's already used in production, make sure you're aware of all existing use cases. To mitigate risk, when you update the parameters of an existing named transformation, existing derived assets using the named transformation are not regenerated. However, if an asset using the named transformation is already in production and is later regenerated for another reason (for example, you invalidate it or adjust transformation parameters outside the named transformation), then the new named transformation definition is applied, and if that definition does not fit with the overall transformation defined for that asset, it could break your production asset.

Syntax

PUT /transformations/:transformation

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.update_transformation(transformation, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->update_transformation($transformation, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->updateTransformation($transformation, $options = []);

Library:

Python:

cloudinary.api.update_transformation(transformation, **options)

Node.js:

cloudinary.v2.api.update_transformation(transformation,
options, callback);

Java:

api.updateTransformations(String transformation, Map options));

.NET:

cloudinary.UpdateTransform(updateTransformParams params);

Go:

resp, err := cld.Admin.UpdateTransformation(ctx, admin.UpdateTransformationParams{})

CLI:

cld admin update_transformation (transformation)

Required parameters

Parameter	Type	Description
transformation	String	The name of the transformation or a listing of the transformation parameters.

Optional parameters

Parameter Type Description

allowed_for_strict Boolean Whether to allow this named transformation when strict transformations are enabled. Default: false.

unsafe_update

String

Parameter	Type	Description
allowed_for_strict	Boolean	Whether to allow this named transformation when strict transformations are enabled. Default: `false`.
unsafe_update	String	Required when modifying the transformation parameters of an existing named transformation. The new transformation definition for the named transformation. Because the changed definition can be unsafe for (significantly change) assets in production, the change is applied only to newly generated derived assets that reference this named transformation. To apply the change to existing derived assets using this named transformation, invalidate them so that they'll be regenerated with the new definition when next requested.

Required when modifying the transformation parameters of an existing named transformation. The new transformation definition for the named transformation.

Because the changed definition can be unsafe for (significantly change) assets in production, the change is applied only to newly generated derived assets that reference this named transformation.

To apply the change to existing derived assets using this named transformation, invalidate them so that they'll be regenerated with the new definition when next requested.

Examples

Allow transformation by name:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.update_transformation('on_sale_overlay',
  :allowed_for_strict => true)

PHP (cloudinary_php v1.x (legacy)):

$api->update_transformation("on_sale_overlay",
  array("allowed_for_strict" => 1));

Library:

PHP (cloudinary_php v2.x):

$api->updateTransformation("on_sale_overlay",
  ["allowed_for_strict" => 1]);

Library:

Python:

cloudinary.api.update_transformation("on_sale_overlay",
  allowed_for_strict = True)

Node.js:

cloudinary.v2.api.update_transformation('on_sale_overlay',
  { allowed_for_strict: true },
  function(error, result) {console.log(result, error); });

Java:

api.updateTransformation("on_sale_overlay",
  ObjectUtils.asMap("allowed_for_strict", true);

.NET:

var updateTransformParams = new UpdateTransformParams(){
  Transformation = "on_sale_overlay",
  Strict = true};
cloudinary.UpdateTransform(updateTransformParams);

Go:

resp, err := cld.Admin.UpdateTransformation(ctx, admin.UpdateTransformationParams{
      Transformation:   "on_sale_overlay", 
      AllowedForStrict: true})

cURL:

curl \
  -d 'allowed_for_strict=true' \
  -X PUT \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/transformations/on_sale_overlay

CLI:

cld admin update_transformation "on_sale_overlay" allowed_for_strict=true

Disallow transformation by parameter listing:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.update_transformation(
  { :width => 150, :height => 100, :crop => :fill},
  { :allowed_for_strict => false })

PHP (cloudinary_php v1.x (legacy)):

$api->update_transformation(
  ["width" => 150, "height" => 100,"crop" => "fill"],
  ["allowed_for_strict" => 0]);

Library:

PHP (cloudinary_php v2.x):

$api->updateTransformation(
  ["width" => 150, "height" => 100,"crop" => "fill"],
  ["allowed_for_strict" => 0]);

Library:

Python:

cloudinary.api.update_transformation(
  dict(width = 150, height = 100, crop = "fill"), 
  dict(allowed_for_strict = False))

Node.js:

cloudinary.v2.api.update_transformation(
  { width: 150, height: 100, crop: 'fill' },
  { allowed_for_strict: false },
  function(error, result) {console.log(result, error); });

Java:

api.updateTransformation(
  new Transformation().width(150).height(100).crop("fill").generate(), 
  ObjectUtils.asMap("allowed_for_strict", false);

.NET:

var updateTransformParams = new UpdateTransformParams(){
  Transformation = "w_150,h_100,c_fill",
  Strict = false};
cloudinary.UpdateTransform(updateTransformParams);

Go:

resp, err := cld.Admin.UpdateTransformation(ctx, admin.UpdateTransformationParams{
      Transformation:   "w_150,h_100,c_fill", 
      AllowedForStrict: false})

cURL:

curl \
  -d 'allowed_for_strict=false' \
  -X PUT \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/transformations/c_fill,h_100,w_150

CLI:

cld admin update_transformation '{"width": 150, "height": 100, "crop": "fill"}' allowed_for_strict=true

Update the transformation definition for a named transformation:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.update_transformation('my_named',
  :unsafe_update => { :crop => :scale, :width =>103 })

PHP (cloudinary_php v1.x (legacy)):

$api->update_transformation("my_named", 
  array("unsafe_update" => array("crop" => "scale", "width" => 103)));

Library:

PHP (cloudinary_php v2.x):

$api->updateTransformation("my_named",
  ["unsafe_update" => ["crop" => "scale", "width" => 103]]);

Library:

Python:

cloudinary.api.update_transformation("my_named",
  unsafe_update=dict(transformation=[{'crop' : "scale", 'width' : 103 }]))

Node.js:

cloudinary.v2.api.update_transformation("my_named",
  {unsafe_update: {crop: 'scale', width: 103}},
  function(error, result) {console.log(result, error); });

Java:

api.updateTransformation("my_named",
  ObjectUtils.asMap("unsafe_update",
  new Transformation().crop("scale").width(103).generate());

.NET:

var updateTransformParams = new UpdateTransformParams(){
  Transformation = "my_named",
  UnsafeTransform = new Transformation().Crop("scale").Width(103)};
cloudinary.UpdateTransform(updateTransformParams);

Go:

resp, err := cld.Admin.UpdateTransformation(ctx, admin.UpdateTransformationParams{
      Transformation: "Test",
      UnsafeUpdate:   "c_scale,w_103"})

cURL:

curl \
  -d 'unsafe_update=c_scale,w_103' \
  -X PUT \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/transformations/my_named

CLI:

cld admin update_transformation my_named unsafe_update='{"crop": "scale", "width": 103}'

Sample response

{
 "message": "updated"
}

Delete transformation

Delete a single transformation. Supply either the name of the transformation or the transformation parameters.

Note

Deleting a transformation also deletes all the derived images based on this transformation (up to 1000). The method returns an error if there are more than 1000 derived images based on this transformation.

Syntax

DELETE /transformations/:transformation

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.delete_transformation(transformation)

PHP (cloudinary_php v1.x (legacy)):

$api->delete_transformation($transformation);

Library:

PHP (cloudinary_php v2.x):

$api->deleteTransformation($transformation);

Library:

Python:

cloudinary.api.delete_transformation(transformation)

Node.js:

cloudinary.v2.api.delete_transformation(transformation, callback});

Java:

api.deleteTransformations(String transformation);

.NET:

cloudinary.DeleteTransform(transformation);

Go:

resp, err := cld.Admin.DeleteTransformation(ctx, admin.DeleteTransformationParams{})

CLI:

cld admin delete_transformation (transformation)

Required parameters

Parameter	Type	Description
transformation	String	The name of the transformation or the transformation parameters.

Examples

Delete transformation by name:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_transformation('w_150,h_100,c_fill')

PHP (cloudinary_php v1.x (legacy)):

$api->delete_transformation("w_150,h_100,c_fill");

Library:

PHP (cloudinary_php v2.x):

$api->deleteTransformation("w_150,h_100,c_fill");

Library:

Python:

cloudinary.api.delete_transformation("w_150,h_100,c_fill")

Node.js:

cloudinary.v2.api.delete_transformation('w_150,h_100,c_fill',
  function(error, result) {console.log(result, error); });

Java:

api.deleteTransformation("w_150,h_100,c_fill",
  ObjectUtils.emptyMap());

.NET:

cloudinary.DeleteTransform("w_150,h_100,c_fill");

Go:

resp, err := cld.Admin.DeleteTransformation(ctx, admin.DeleteTransformationParams{Transformation: "w_150,h_100,c_fill"})

cURL:

curl  \
  -X DELETE \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/transformations/w_150,h_100,c_fill

CLI:

cld admin delete_transformation "w_150,h_100,c_fill"

Delete transformation by parameters:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_transformation(:width => 150, :height => 100,
  :crop => :fill)

PHP (cloudinary_php v1.x (legacy)):

$api->delete_transformation(["width" => 150, "height" => 100,
  "crop" => "fill"]);

Library:

PHP (cloudinary_php v2.x):

$api->deleteTransformation(["width" => 150, "height" => 100,
  "crop" => "fill"]);

Library:

Python:

cloudinary.api.delete_transformation(dict(width = 150, height = 100,
  crop = "fill"))

Node.js:

cloudinary.v2.api.delete_transformation(
  {width: 150, height: 100, crop: 'fill'},
  function(error, result) {console.log(result, error); });

Java:

api.deleteTransformation(new Transformation().width(150).height(100).
  crop("fill").generate(), ObjectUtils.emptyMap());

.NET:

Not supported by this SDK

Go:

Not supported by this SDK

cURL:

curl \
  -X DELETE \  
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/transformations/c_fill,h_100,w_150

CLI:

cld admin delete_transformation '{"width": 150, "height": 100, "crop": "fill"}'

Sample response

{
 "message": "deleted"
}

Upload mappings

Dynamically fetches images from existing online locations and uploads the files to your account.

See the Auto upload remote files documentation for more information.

Method	Description
GET`/upload_mappings`	Get upload mappings
GET`/upload_mappings/:folder`	Get the details of a single upload mapping
POST`/upload_mappings`	Create an upload mapping
PUT`/upload_mappings`	Update an upload mapping
DELETE`/upload_mappings/:folder`	Delete an upload mapping

Get upload mappings

List all upload mappings by folder and includes its mapped template (URL).

Syntax

GET /upload_mappings

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.upload_mappings(options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->upload_mappings($options = []);

Library:

PHP (cloudinary_php v2.x):

$api->uploadMappings($options = []);

Library:

Python:

cloudinary.api.upload_mappings(**options)

Node.js:

cloudinary.v2.api.upload_mappings(options, callback);

Java:

api.uploadMappings(Map options);

.NET:

cloudinary.UploadMappings(uploadMappingParams params);

Go:

resp, err := cld.Admin.ListUploadMappings(ctx, admin.ListUploadMappingsParams{})

CLI:

cld admin upload_mappings

Optional parameters

Parameter	Type	Description
max_results	Integers	Maximum number of assets to return (up to 500). Default: `10`.
next_cursor	String	When a request has more results to return than `max_results`, the `next_cursor` value is returned as part of the response. You can then specify this value as the `next_cursor` parameter of a following request.

Examples

List all upload mappings

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.upload_mappings

PHP (cloudinary_php v1.x (legacy)):

$api->upload_mappings();

Library:

PHP (cloudinary_php v2.x):

$api->uploadMappings();

Library:

Python:

cloudinary.api.upload_mappings()

Node.js:

cloudinary.v2.api.upload_mappings(function(error, result){console.log(result);});

Java:

api.uploadMappings(ObjectUtils.emptyMap());

.NET:

cloudinary.UploadMappings();

Go:

resp, err := cld.Admin.ListUploadMappings(ctx, admin.ListUploadMappingsParams{})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/upload_mappings

CLI:

cld admin upload_mappings

Sample response

{
    "mappings": [
      {
        "folder": "wiki", 
        "template": "https://u.wiki.example.com/wiki-images/"
      },
      {
        "folder": "exam", 
        "template": "https://images.example.com/product_assets/images/"
      }, 
    ]
}

Get the details of a single upload mapping

Retrieve the mapped template (URL) of a given upload mapping folder.

Syntax

GET /upload_mappings/:folder

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.upload_mapping(folder)

PHP (cloudinary_php v1.x (legacy)):

$api->upload_mapping($folder);

Library:

PHP (cloudinary_php v2.x):

$api->uploadMapping($folder);

Library:

Python:

cloudinary.api.upload_mapping(folder)

Node.js:

cloudinary.v2.api.upload_mapping(folder, callback);

Java:

api.uploadMapping(String folder));

.NET:

cloudinary.UploadMapping(uploadMappingParams params);

Go:

resp, err := cld.Admin.GetUploadMapping(ctx, admin.GetUploadMappingParams{})

CLI:

cld admin upload_mapping (folder)

Required parameters

Parameter	Type	Description
folder	String	The name of the folder to map.

Examples

Upload mapping details by folder the 'wiki' folder:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.upload_mapping('wiki')

PHP (cloudinary_php v1.x (legacy)):

$api->upload_mapping("wiki");

Library:

PHP (cloudinary_php v2.x):

$api->uploadMapping("wiki");

Library:

Python:

cloudinary.api.upload_mapping("wiki")

Node.js:

cloudinary.v2.api.upload_mapping('wiki',
  function(error, result){console.log(result);});

Java:

api.uploadMapping("wiki",
  ObjectUtils.emptyMap());

.NET:

cloudinary.UploadMapping("wiki");

Go:

resp, err := cld.Admin.GetUploadMapping(ctx, admin.GetUploadMappingParams{Folder: "wiki"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/upload_mappings/wiki

CLI:

cld admin upload_mapping "wiki"

Sample response

{
    "folder": "wiki", 
    "template": "https://u.wiki.example.com/wiki-images/"
}

Create an upload mapping

Create a new upload mapping folder and its template (URL).

Syntax

POST /upload_mappings

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.create_upload_mapping(folder, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->create_upload_mapping(folder, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->createUploadMapping(folder, $options = []);

Library:

Python:

cloudinary.api.create_upload_mapping(folder, **options)

Node.js:

cloudinary.v2.api.create_upload_mapping(folder, options, callback);

Java:

api.createUploadMapping(String folder, Map options));

.NET:

cloudinary.CreateUploadMapping(uploadMappingParams params);

Go:

resp, err := cld.Admin.CreateUploadMapping(ctx, admin.CreateUploadMappingParams{})

CLI:

cld admin create_upload_mapping (folder)

Required parameters

Parameter	Type	Description
folder	String	The name of the folder to map.
template	String	The URL to be mapped to the folder, as part of `options`.

Examples

Create upload mapping from 'https://www.example.com/images/' to a folder called 'my_map':

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.create_upload_mapping("my_map",
  :template => "https://www.example.com/images/")

PHP (cloudinary_php v1.x (legacy)):

$api->create_upload_mapping("my_map",
  ["template" => "https://www.example.com/images/"]);

Library:

PHP (cloudinary_php v2.x):

$api->createUploadMapping("my_map",
  ["template" => "https://www.example.com/images/"]);

Library:

Python:

cloudinary.api.create_upload_mapping("my_map",
  template = "https://www.example.com/images/")

Node.js:

cloudinary.v2.api.create_upload_mapping('my_map',
  { template: "https://www.example.com/images/" },
  function(error, result){console.log(result);});

Java:

api.createUploadMapping("my_map",
  ObjectUtils.asMap("template", "https://www.example.com/images/"));

.NET:

cloudinary.CreateUploadMapping("my_map", "https://www.example.com/images/");

Go:

resp, err := cld.Admin.CreateUploadMapping(ctx, admin.CreateUploadMappingParams{
      Folder:     "my_map", 
      Template:   "https://www.example.com/images/"})

cURL:

curl \
 -d "folder=my_map&template=https://www.example.com/images/" \
 -X POST \
 https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/upload_mappings

CLI:

cld admin create_upload_mapping "my_map" template="https://www.example.com/images/"

Sample response

{
    "message": "created"
}

Update an upload mapping

Update an existing upload mapping folder with a new template (URL).

Syntax

PUT /upload_mappings

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.update_upload_mapping(folder, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->update_upload_mapping(folder, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->updateUploadMapping(folder, $options = []);

Library:

Python:

cloudinary.api.update_upload_mapping(folder, **options)

Node.js:

cloudinary.v2.api.update_upload_mapping(folder, options, callback);

Java:

api.updateUploadMapping(String folder, Map options));

.NET:

cloudinary.UpdateUploadMapping(uploadMappingParams params);

Go:

resp, err := cld.Admin.UpdateUploadMapping(ctx, admin.UpdateUploadMappingParams{})

CLI:

cld admin update_upload_mapping (folder)

Required parameters

Parameter	Type	Description
folder	String	The name of the folder to map.
template	String	The URL to be mapped to the folder, as part of `options`.

Examples

Update an upload mapping to the 'wiki' folder with the https://u.wiki.com/images/ URL:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.update_upload_mapping("wiki",
  :template => "https://u.wiki.com/images/")

PHP (cloudinary_php v1.x (legacy)):

$api->update_upload_mapping("wiki",
  ["template" => "https://u.wiki.com/images/"]);

Library:

PHP (cloudinary_php v2.x):

$api->updateUploadMapping("wiki",
  ["template" => "https://u.wiki.com/images/"]);

Library:

Python:

cloudinary.api.update_upload_mapping("wiki",
  template = "https://u.wiki.com/images/")

Node.js:

cloudinary.v2.api.update_upload_mapping('wiki',
  { template: "https://u.wiki.com/images/" },
  function(error, result){console.log(result);});

Java:

api.updateUploadMapping("wiki",
  ObjectUtils.asMap("template", "https://u.wiki.com/images/"), ObjectUtils.emptyMap());

.NET:

var uploadMappingParams = new UploadMappingParams(){
  Folder = "wiki",
  Template = "https://u.wiki.com/images/";
cloudinary.UploadMapping(uploadMappingParams);

Go:

resp, err := cld.Admin.UpdateUploadMapping(ctx, admin.UpdateUploadMappingParams{
        Folder:   "wiki",
        Template: "https://u.wiki.com/images/"})

cURL:

curl \
  -d "folder=wiki&template=https://u.wiki.com/images/" \
  -X PUT \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/upload_mappings

CLI:

cld admin update_upload_mapping "wiki" template="https://u.wiki.com/images/"

Sample response

{
    "message": "updated"
}

Delete an upload mapping

Delete an upload mapping by folder name.

Syntax

DELETE /upload_mappings/:folder

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.delete_upload_mapping(folder)

PHP (cloudinary_php v1.x (legacy)):

$api->delete_upload_mapping(folder);

Library:

PHP (cloudinary_php v2.x):

$api->deleteUploadMapping(folder);

Library:

Python:

cloudinary.api.delete_upload_mapping(folder)

Node.js:

cloudinary.v2.api.delete_upload_mapping(folder, callback);

Java:

api.deleteUploadMapping(String folder));

.NET:

cloudinary.DeleteUploadMapping(uploadMappingParams params);

Go:

resp, err := cld.Admin.DeleteUploadMapping(ctx, admin.DeleteUploadMappingParams{})

CLI:

cld admin delete_upload_mapping (folder)

Required parameters

Parameter	Type	Description
folder	String	The name of the folder to map.

Examples

Delete an upload mapping to the 'wiki' folder:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_upload_mapping('wiki')

PHP (cloudinary_php v1.x (legacy)):

$api->delete_upload_mapping("wiki");

Library:

PHP (cloudinary_php v2.x):

$api->deleteUploadMapping("wiki");

Library:

Python:

cloudinary.api.delete_upload_mapping("wiki")

Node.js:

cloudinary.v2.api.delete_upload_mapping('wiki',
  function(error, result){console.log(result);});

Java:

api.deleteUploadMapping("wiki",
  ObjectUtils.emptyMap());

.NET:

cloudinary.DeleteUploadMapping("wiki");

Go:

resp, err := cld.Admin.DeleteUploadMapping(ctx, admin.DeleteUploadMappingParams{Folder: "wiki"})

cURL:

curl \
  -X DELETE \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/upload_mappings/wiki

CLI:

cld admin delete_upload_mapping "wiki"

Sample response

{
    "message": "deleted"
}

Upload presets

Enables you to centrally define image upload options instead of specifying them in each upload call.

See the upload preset documentation for more information.

Method	Description
GET `/upload_presets`	Get upload presets
GET `/upload_presets/:name`	Get the details of a single upload preset
POST`/upload_presets`	Create an upload preset
PUT`/upload_presets/:name`	Update an upload preset
DELETE`/upload_presets/:name`	Delete an upload preset

Get upload presets

Lists the upload presets defined for your account.

Syntax

GET /upload_presets

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.upload_presets(options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->upload_presets($options = []);

Library:

PHP (cloudinary_php v2.x):

$api->uploadPresets($options = []);

Library:

Python:

cloudinary.api.upload_presets(**options)

Node.js:

cloudinary.v2.api.upload_presets(options, callback);

Java:

api.uploadPresets(Map options);

.NET:

cloudinary.ListUploadPresets(uploadPresetParams params);

Go:

resp, err := cld.Admin.ListUploadPresets(ctx, admin.ListUploadPresetsParams{})

CLI:

cld admin upload_presets

Optional parameters

Parameter	Type	Description
max_results	Integers	Maximum number of assets to return (up to 500). Default: `10`.
next_cursor	String	When a request has more results to return than `max_results`, the `next_cursor` value is returned as part of the response. You can then specify this value as the `next_cursor` parameter of a following request.

Examples

List all upload presets:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.upload_presets

PHP (cloudinary_php v1.x (legacy)):

$api->upload_presets();

Library:

PHP (cloudinary_php v2.x):

$api->uploadPresets();

Library:

Python:

cloudinary.api.upload_presets()

Node.js:

cloudinary.v2.api.upload_presets(function(error, result){console.log(result);});

Java:

api.uploadPresets(ObjectUtils.emptyMap());

.NET:

cloudinary.ListUploadPresets();

Go:

resp, err := cld.Admin.ListUploadPresets(ctx, admin.ListUploadPresetsParams{})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/upload_presets

CLI:

cld admin upload_presets

Sample response

{
    "presets": [
      {
        "name": "pd1e4lst",
        "unsigned": true,
        "settings": 
          {
            "transformation": "c_crop,g_custom/ar_1,c_pad,w_1.0"
          }
      }, 
      {
        "name": "remote_media",
        "unsigned": false,
        "settings": 
          {
            "tags": "test"
            "allowed_formats": "jpg,png",
            "eager": "c_fill,g_face,h_150,w_200"
          }
      }, 
    ]
}

Get the details of a single upload preset

Retrieves the details of an upload preset.

Syntax

GET /upload_presets/:name

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.upload_preset(name, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->upload_preset($name, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->uploadPreset($name, $options = []);

Library:

Python:

cloudinary.api.upload_preset(name, **options)

Node.js:

cloudinary.v2.api.upload_preset(name, options, callback);

Java:

api.uploadPreset(String name, Map options);

.NET:

cloudinary.GetUploadPreset(uploadPresetParams params);

Go:

resp, err := cld.Admin.GetUploadPreset(ctx, admin.GetUploadPresetParams{})

CLI:

cld admin upload_preset (name)

Required parameters

Parameter	Type	Description
name	String	The name of the upload preset.

Examples

Upload preset details for the 'remote_media' preset:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.upload_preset('remote_media')

PHP (cloudinary_php v1.x (legacy)):

$api->upload_preset("remote_media");

Library:

PHP (cloudinary_php v2.x):

$api->uploadPreset("remote_media");

Library:

Python:

cloudinary.api.upload_preset("remote_media")

Node.js:

cloudinary.v2.api.upload_preset('remote_media',
  function(error, result){console.log(result);});

Java:

api.uploadPreset("remote_media",
  ObjectUtils.emptyMap());

.NET:

cloudinary.GetUploadPreset("remote_media");

Go:

resp, err := cld.Admin.GetUploadPreset(ctx, admin.GetUploadPresetParams{Name: "remote_media"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/upload_presets/remote_media

CLI:

cld admin upload_preset "remote_media"

Sample response

{
    "name": "remote_media",
    "unsigned": false,
    "settings": 
      {
        "tags": "test",
        "allowed_formats": "jpg,png",
        "eager": "c_fill,g_face,h_150,w_200"
      }
}

Create an upload preset

Create a new upload preset.

Syntax

POST /upload_presets

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.create_upload_preset(options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->create_upload_preset($options = []);

Library:

PHP (cloudinary_php v2.x):

$api->createUploadPreset($options = []);

Library:

Python:

cloudinary.api.create_upload_preset(**options)

Node.js:

cloudinary.v2.api.create_upload_preset(options, callback);

Java:

api.createUploadPreset(Map options);

.NET:

cloudinary.CreateUploadPreset(uploadPresetParams params);

Go:

resp, err := cld.Admin.CreateUploadPresets(ctx, admin.CreateUploadPresetsParams{})

CLI:

cld admin create_upload_preset

Optional parameters

Parameter	Type	Description
name	String	The name to assign to the new upload preset. If not specified, a random name is generated. If the name is of an existing preset, it will be overwritten.
unsigned	Boolean	Whether this upload preset allows unsigned uploading to Cloudinary. Default: `false`.
disallow_public_id	Boolean	Whether this upload preset disables assigning a public_id in the upload call. Default: `false`.
live	Boolean	Whether to enable "live broadcast", so that the upload preset can be used for live streaming.
{Upload parameters}		The upload parameters to apply to assets uploaded with this preset.

Examples

Create a new upload preset called 'my_preset', that allows unsigned uploading, adds the tag 'remote' to uploaded images, and only allows the uploading of JPG and PNG image formats:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.create_upload_preset(
  :name => "my_preset",
  :unsigned => true, 
  :tags => "remote", 
  :allowed_formats => "jpg,png")

PHP (cloudinary_php v1.x (legacy)):

$api->create_upload_preset([
    "name" => "my_preset", 
    "unsigned" => true, 
    "tags" => "remote", 
    "allowed_formats" => "jpg,png"]);

Library:

PHP (cloudinary_php v2.x):

$api->createUploadPreset([
    "name" => "my_preset", 
    "unsigned" => true, 
    "tags" => "remote", 
    "allowed_formats" => "jpg,png"]);

Library:

Python:

cloudinary.api.create_upload_preset(
  name = "my_preset",
  unsigned = True, 
  tags = "remote", 
  allowed_formats = "jpg,png")

Node.js:

cloudinary.v2.api.create_upload_preset(
  { name: "my_preset", 
    unsigned: true, 
    tags: "remote", 
    allowed_formats: "jpg,png" },
  function(error, result){console.log(result);});

Java:

api.createUploadPreset(
  ObjectUtils.asMap(
    "name", "my_preset",
    "unsigned", true, 
    "tags" => "remote", 
    "allowed_formats" => "jpg,png"));

.NET:

var uploadPresetParams = new UploadPresetParams(){
  Name = "my_preset",
  Unsigned = true,
  Tags = "remote",
  AllowedFormats = "jpg,png"};
cloudinary.CreateUploadPreset(uploadPresetParams);

Go:

resp, err := cld.Admin.CreateUploadPreset(ctx, admin.CreateUploadPresetParams{
      Name:         "my_preset",
      Unsigned:     true,
      UploadParams: uploader.UploadParams{Tags: []string{"remote"}, AllowedFormats: []string{"jpg", "png"}}})

cURL:

curl \
  -d "name=my_preset&unsigned=true&tags=remote&allowed_formats=jpg,png" \
  -X POST \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/upload_presets

CLI:

cld admin create_upload_preset name="my_preset" unsigned="true" tags="remote" allowed_formats="jpg,png"

Sample response

{
    "message": "created"
}

Update an upload preset

Update an existing upload preset.

Syntax

PUT /upload_presets/:name

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.update_upload_preset(name, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->update_upload_preset($name, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->updateUploadPreset($name, $options = []);

Library:

Python:

cloudinary.api.update_upload_preset(name, **options)

Node.js:

cloudinary.v2.api.update_upload_preset(name, options, callback);

Java:

api.updateUploadPreset(String name, Map options);

.NET:

cloudinary.UpdateUploadPreset(uploadPresetParams params);

Go:

resp, err := cld.Admin.UpdateUploadPreset(ctx, admin.UpdateUploadPresetParams{})

CLI:

cld admin update_upload_preset (name)

Optional parameters

Parameter	Type	Description
name	String	The name of the upload preset.
unsigned	Boolean	Whether this upload preset allows unsigned uploading to Cloudinary. Default: `false`.
disallow_public_id	Boolean	Whether this upload preset disables assigning a public_id in the upload call. Default: `false`.
live	Boolean	Whether to enable "live broadcast", so that the upload preset can be used for live streaming.
{Upload parameters}		The upload parameters to apply to assets uploaded with this preset.

Examples

Update an upload preset called 'wiki', to allow unsigned uploading, add the tag 'remote' to uploaded images, and only allow the uploading of JPG and PNG image formats:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.update_upload_preset("wiki",
  :unsigned => true, 
  :tags => "remote", 
  :allowed_formats => "jpg,png")

PHP (cloudinary_php v1.x (legacy)):

$api->update_upload_preset("wiki", [
    "unsigned" => true, 
    "tags" => "remote", 
    "allowed_formats" => "jpg,png"]);

Library:

PHP (cloudinary_php v2.x):

$api->updateUploadPreset("wiki", [
    "unsigned" => true, 
    "tags" => "remote", 
    "allowed_formats" => "jpg,png"]);

Library:

Python:

cloudinary.api.update_upload_preset("wiki",
  unsigned = True, 
  tags = "remote", 
  allowed_formats = "jpg,png")

Node.js:

cloudinary.v2.api.update_upload_preset('wiki',
  { unsigned: true,
    tags: "remote", 
    allowed_formats: "jpg,png"},
  function(error, result){console.log(result);});

Java:

api.updateUploadPreset("wiki",
  ObjectUtils.asMap(
    "unsigned", true, 
    "tags" => "remote", 
    "allowed_formats" => "jpg,png"));

.NET:

var uploadPresetParams = new UploadPresetParams(){
  Name = "wiki",
  Unsigned = true,
  Tags = "remote",
  AllowedFormats = "jpg,png"};
cloudinary.UpdateUploadPreset(uploadPresetParams);

Go:

resp, err := cld.Admin.UpdateUploadPreset(ctx, admin.UpdateUploadPresetParams{
      Name:         "wiki",
      Unsigned:     true,
      UploadParams: uploader.UploadParams{Tags: []string{"remote"}, AllowedFormats: []string{"jpg", "png"}}})

cURL:

curl \
  -d "unsigned=true&tags=remote&allowed_formats=jpg,png" \
  -X PUT \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/upload_presets/wiki

CLI:

cld admin update_upload_preset "wiki" unsigned="true" tags="remote" allowed_formats="jpg,png"

Sample response

{
    "message": "updated"
}

Delete an upload preset

Delete an existing upload preset.

Syntax

DELETE /upload_presets/:name

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.delete_upload_preset(name)

PHP (cloudinary_php v1.x (legacy)):

$api->delete_upload_preset($name);

Library:

PHP (cloudinary_php v2.x):

$api->deleteUploadPreset($name);

Library:

Python:

cloudinary.api.delete_upload_preset(name)

Node.js:

cloudinary.v2.api.delete_upload_preset(name, callback);

Java:

api.deleteUploadPreset(String name));

.NET:

cloudinary.DeleteUploadPreset(String name);

Go:

resp, err := cld.Admin.DeleteUploadPreset(ctx, admin.DeleteUploadPresetParams{})

CLI:

cld admin delete_upload_preset (name)

Required parameters

Parameter	Type	Description
name	String	The name of the upload preset.

Examples

Delete an upload preset called 'remote_media':

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_upload_preset('remote_media')

PHP (cloudinary_php v1.x (legacy)):

$api->delete_upload_preset("remote_media");

Library:

PHP (cloudinary_php v2.x):

$api->deleteUploadPreset("remote_media");

Library:

Python:

cloudinary.api.delete_upload_preset("remote_media")

Node.js:

cloudinary.v2.api.delete_upload_preset('remote_media',
  function(error, result){console.log(result);});

Java:

api.deleteUploadPreset("remote_media",
  ObjectUtils.emptyMap());

.NET:

cloudinary.DeleteUploadPreset("remote_media");

Go:

resp, err := cld.Admin.DeleteUploadPreset(ctx, admin.DeleteUploadPresetParams{Name: "remote_media"})

cURL:

curl \
  -X DELETE \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<cloud_name>/upload_presets/remote_media

CLI:

cld admin delete_upload_preset "remote_media"

Sample response

{
    "message": "deleted"
}

Metadata

Enables you to manage the metadata fields available for your account.

See the Metadata API documentation for detailed information on the the following Metadata methods, as well as detailed information on the Metadata field structure, including how to work with field validation and list (datasource) values:

Method	Description
GET`/metadata_fields`	Get metadata fields
GET`/metadata_fields/:external_id`	Get a metadata field by external id
POST`/metadata_fields`	Create a metadata field
POST`/metadata_fields/:external_id/datasource_restore`	Restore entries in a metadata field datasource
PUT`/metadata_fields/:external_id`	Update a metadata field by external id
PUT`/metadata_fields/:external_id/datasource`	Update a metadata field datasource
DELETE`/metadata_fields/:external_id`	Delete a metadata field by external id
DELETE`/metadata_fields/:external_id/datasource`	Delete entries in a metadata field datasource

Folders

Enables you to manage folders for your account.

Method	Description
GET`/folders`	Get root folders
GET`/folders/:folder`	Get subfolders
POST`/folders/:folder`	Create a folder
DELETE`/folders/:folder`	Delete a folder

Get root folders

Lists all the root folders. Limited to 2000 results.

Syntax

GET /folders

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.root_folders

PHP (cloudinary_php v1.x (legacy)):

$api->root_folders();

Library:

PHP (cloudinary_php v2.x):

$api->rootFolders();

Library:

Python:

cloudinary.api.root_folders()

Node.js:

cloudinary.v2.api.root_folders(callback);

Java:

api.rootFolders(ObjectUtils.emptyMap());

.NET:

cloudinary.RootFolders();

Go:

resp, err := cld.Admin.RootFolders(ctx, admin.RootFoldersParams{})

CLI:

cld admin root_folders

Sample response

The response contains an array of all the root folders.

{
    "folders": [
      {
        "name": "cloud",
        "path": "cloud"
      }, 
      {
        "name": "brooks",
        "path": "brooks"
      }   
    ]
}

Get subfolders

Lists the name and path of all the subfolders of a given folder. Limited to 2000 results.

Syntax

GET /folders/:folder

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.subfolders(folder, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->subfolders($folder, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->subfolders($folder, $options = []);

Library:

Python:

cloudinary.api.subfolders(folder, **options)

Node.js:

cloudinary.v2.api.sub_folders(folder, options, callback);

Java:

api.subfolders(String folder, Map options);

.NET:

cloudinary.SubFolders(folderParams params);

Go:

resp, err := cld.Admin.SubFolders(ctx, admin.SubFoldersParams{})

CLI:

cld admin subfolders (folder)

Required parameters

Parameter	Type	Description
folder	String	The full path of the folder to return subfolders of.

Optional parameters

Parameter	Type	Description
max_results	Integers	Maximum number of results to return (up to 500). Default: `10`.
next_cursor	String	When a request has more results to return than `max_results`, the `next_cursor` value is returned as part of the response. You can then specify this value as the `next_cursor` parameter of a following request.

Examples

List all subfolders of a given folder 'product/shoe':

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.subfolders("product/shoe")

PHP (cloudinary_php v1.x (legacy)):

$api->subfolders("product/shoe");

Library:

PHP (cloudinary_php v2.x):

$api->subfolders("product/shoe");

Library:

Python:

cloudinary.api.subfolders("product/shoe")

Node.js:

cloudinary.v2.api.sub_folders("product/shoe", function(error, result){console.log(result);});

Java:

api.subfolders("product/shoe", ObjectUtils.emptyMap());

.NET:

cloudinary.SubFolders("product/shoe");

Go:

resp, err := cld.Admin.SubFolders(ctx, admin.SubFoldersParams{"product/shoe"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/folders/product/shoe

CLI:

cld admin subfolders "product/shoe"

Sample response

The response contains an array of all the subfolders of the given folder.

{
    "folders": [
      {
        "name": "red",
        "path": "product/shoe/red"
      }, 
      {
        "name": "white",
        "path": "product/shoe/white"
      }   
    ]
 }

Create folder

Create a new empty folder.

Syntax

POST /folders/:folder

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.create_folder(folder)

PHP (cloudinary_php v1.x (legacy)):

$api->create_folder($folder);

Library:

PHP (cloudinary_php v2.x):

$api->createFolder($folder);

Library:

Python:

cloudinary.api.create_folder(folder)

Node.js:

cloudinary.v2.api.create_folder(folder, callback);

Java:

api.createFolder(String folder, Map options);

.NET:

cloudinary.CreateFolder(folder);

Go:

resp, err := cld.Admin.CreateFolder(ctx, admin.CreateFolderParams{})

CLI:

cld admin create_folder $folder

Required parameters

Parameter	Type	Description
folder	String	The full path of the new folder to create.

Examples

Create a new folder called 'test' as a subfolder of the root folder 'product' ('product/test'):

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.create_folder("product/test")

PHP (cloudinary_php v1.x (legacy)):

$api->create_folder("product/test");

Library:

PHP (cloudinary_php v2.x):

$api->createFolder("product/test");

Library:

Python:

cloudinary.api.create_folder("product/test")

Node.js:

cloudinary.v2.api.create_folder("product/test", function(error, result){console.log(result);});

Java:

api.createFolder("product/test", ObjectUtils.emptyMap());

.NET:

cloudinary.CreateFolder("product/test");

Go:

resp, err := cld.Admin.CreateFolder(ctx, admin.CreateFolderParams{Folder: "product/test"})

cURL:

curl \
  -X POST
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/folders/product/test

CLI:

cld admin create_folder "product/test"

Sample response

{
    "success": true,
    "path": "product/test",
    "name": "test"
}

Delete folder

Deletes an empty folder.

Note

Use the Delete resources method to delete the assets within a folder.

Syntax

DELETE /folders/:folder

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.delete_folder(folder)

PHP (cloudinary_php v1.x (legacy)):

$api->delete_folder($folder);

Library:

PHP (cloudinary_php v2.x):

$api->deleteFolder($folder);

Library:

Python:

cloudinary.api.delete_folder(folder)

Node.js:

cloudinary.v2.api.delete_folder(folder, callback);

Java:

api.deleteFolder(String folder, Map options);

.NET:

cloudinary.DeleteFolder(folder);

Go:

resp, err := cld.Admin.DeleteFolder(ctx, admin.DeleteFolderParams{})

CLI:

cld admin delete_folder (folder)

Required parameters

Parameter	Type	Description
folder	String	The full path of the empty folder to delete.

Examples

Delete a folder called 'test' which is a subfolder of the root folder 'product' ('product/test'):

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.delete_folder("product/test")

PHP (cloudinary_php v1.x (legacy)):

$api->delete_folder("product/test");

Library:

PHP (cloudinary_php v2.x):

$api->deleteFolder("product/test");

Library:

Python:

cloudinary.api.delete_folder("product/test")

Node.js:

cloudinary.v2.api.delete_folder("product/test", function(error, result){console.log(result);});

Java:

api.deleteFolder("product/test", ObjectUtils.emptyMap());

.NET:

cloudinary.DeleteFolder("product/test");

Go:

resp, err := cld.Admin.DeleteFolder(ctx, admin.DeleteFolderParams{Folder: "product/test"})

cURL:

curl \
  -X DELETE \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/folders/product/test

CLI:

cld admin delete_folder "product/test"

Sample response

{
    "deleted": [
        "product/test"
    ]
}

Adaptive streaming profiles

Enables you to list, get details of, create, modify, or delete built-in and custom adaptive streaming profiles, which can be used to deliver your video using HLS and MPEG-DASH adaptive bitrate streaming.

Method	Description
GET`/streaming_profiles`	Get adaptive streaming profiles
GET`/streaming_profiles/:name`	Get details of a streaming profile
POST`/streaming_profiles`	Create a streaming profile
PUT`/streaming_profiles/:name`	Update an existing streaming profile
DELETE`/streaming_profiles/:name`	Delete or revert the specified streaming profile

Get adaptive streaming profiles

List streaming profiles, including built-in and custom profiles.

Syntax

GET /streaming_profiles

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.list_streaming_profiles

PHP (cloudinary_php v1.x (legacy)):

$api->list_streaming_profiles();

Library:

PHP (cloudinary_php v2.x):

$api->listStreamingProfiles();

Library:

Python:

cloudinary.api.list_streaming_profiles()

Node.js:

cloudinary.v2.api.list_streaming_profiles(callback);

Java:

api.listStreamingProfiles();

.NET:

cloudinary.ListStreamingProfiles()

Go:

resp, err := cld.Admin.ListStreamingProfiles(ctx, admin.ListStreamingProfilesParams{})

CLI:

cld admin list_streaming_profiles

Sample response

The response contains an array of all the defined streaming profiles.

{
  "data": [
    {
      "name": "4k",
      "display_name": "4K (2160p)",
      "predefined": true
    },
    {
      "name": "full_hd",
      "display_name": "Full HD (1080p)",
      "predefined": true
    },
    {
      "name": "hd",
      "display_name": "HD (720p)",
      "predefined": true
    },
    {
      "name": "sd",
      "display_name": "SD (480p)",
      "predefined": true
    },
    {
      "name": "full_hd_wifi",
      "display_name": "Full HD WiFi (1080p)",
      "predefined": true
    },
    {
      "name": "full_hd_lean",
      "display_name": "Full HD Lean (1080p)",
      "predefined": true
    },
    {
      "name": "hd_lean",
      "display_name": "HD Lean (720p)",
      "predefined": true
    },
    {
      "name": "custom_square",
      "display_name": "Custom square resolution",
      "predefined": false
    }
  ]
}

Get details of a single streaming profile

Retrieve the details of a single streaming profile by name.

Syntax

GET /streaming_profiles/:name

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.get_streaming_profile(name)

PHP (cloudinary_php v1.x (legacy)):

$api->get_streaming_profile($name);

Library:

PHP (cloudinary_php v2.x):

$api->getStreamingProfile($name);

Library:

Python:

cloudinary.api.get_streaming_profile(name)

Node.js:

cloudinary.v2.api.get_streaming_profile(name, callback);

Java:

api.getStreamingProfile(String name);

.NET:

cloudinary.GetStreamingProfile(name)

Go:

resp, err := cld.Admin.GetStreamingProfile(ctx, admin.GetStreamingProfileParams{})

CLI:

cld admin get_streaming_profile (name)

Required parameters

Parameter	Type	Description
name	String	The name of the streaming profile to get the details of.

Examples

Get the details of a specified streaming file:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.get_streaming_profile('custom_square')

PHP (cloudinary_php v1.x (legacy)):

$api->get_streaming_profile("custom_square");

Library:

PHP (cloudinary_php v2.x):

$api->getStreamingProfile("custom_square");

Library:

Python:

cloudinary.api.get_streaming_profile("custom_square")

Node.js:

cloudinary.v2.api.get_streaming_profile('custom_square', function(error, result){console.log(result);});

Java:

api.getStreamingProfile("custom_square");

.NET:

cloudinary.GetStreamingProfile("custom_square")

Go:

resp, err := cld.Admin.GetStreamingProfile(ctx, admin.GetStreamingProfileParams{Name: "custom_square"})

cURL:

curl https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/streaming_profiles/custom_square

CLI:

cld admin get_streaming_profile "custom_square"

Sample response

The response contains details for a single streaming profile.

{
 "data": {
   "name": "custom_square",
   "display_name": "Custom square resolution",
   "predefined": false,
   "representations": [
     {
       "transformation": {
         "width": 1200, "height": 1200, "bit_rate": "5m", "video_codec": "h264:main:3.1"
       }
     },
     {
       "transformation": {
         "width": 900, "height": 900, "bit_rate": "3500k", "video_codec": "h264:main:3.1"
       }
     },
     {
       "transformation": {
         "width": 600, "height": 600, "bit_rate": "1500k", "video_codec": "h264:baseline:3.0"
       }
     }
   ]
 }
}

Create a streaming profile

Create a new, custom streaming profile.

Syntax

POST /streaming_profiles

Ruby PHP Python Node.js Java .NET Go CLI All

Ruby:

Cloudinary::Api.create_streaming_profile(name, options = {})

PHP (cloudinary_php v1.x (legacy)):

$api->create_streaming_profile($name, $options = []);

Library:

PHP (cloudinary_php v2.x):

$api->createStreamingProfile($name, $options = []);

Library:

Python:

cloudinary.api.create_streaming_profile(name, **options)

Node.js:

cloudinary.v2.api.create_streaming_profile(name, options, callback);

Java:

:
api.createStreamingProfile(String name, Map options);

.NET:

cloudinary.CreateStreamingProfile(StreamingProfileCreateParams params);

Go:

resp, err := cld.Admin.CreateStreamingProfile(ctx, admin.CreateStreamingProfileParams{})

CLI:

cld admin create_streaming_profile (name)

Required parameters

Parameter	Type	Description
name	String	The identification name to assign to the new streaming profile. The name is case-insensitive and can contain alphanumeric characters, underscores (_) and hyphens (-).
representations	JSON string	An array of structures that defines a custom streaming profile.
transformation	String or Hash	Specifies the transformation parameters for the representation. All video transformation parameters except `video_sampling` are supported. Common transformation parameters for representations include: `width`, `height` (or `aspect_ratio`), `bit_rate`, `video_codec`, `audio_codec`, `sample_rate` (or `fps`), etc.

Optional parameters

Parameter	Type	Description
display_name	String	A descriptive name for the profile.

Examples

Create a streaming profile with 3 representations:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.create_streaming_profile("custom_square",
  :display_name => "Custom square resolution",
  :representations =>
    [{:transformation => {:crop => "limit", :width => "1200", :height => "1200", :bit_rate => "5m"}},
     {:transformation => {:crop => "limit", :width => "900", :height => "900", :bit_rate => "3500k"}}
     {:transformation => {:crop => "limit", :width => "600", :height => "600", :bit_rate => "1500k"}}])

PHP (cloudinary_php v1.x (legacy)):

$api->create_streaming_profile("custom_square", [
    "display_name" => "Custom square resolution",
    "representations" => [
      ["crop" => "limit", "width" => 1200, "height" => 1200, "bit_rate" => "5m"],
      ["crop" => "limit", "width" => 900, "height" => 900, "bit_rate" => "3500k"],
      ["crop" => "limit", "width" => 600, "height" => 600, "bit_rate" => "1500k"]]]);

Library:

PHP (cloudinary_php v2.x):

$api->createStreamingProfile("custom_square", [
    "display_name" => "Custom square resolution",
    "representations" => [
      ["crop" => "limit", "width" => 1200, "height" => 1200, "bit_rate" => "5m"],
      ["crop" => "limit", "width" => 900, "height" => 900, "bit_rate" => "3500k"],
      ["crop" => "limit", "width" => 600, "height" => 600, "bit_rate" => "1500k"]]]);

Library:

Python:

cloudinary.api.create_streaming_profile("custom_square",
  display_name="Custom square resolution",
  representations=[
    {"transformation": {"crop": "limit", "width": 1200, "height": 1200, "bit_rate": "5m"}},
    {"transformation": {"crop": "limit", "width": 900, "height": 900, "bit_rate": "3500k"}},
    {"transformation": {"crop": "limit", "width": 600, "height": 600, "bit_rate": "1500k"}}])

Node.js:

cloudinary.v2.api.create_streaming_profile('custom_square',
  { display_name: "Custom square resolution",
    representations: [
    { transformation:{crop: "limit", width: 1200, height: 1200, bit_rate: "5m" }},
    { transformation:{crop: "limit", width: 900, height: 900, bit_rate: "3500k" }},
    { transformation:{crop: "limit", width: 600, height: 600, bit_rate: "1500k" }}] },
  function(error, result){console.log(result);});

Java:

:
api.createStreamingProfile("custom_square", "Custom square resolution",
  Arrays.asList(
    ObjectUtils.asMap("transformation", new 
      Transformation().crop("limit").width(1200).height(1200).bitRate("5m")),
    ObjectUtils.asMap("transformation", new 
      Transformation().crop("limit").width(900).height(900).bitRate("3500k")),
    ObjectUtils.asMap("transformation", new 
      Transformation().crop("limit").width(600).height(600).bitRate("1500k"))));

.NET:

var streamingProfileParams = new StreamingProfileCreateParams()
  {
    Name = "custom_square",
    DisplayName = "Custom square resolution",
    Representations = new List<Representation>
      {
        new Representation {Transformation = new Transformation().Crop("limit").Width(1200).Height(1200).BitRate("5m")},
        new Representation {Transformation = new Transformation().Crop("limit").Width(900).Height(900).BitRate("3500k")},
        new Representation {Transformation = new Transformation().Crop("limit").Width(600).Height(600).BitRate("1500k")}
      }
  };
cloudinary.CreateStreamingProfile(streamingProfileParams);

Go:

resp, err := cld.Admin.CreateStreamingProfile(ctx, admin.CreateStreamingProfileParams{
      Name:        "custom_square",
      DisplayName: "Custom square resolution",
      Representations: admin.StreamingProfileRepresentations{
          {Transformation: "c_limit,w_1200,h_1200,br_5m"},
          {Transformation: "c_limit,w_900,h_900,br_3500k"},
          {Transformation: "c_limit,w_600,h_600,br_1500k"},
        }})

cURL:

curl \
  -d 'name=custom_square&display_name=Custom%20square%20resolution&representations=\[\{%22transformation%22:%22c_limit,w_1200,h_1200,br_5m%22\},\{%22transformation%22:%22c_limit,w_900,h_900,br_3500k%22\},\{%22transformation%22:%22c_limit,w_600,h_600,br_1500k%22\}\]'
  -X POST \
  https://<API_KEY>:<API_SECRET>@api.cloudinary.com/v1_1/<CLOUD_NAME>/streaming_profiles

CLI:

cld admin create_streaming_profile "custom_square" display_name="Custom square resolution" representations='[{"transformation": {"crop": "limit","width": 1200, "height": 1200, "bit_rate": "5m"}},{"transformation": {"crop": "limit", "width": 900, "height": 900, "bit_rate": "3500k"}},{"transformation": {"crop": "limit", "width": 600, "height": 600, "bit_rate": "1500k"}}]'

Sample response

The response contains details for the streaming profile that was created.

{
 "data": {
   "name": "custom_square",
   "display_name": "Custom square resolution",
   "predefined": false,
   "representations": [
     {
       "transformation": {
         "width": 1200, "height": 1200, "bit_rate": "5m", "video_codec": "h264:main:3.1"
       }
     },
     {
       "transformation": {
         "width": 900, "height": 900, "bit_rate": "3500k", "video_codec": "h264:main:3.1"
       }
     },
     {
       "transformation": {
         "width": 600, "height": 600, "bit_rate": "1500k", "video_codec": "h264:baseline:3.0"
       }
     }
   ]
 }
}

Create a streaming profile with 6 representations and a combination of codecs:

Ruby PHP Python Node.js Java .NET Go cURL CLI All

Ruby:

Cloudinary::Api.create_streaming_profile("custom_square_combo",
  :display_name => "Custom square resolution with combination of codecs",
  :representations =>
    [{:transformation => {:crop => "limit", :width => "1200", :height => "1200", :video_codec => "h265", :bit_rate => "5m"}},
     {:transformation => {:crop => "limit", :width => "900", :height => "900", :video_codec => "h265", :bit_rate => "3500k"}},
     {:transformation => {:crop => "limit", :width => "600", :height => "600", :video_codec => "h265", :bit_rate => "1500k"}},
     {:transformation => {:crop => "limit", :width => "1200", :height => "1200", :video_codec => "vp9", :bit_rate => "5m"}},
     {:transformation => {:crop => "limit", :width => "900", :height => "900", :video_codec => "vp9", :bit_rate => "3500k"}}
     {:transformation => {:crop => "limit", :width => "600", :height => "600", :video_codec => "vp9", :bit_rate => "1500k"}}])

PHP (cloudinary_php v1.x (legacy)):

$api->create_streaming_profile("custom_square_combo", [
    "display_name" => "Custom square resolution with combination of codecs",
    "representations" => [
      ["crop" => "limit", "width" => 1200, "height" => 1200, "video_codec" => "h265", "bit_rate" => "5m"],
      ["crop" => "limit", "width" => 900, "height" => 900, "video_codec" => "h265", "bit_rate" => "3500k"],
      ["crop" => "limit", "width" => 600, "height" => 600, "video_codec" => "h265", "bit_rate" => "1500k"],
      ["crop" => "limit", "width" => 1200, "height" => 1200, "video_codec" => "vp9", "bit_rate" => "5m"],
      ["crop" => "limit", "width" => 900, "height" => 900, "video_codec" => "vp9", "bit_rate" => "3500k"],
      ["crop" => "limit", "width" => 600, "height" => 600, "video_codec" => "vp9", "bit_rate" => "1500k"]]);

Library:

PHP (cloudinary_php v2.x):

$api->createStreamingProfile("custom_square_combo", [
    "display_name" => "Custom square resolution with combination of codecs",
    "representations" => [
      ["crop" => "limit", "width" => 1200, "height" => 1200, "video_codec" => "h265", "bit_rate" => "5m"],
      ["crop" => "limit", "width" => 900, "height" => 900, "video_codec" => "h265", "bit_rate" => "3500k"],
      ["crop" => "limit", "width" => 600, "height" => 600, "video_codec" => "h265", "bit_rate" => "1500k"],
      ["crop" => "limit", "width" => 1200, "height" => 1200, "video_codec" => "vp9", "bit_rate" => "5m"],
      ["crop" => "limit", "width" => 900, "height" => 900, "video_codec" => "vp9", "bit_rate" => "3500k"],
      ["crop" => "limit", "width" => 600, "height" => 600, "video_codec" => "vp9", "bit_rate" => "1500k"]]);

Library:

Python:

cloudinary.api.create_streaming_profile("custom_square_combo",
  display_name="Custom square resolution with combination of codecs",
  representations=[
    {"transformation": {"crop": "limit", "width": 1200, "height": 1200, "video_codec": "h265", "bit_rate": "5m"}},
    {"transformation": {"crop": "limit", "width": 900, "height": 900, "video_codec": "h265", "bit_rate": "3500k"}},
    {"transformation": {"crop": "limit", "width": 600, "height": 600, "video_codec": "h265", "bit_rate": "1500k"}},
    {"transformation": {"crop": "limit", "width": 1200, "height": 1200, "video_codec": "vp9", "bit_rate": "5m"}},
    {"transformation": {"crop": "limit", "width": 900, "height": 900, "video_codec": "vp9", "bit_rate": "3500k"}},
    {"transformation": {"crop": "limit", "width": 600, "height": 600, "video_codec": "vp9", "bit_rate": "1500k"}}])

Node.js:

cloudinary.v2.api.create_streaming_profile('custom_square_combo',
  { display_name: "Custom square resolution with combination of codecs",
    representations: [
    { transformation:{crop: "limit", width: 1200, height: 1200, video_codec: "h265", bit_rate: "5m" }},
    { transformation:{crop: "limit", width: 900, height: 900, video_codec: "h265", bit_rate: "3500k" }},
    { transformation:{crop: "limit", width: 600, height: 600, video_codec: "h265", bit_rate: "1500k" }},
    { transformation:{crop: "limit", width: 1200, height: 1200, video_codec: "vp9", bit_rate: "5m" }},
    { transformation:{crop: "limit", width: 900, height: 900, video_codec: "vp9", bit_rate: "3500k" }},
    { transformation:{crop: "limit", width: 600, height: 600, video_codec: "vp9", bit_rate: "1500k" }}] },
  function(error, result){console.log(result);});

Java:

:
api.createStreamingProfile("custom_square_combo", "Custom square resolution with combination of codecs",
  Arrays.asList(
    ObjectUtils.asMap("transformation", new 
      Transformation().crop("limit").width(1200).height(1200).videoCodec("h265").bitRate("5m")),
    ObjectUtils.asMap("transformation", new 
      Transformation().crop("limit").width(900).height(900).videoCodec("h265").bitRate("3500k")),
    ObjectUtils.asMap("transformation", new 
      Transformation().crop("limit").width(600).height(600).videoCodec("h265").bitRate("1500k")),
    ObjectUtils.asMap("transformation", new 
      Transformation().crop("limit").width(1200).height(1200).videoCodec("vp9").bitRate("5m")),
    ObjectUtils.asMap("transformation", new 
      Transformation().crop("limit").width(900).height(900).videoCodec("vp9").bitRate("3500k")),
    ObjectUtils.asMap("transformation", new 
      Transformation().crop("limit").width(600).height(600).videoCodec("vp9").bitRate("1500k"))));

.NET:

var streamingProfileParams = new StreamingProfileCreateParams()
  {
    Name = "custom_square",
    DisplayName = "Custom square resolution",
    Representations = new List<Representation>
      {
        new Representation {Transformation = new Transformation().Crop("limit").Width(1200).Height(1200).BitRate("5m")},
        new Representation {Transformation = new Transformation().Crop("limit").Width(900).Height(900).BitRate("3500k")},
        new Representation {Transformation = new Transformation().Crop("limit").Width(600).Height(600).BitRate("1500k")}
        new Representation { Transformation = new Transformation().Crop("limit").Width(1200).Height(1200).VideoCodec("vp9").BitRate("5m")},
        new Representation { Transformation = new Transformation().Crop("limit").Width(900).Height(900).VideoCodec("vp9").BitRate("3500k")},
        new Representation { Transformation = new Transformation().Crop("limit").Width(600).Height(600).VideoCodec("vp9").BitRate("1500k")}
      }
  };
cloudinary.CreateStreamingProfile(streamingProfileParams);

Go:

resp, err := cld.Admin.CreateStreamingProfile(ctx, admin.CreateStreamingProfileParams{
      Name:        "custom_square",
      DisplayName: "Custom square resolution",
      Representations: admin.StreamingProfileRepresentations{
          {Transformation: "c_limit,w_1200,h_1200,vc_h265,br_5m"},
          {Transformation: "c_limit,w_900,h_900,vc_h265,br_3500k"},
          {Transformation: "c_limit,w_600,h_600,vc_h265,br_1500k&quo