Media Library Widget

By integrating the Cloudinary Media Library widget into your CMS or any other web application, all your users can easily select images, videos, PDFs, or other stored raw files directly from a Cloudinary account and insert them in a way that exactly fits your application design, required behavior, and overall workflow.

The integration involves only a few lines of code and provides you (and your users) all the benefits of Cloudinary's responsive Media Library UI with its rich search capabilities and optimized media asset delivery.

Media library widget features

This JavaScript-based integration includes many configuration options, including:

• Set the Media Library to open as a modal dialog or inline in your application.
• Control whether users can insert one asset at a time or many.
• Set up default transformations to be applied to all selected assets.
  This can be useful to ensure usage of consistent size, quality, format, or other optimization settings, adding a logo overlay, or other applying styles to ensure consistency of the media delivered via your application. If the user also defines transformations, the default transformations are applied (chained) to their transformations.
• Customize elements of the widget look and feel, such as supplying a custom button class, customizing various button captions, or hiding the Cloudinary logo banner when opening the widget inline in your application.
• Open the Media Library directly to a specified state, such as opening to a specific folder, or opening a specific asset.
• Enable users to seamlessly log in to Cloudinary via authentication signature (included) or via your organization's SAML-based SSO provider (premium feature).

How to integrate the widget in your app

Integration overview

The following steps summarize the process of integrating the Cloudinary Media Library widget into a page in your application. Click the links for detailed implementation information.

1. Include the required JavaScript - Include Cloudinary's all.js file in the page where you want to open the Media Library.
2. Optional. Generate the authentication signature - To seamlessly and securely log a user into Cloudinary so that they can use the Media Library widget directly from the application hosting the widget, you can generate and pass an SHA-256 encrypted signature based on the cloud name, user name, a timestamp, and your account's API secret.
3. Set the configuration options - When you call the method to initialize and/or open the Media Library widget, you pass it a set of configuration options. These options include the mandatory cloud_name and api_key options. Additionally, you can provide a number of optional parameters that control settings such as those described in the introduction above.
4. Create your callback function - After a user selects media assets and closes the Media Library, the widget returns a JSON payload that includes the URL(s) of the selected asset(s) as well as other asset data such as file and pixel size, format, asset type (image, video, raw, etc), and more. You should create an insertHandler callback function that receives and handles this data to control how the selected assets will be integrated into your page.
5. Instantiate and open the Media Library widget instance - Now that you've set up the configuration options, and created the callback function, you pass these to the createMediaLibrary or openMediaLibrary method, which instantiates, or instantiates and opens, the widget.
6. Optional. Set up SAML authentication. As an alternative to generating and passing an authentication signature, you can enable (or require) your users to log in to Cloudinary via your SAML-based SSO provider. If your users already log in using SSO for the CMS or web app that will host the Media Library widget, this option can provide a seamless experience.
7. Optional. Define the Cloudinary log out policy - You can log the user out of Cloudinary when they log out of your CMS, or at any time, using the Cloudinary logout endpoint.

cld make media_library_widget

1. Include the required JavaScript

Add the following line to the web page where you want to open the Media Library widget:

<script src="https://media-library.cloudinary.com/global/all.js"></script>

2. Optional. Generate the authentication signature

To seamlessly and securely log a user into Cloudinary so that they can use the Media Library widget directly from the application hosting the widget, you can generate and pass an SHA-256 encrypted signature based on the cloud name, user name, a timestamp, and your account's API secret.

1. Create a string with the parameters and values to sign in the format:
   cloud_name=value&timestamp=unixtime&username=clduser@domain.comapisecret

   • The parameters are listed in alphabetical order. Parameter names are separated from their values with =. Parameter/value pairs are joined with &.
   • apisecret in the syntax above represents your account API secret, appended directly after the last parameter without a separator.
   • unixtime indicates the exact time (in UNIX format) when the signature will become valid. The signature can be used to initialize the widget (and log into Cloudinary) for up to 1 hour after the timestamp value, so make sure the timestamp value will be calculated close to the time of widget instantiation. Once the user is logged in, their session will remain active with no expiration time. (Use the logout endpoint to log a user out of the Cloudinary account.)

     
     For example: "cloud_name=my_company&timestamp=1518601863&username=jane@mycompany.comabcd"

2. Encrypt the signature string using SHA-256 hexadecimal hashing.
   For example, the above string results in: 5CBC5A2A695CBDA4FAE85DE692D446AF68B96C6C81DB4EB9DD2F63AF984FB247.

