Cloudinary Blog

Image moderation made easy using cloud-based UI and API

Image moderation made easy using cloud-based UI & API

Many websites and mobile apps today allow their visitors to share their own photos. Users upload their profile images to dating sites, photos of their personal belongings to second hand market websites and real estate billboards. Users share their personal photos on social networks, and upload images to their favorite e-commerce websites, showcasing and reviewing their latest purchases.

It’s sometimes quite important to moderate these images. You might want to keep out offensive content. You may want to actively reject images that do not answer your website’s needs, for example, make sure there are visible faces in profile images, or that only photos of your brand appear on a shared marketing campaign. You may also want to make sure that photos are of high enough quality before making them available on your website.

While image moderation can be very important, from the developer’s perspective, implementing such a flow can be very time consuming.

To eliminate all the hassle from implementing your own image moderation solution, we’ve built a complete image moderation solution into Cloudinary’s cloud-based image management service.

Manual image moderation console

You can start using Cloudinary’s image moderation in minutes, with a straightforward integration.

Upload images to Cloudinary for image moderation

Cloudinary is an end-to-end cloud-based image management solution. To start moderating your images with Cloudinary, start by tagging them as “requiring moderation” during upload. Your moderators will then be able to view all the images that require moderation, and accept or reject them, in our online interface.

To upload images to Cloudinary, use the server-side upload API call, or allow users to upload the images directly from their browser using our jQuery plugin.

In the upload call, set the moderation parameter to manual. This tells Cloudinary to mark this image as pending manual moderation.

Check out the simple upload code below in Ruby, PHP, Node.js, Python and Java.

Ruby:
Cloudinary::Uploader.upload("user_photo.jpg", :moderation => 'manual')
PHP:
\Cloudinary\Uploader::upload("user_photo.jpg",
    array( "moderation" => "manual" ));
Python:
cloudinary.uploader.upload(
  "user_photo.jpg",
  moderation = 'manual'
)
Node.js:
cloudinary.uploader.upload(
  "user_photo.jpg",
  function(result) { console.log(result); },
  { moderation: 'manual' }
);
Java:
cloudinary.uploader().upload(new File("user_photo.jpg"), Cloudinary.asMap(
  "moderation", "manual"));

The response includes all image details and URLs by which you can deliver the image to your users, including the moderation status:

{ 
  "public_id": "zutqljpun3qc37asxbgi",`
  "version": 1398848882, 
  "url":  
    "http://.../image/upload/v1398848882/zutqljpun3qc37asxbgi.jpg", 
  "moderation": [{"status": "pending", "kind": "manual"}],  
    
}

Cloudinary’s image moderation UI

Images that are uploaded to Cloudinary, and tagged for manual moderation, can be viewed by moderators using Cloudinary’s Media Library. Moderators can browse recently uploaded images and decide to accept or reject them.

You can use Cloudinary’s user management capabilities to define multiple moderator users that can access only the image moderation console, and do not have access to other Cloudinary features such as image manipulations, reports, etc.

Queue of pending images

In this scenario, a social web app asked that users upload a front-facing photo of themselves. While all the images might seem valid at first glance, a moderator might opt to reject some of them.

The first photo shows two people, however the social app specified a photo of a single person, so the image would be rejected.

The second and fourth photos show a front-facing person. The moderator should decide, based on site policy, whether both the close-up and the longer distance photo should be approved.

The third photo shows a front facing person, however there is an offensive symbol on the person’s T-shirt, which would cause it to be rejected. The fifth photo would also be rejected, as it is too blurry.

Rejecting and approving pending images can be done simply by hovering over a thumbnail in the media library, and clicking on the Reject (red) or Approve (green) button. Moderators can also click on an image to view further details, see a larger view and approve / reject the image in expanded mode.

Pending moderation photo

The list of approved images can be viewed from the same web interface, and moderators can change their minds at any time, and choose to reject a previously-approved image. Note that it can take up to ten minutes for cached copies to be updated.

Approved images queue

Rejected images are still saved in your cloud-based media library, using Cloudinary’s backup repository. Only the moderator can access and view the original uploaded images. If the moderator changes his mind, the originally rejected images will be recovered from backup and made available for delivery on your site.

Rejected images queue

Rejected image

You can add a notification_url parameter while uploading the image, which instructs Cloudinary to notify your application of changes to moderation status, at this point your application will receive a notification with the details of the moderation event (approval or rejection).

Replacing a rejected images with a placeholder image

When an image is rejected, you can use Cloudinary’s default image mechanism to display a placeholder image instead.

The default_image parameter (or d for URLs) allows you to specify a placeholder image to display, in case an image was rejected by your moderator.

The following sample code creates a 150x150 face-detection-based thumbnail of the uploaded images, then rounds the corner of the photos and increases color saturation. This is all done on-the-fly using Cloudinary’s image manipulation feature. The example below also specified an alternative image to show if the original has been actively rejected.

Ruby:
cl_image_tag("j6ayuxwr76qwvyjioq7b.jpg", :width=>150, :height=>150, :gravity=>"face", :radius=>30, :effect=>"saturation:50", :default_image=>"avatar.png", :crop=>"fill")
PHP:
cl_image_tag("j6ayuxwr76qwvyjioq7b.jpg", array("width"=>150, "height"=>150, "gravity"=>"face", "radius"=>30, "effect"=>"saturation:50", "default_image"=>"avatar.png", "crop"=>"fill"))
Python:
CloudinaryImage("j6ayuxwr76qwvyjioq7b.jpg").image(width=150, height=150, gravity="face", radius=30, effect="saturation:50", default_image="avatar.png", crop="fill")
Node.js:
cloudinary.image("j6ayuxwr76qwvyjioq7b.jpg", {width: 150, height: 150, gravity: "face", radius: 30, effect: "saturation:50", default_image: "avatar.png", crop: "fill"})
Java:
cloudinary.url().transformation(new Transformation().width(150).height(150).gravity("face").radius(30).effect("saturation:50").defaultImage("avatar.png").crop("fill")).imageTag("j6ayuxwr76qwvyjioq7b.jpg")
jQuery:
$.cloudinary.image("j6ayuxwr76qwvyjioq7b.jpg", {width: 150, height: 150, gravity: "face", radius: 30, effect: "saturation:50", default_image: "avatar.png", crop: "fill"})
.Net:
cloudinary.Api.UrlImgUp.Transform(new Transformation().Width(150).Height(150).Gravity("face").Radius(30).Effect("saturation:50").DefaultImage("avatar.png").Crop("fill")).BuildImageTag("j6ayuxwr76qwvyjioq7b.jpg")
150x150 face detection based cropped thumbnail

Another face thumbnail

Placeholder thumbnail of a rejected image

Implementing pre/post-publishing moderation with Cloudinary

Does moderation need to occur before an image is published on the site, or can the image be published and visible in the meantime? The answer will determine your moderation workflow.

Post-publishing moderation is easier to implement, but can sometimes result in users seeing inappropriate or even problematic images until they are moderated.

Pre-publishing moderation is safer, but comes at the cost of users having to wait for their images to appear, and a higher cost of manpower, because moderation needs to happen urgently as images are uploaded.

With Cloudinary, you can choose the workflow that is most appropriate to your website.

Pre-publishing moderation

To implement pre-publishing moderation, it is recommended to use Cloudinary’s randomly-generated public IDs. As you can see in the response code above, Cloudinary returns a long URL with a random ID which is difficult to guess. This URL is publically-accessible, and you can use it to show the uploaded image to the user who uploaded the photo.

As for other visitors of your site, you can simply code your backend so it doesn’t display an image until it is set as “moderated”, and they won’t stumble upon it accidentally due to the long ‘unguessable’ URL.

If you want to completely hide images while they are under moderation, you can use our private images feature, detailed in this blog post.

Post-publishing moderation

To implement post-publishing moderation, you can simply take the publically-available URL returned by Cloudinary (or specify a more friendly URL) and display the image on the relevant page of your site.

When your moderators rejects and image, you’ll be able to catch this event and handle it accordingly.

Build your own image moderation interface

Do you want to build your own image moderation interface, or already have one in place? You can use Cloudinary’s Admin API to easily integrate your custom interface with Cloudinary’s image upload, storage, CDN and moderation workflow.

The following sample code calls Cloudinary’s Admin API for listing all pending images waiting for manual moderation:

Ruby:
list = Cloudinary::Api.resources_by_moderation("manual", "pending")
PHP:
$api = new \Cloudinary\Api();
$list = $api->resources("manual", "pending");
Python:
list = cloudinary.api.resources_by_moderation("manual", "pending")
Node.js:
cloudinary.api. resources_by_moderation("manual", "pending",
  function(result) { console.log(result) });
Java:
Cloudinary cloudinary = new Cloudinary(config);

ApiResponse result = cloudinary.api(). resourcesByModeration(
  "manual", "pending",  Cloudinary.emptyMap());

Here’s a sample output result:

    {"resources"=>
     [{
       "public_id"=>"omjisa17oaih05me4k4h", "format"=>"jpg",  
       "version"=>1398848978,
       "resource_type"=>"image", "type"=>"upload", 
       "created_at"=>"2014-04-30T09:09:38Z",
       "bytes"=>87932, "width"=>849, "height"=>565, "backup"=>true,
       "url"=>"http://.../image/upload/v1398848978/omjisa17oaih05me4k4h.jpg",
       "secure_url"=>"https://.../image/upload/v1398848978/omjisa17oaih05me4k4h.jpg"
      }, 
     {
       "public_id"=>"j6ayuxwr76qwvyjioq7b", "format"=>"jpg", 
       "version"=>1398848970, 
       "resource_type"=>"image", "type"=>"upload",
       "created_at"=>"2014-04-30T09:09:30Z",
       "bytes"=>43214, "width"=>390, "height"=>500, "backup"=>true,
       "url"=>"http://.../image/upload/v1398848970/j6ayuxwr76qwvyjioq7b.jpg",     
       "secure_url"=>"https://.../image/upload/v1398848970/j6ayuxwr76qwvyjioq7b.jpg"
      }, 
      ...
    ]}

You can then use the Admin’s API update method to approve or reject images. The following sample code shows an approval request of a pending image with ID j6ayuxwr76qwvyjioq7b:

Cloudinary::Api.update("j6ayuxwr76qwvyjioq7b", :moderation_status => "approved")

Same goes for the rejection of pending images:

Cloudinary::Api.update("uznjsi2nzcbwqzacym7c", :moderation_status => "rejected")

A notification callback (HTTP post) will be sent to your web application for each approval or rejection event, if you specified the notification_url while uploading images using the API.

You can also use the API to list images that were approved or rejected. The output of these methods has the same format as the pending queue listing shown above. You can allow moderators to revisit their decision regarding the approved or rejected images, and you can call the update method again for the same images, based on their public_id value, to change their moderation status.

The following sample code shows how to list approved and rejected images:

approved_list = Cloudinary::Api.resources_by_moderation("manual", "approved")

rejected_list = Cloudinary::Api.resources_by_moderation("manual", "rejected")

Summary

Moderation of user contributed content can be critical for modern websites and mobile applications. Cloudinary’s image management solution makes it easy to implement an image moderation workflow on your service, while optimizing storage and delivery of images, and enabling easy on-the-fly manipulation of images as well. We also showed how Cloudinary’s powerful Admin API can be used to create a custom image moderation interface.

In this post we covered manual moderation by trained staff, which can ensure almost 100% accuracy, but might be time consuming. Cloudinary also supports automatic image moderation - stay tuned for an upcoming blog post discussing this feature.

The image moderation features discussed in this post, including the user interface and all API methods, are available for all Cloudinary plans, including the free tier. Try it out now by creating a free account. If you have any feedback or ideas on our manual image moderation, you’re most welcome to contact us, or add a comment at the bottom of this post.

Recent Blog Posts

HTML5 Video Player

By Prosper Otemuyiwa
HTML5 Video Comparison

HTML5 is the latest evolution of the HTML standard. It is bundled with a lot of new elements and attributes that makes semantics, connectivity, performance, device access, 2D/3D graphics and styling better on the web.

Read more
Increase engagement with on-the-fly cartoon effect

We all know that images attract interest and increase engagement, but with the huge overload of images out there, we sometimes need to get creative to stand out in the crowd. Your users who upload photos to your site or app may also be looking for those same creative opportunities. A quick look at the most popular social media apps and their continually increasing toolbox of special photo effects shows the increasing trend in popularity and demand for these fun ways of expressing one’s identity.

Read more

Lazy Loading for Optimal Performance

By Ezequiel Bruni
Lazy Loading for Performance

Who doesn't love some striking imagery to drive your point home? Whether you're selling a product or service, trying to communicate complex ideas, or simply captivate the emotions of your users, pictures can do that. Everyone knows they work, and everyone loves them.

Read more
Automating image manipulation with user-defined variables

No programmer could imagine a world without variables. Neither can Cloudinary. That’s why Cloudinary now offers image transformations that support user-defined variables.

Using Cloudinary, you can already deliver transformed images with a variety of transformations, including resizing, cropping, rotating, a huge toolbox of special effects and filters, text and image overlays, and more, all of which you can deliver responsively, on-the-fly, and optimized for quick delivery via CDN.

Read more