3. Set the configuration options

When you call the openMediaLibrary() or createMediaLibrary() method, you pass it a set of configuration options. These options include the mandatory cloud_name and api_key options. Additionally, you can include a variety of optional settings that control the behavior and look and feel of the widget, as shown below.

You can also optionally adjust the values of the Media library behavior options shown below when re-opening the widget using the show() method.

Sample configuration options definition

The configuration below displays a custom designed button (of class myBtn) with the label Insert Images in the CMS or Web app page. When the button is clicked, the Media Library widget will open as a modal dialog with alex as the logged in user. For each image selected, two derived images will be generated, one that delivers the original image, but with q_auto and f_auto transformations applied, and another that delivers the image as a small, circular image, using g_auto to ensure the most important part of the image remains in the crop.

    const mloptions = {
        cloud_name: 'my_company',
        api_key: '12345',
        username: 'alex@mycompany.com',
        timestamp: '1234567890',
        signature: 'abcdefgh',
        button_class: 'myBtn',
        button_caption: 'Insert Images',
        default_transformations: [
          [{quality: "auto"},{fetch_format: "auto"}],
          [{width: 80, height: 80, crop: "fill", gravity: "auto", radius: "max"}, {fetch_format: "auto", quality: "auto"}]
        ],    
        }

4. Create your callback function

After a user selects media assets to insert and closes the Media Library, the widget returns a JSON payload that includes the URL(s) of the selected asset(s), any derived assets based on specified or default transformations, as well as other asset data such as file dimensions, byte size, format, asset type (image, video, raw, etc), and more. You should create an insertHandler callback function that receives and handles this data to control how the selected assets will be integrated into your page.

For example: function insertHandler(data){...}

The returned data consists of an array of Objects - one for each inserted asset. Each object includes the following attributes (shown here in alphabetical order):

• bytes: number
• context: Object[]
• created_at: string
• derived: Object[]
• format: string
• height: number
• public_id: string
• resource_type: string
• secure_url: string
• tags: string[]
• type:"upload"
• url: string
• version: number
• width: number
• [duration: number] - for video assets only

Sample JSON response for a transformed image

The following shows an example of the JSON data returned after a user applied a transformation on an image. Note that data includes the URLs (HTTP and HTTPS versions) of the original image as well as the URLs of the derived (transformed) image.

{
  assets: [{
  "public_id": "sample",
  "resource_type": "image",
  "type": "upload",
  "format": "jpg",
  "version": 1511474034,
  "url": "http://res.cloudinary.com/demo/image/upload/v1511474034/sample.jpg",
  "secure_url": "https://res.cloudinary.com/demo/image/upload/v1511474034/sample.jpg",
  "width": 864,
  "height": 576,
  "bytes": 120257,
  "duration": null,
  "tags": [],
  "context": [],
  "created_at": "2017-11-23T21:53:54Z",
  "derived": [
    {
      "url": "http://res.cloudinary.com/demo/image/upload/c_scale,e_grayscale,f_auto,q_auto,w_100/v1511474034/sample.jpg",
      "secure_url": "https://res.cloudinary.com/demo/image/upload/c_scale,e_grayscale,f_auto,q_auto,w_100/v1511474034/sample.jpg"
    }
  ]
}]}

Sample JSON response for an original video

The following shows an example of the JSON data returned after a user selected a video asset.

{ 
  assets: [{
  "public_id": "video_test/dog",
  "resource_type": "video",
  "type": "upload",
  "format": "mp4",
  "version": 1498600792,
  "url": "http://res.cloudinary.com/demo/video/upload/v1498600792/video_test/dog.mp4",
  "secure_url": "https://res.cloudinary.com/demo/video/upload/v1498600792/video_test/dog.mp4",
  "width": 854,
  "height": 480,
  "bytes": 9094354,
  "duration": 13.4134,
  "tags": [],
  "context": [],
  "created_at": "2017-06-27T21:59:52Z"
}, [...]]}

5. Instantiate and open the Media Library widget

Now that you've set up the configuration options, and created the callback function, you pass these to one of the instantiation methods. Both methods instantiate the widget.

• openMediaLibrary - Instantiates the widget and then opens it. If the user is not yet logged into Cloudinary (either directly or via SSO), a link prompts the user to log in. After successful login, the widget opens and displays the available assets.
• createMediaLibrary - Instantiates the widget, but does not open it. This can be useful if you want to activate the instantiation process in the background so that the Media Library will open more quickly for your users when requested. You can explicitly open or close the media widget using the show() and hide() toggle methods.

Syntax

• openMediaLibrary(options, callback, [:btnPlaceholder])
• createMediaLibrary(options, callback, [:btnPlaceholder])

Parameters

• options - The configuration options to apply to your initial Media Library instance. If you use the show() and hide() toggle methods](#show_or_hide_the_media_library), you can optionally adjust some of these settings each time the widget opens.
• callback - The callback function that determines how to handle the selected (returned) media assets.
• btnPlaceholder - Optional. An HTMLElement or selector in your web page that will be replaced with a new button that toggles the Media Library instance open and closed. You can configure the appearance and text of this button by defining the button_class and button_caption configuration options.

Example

window.ml = cloudinary.createMediaLibrary(config, {insertHandler: insertHandler}, "#my_btn")

Show or hide the media library

After the Media Library has been instantiated, you can use the show() and hide() methods to open and close the widget in your application.

• window.ml.show( [options] ) - If you want to adjust any of the Media Library behavior options that were defined when you instantiated the widget, you can optionally pass a new options object with the settings you want to change for this particular show session.

  For example, if you want to control the total number of assets a user can insert during a single operation in your CMS application, then if the user inserts a few items, closes the widget, and then reopens it, you might want to adjust the max_files value according to the new remaining amount.

  When calling show(), if the user is not yet logged into Cloudinary (either directly or via authentication signature/SSO), the user is prompted to log in.

• window.ml.hide() - When you hide the widget, any adjusted options that were passed in the show() command are forgotten, and the settings revert to those set in the initial instantiation.

Show and hide callback functions

In addition to the required insertHandler callback function, you can also add optional callback functions that will run when the Media Library widget is displayed or hidden:

• The showHandler callback function runs when the widget is displayed, e.g.: {showHandler: () => {console.log("show")}}
• The hideHandler callback function runs when the widget is hidden, e.g.: {hideHandler: () => {console.log("hide")}}

For example:

window.ml = cloudinary.createMediaLibrary(config, {
    insertHandler: insertHandlerFunction, 
    showHandler: showHandlerFunction, 
    hideHandler: hideHandlerFunction
})

6. Optional. Set up SAML authentication

If your CMS or web app users already log in using SSO, you can also set up SSO login for Cloudinary so that your users can enjoy a seamless experience.

After the feature has been made available for your account, you (as a Cloudinary account admin) activate SAML authentication for your users by entering your provider's SAML metadata URL in the SAML login option in the User settings of the Cloudinary console. You can choose to either allow or enforce SSO login for your users.

7. Optional. Define the Cloudinary log out policy

You can log the user out of Cloudinary when they log out of your application (or at any other point during their application session) by calling the Cloudinary logout endpoint: https://cloudinary.com/users/logout

Examples

Example 1

The following example instantiates the Media Library widget as a modal dialog and prepares it for John Doe to log into the my_company Cloudinary account. (The login will either be handled by SAML authentication or manual login.) The configuration includes a customized button class and button text that will replace the open-btn HTML element in the CMS page. The data for the selected asset is displayed in the console log.

window.ml = cloudinary.createMediaLibrary({
   cloud_name: 'my_company',
   api_key: '1234567890',
   username: 'john_doe@mycompany.com',
   button_class: 'myBtn',
   button_caption: 'Select Image or Video',
 }, {
     insertHandler: function (data) {
       data.assets.forEach(asset => { console.log("Inserted asset:",
       JSON.stringify(asset, null, 2)) })
       }
    },
    document.getElementById("open-btn")
)

Example 2

The following example instantiates the Media Library widget and prepares it for Alice Wonderlin to log into the my_company Cloudinary account using an authentication signature, and then opens the widget as a modal dialog.

No Open Media Library button is created. The widget will enable this user to select up to 8 media assets. The data for each of the selected assets is displayed in the console log.

window.ml = cloudinary.openMediaLibrary({
  cloud_name: 'my_company',
  api_key: '1234567890',
  username: 'Alice_Wonderlin@mycompany.com',
  timestamp: '1234567890',
  signature: 'abcdefgh',
  inline_container: '.cms-container',
  multiple: true,
  max_files: 8,
  }, {
       insertHandler: function (data) {
         data.assets.forEach(asset => { console.log("Inserted asset:", 
           JSON.stringify(asset, null, 2)) })
       }
     }
  )