This topic describes how to use Content Moderation SDK for Java to perform optical character recognition (OCR). This way, you can recognize text in images.


  • Java dependencies are installed. For more information, see Installation.
    Note You must use the required Java version described in the Installation topic to install the dependencies. Otherwise, subsequent operation calls fail.
  • The Extension.Uploader utility class is downloaded and imported into your project if you submit a local image or a binary image stream for image moderation.

Submit synchronous OCR tasks

Interface Description Supported region
ImageSyncScanRequest Submits synchronous OCR tasks to recognize text in images. Set the scenes parameter to ocr.
  • cn-shanghai: China (Shanghai)
  • cn-beijing: China (Beijing)
  • cn-shenzhen: China (Shenzhen)
  • ap-southeast-1: Singapore (Singapore)
  • ap-southeast-5: Indonesia (Jakarta)
Sample code
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.exceptions.ServerException;
import com.aliyuncs.http.FormatType;
import com.aliyuncs.http.HttpResponse;
import com.aliyuncs.http.MethodType;
import com.aliyuncs.http.ProtocolType;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.profile.IClientProfile;

import java.util.*;

public class Main {

    public static void main(String[] args) throws Exception {
        IClientProfile profile = DefaultProfile
            .getProfile("cn-shanghai", "yourAccessKeyId", "yourAccessKeySecret");
            .addEndpoint("cn-shanghai", "Green", "");
        IAcsClient client = new DefaultAcsClient(profile);

        ImageSyncScanRequest imageSyncScanRequest = new ImageSyncScanRequest();
        // Specify the format of the response. 
        // Specify the request method. 
        // Specify the protocol. HTTP and HTTPS are supported. 

        JSONObject httpBody = new JSONObject();
         * Specify the moderation scenario. 
         * A value of ocr indicates that the server uses OCR to recognize text in images. 
        httpBody.put("scenes", Arrays.asList("ocr"));

         * Create one task for each image to be moderated. 
         * If you moderate multiple images in a request, the total response time that the server spends on processing the request starts from when the request is initiated to when the last image is moderated. 
         * The average response time of moderating multiple images in a request is longer than that of moderating a single image. The more images you submit at a time, the higher the probability that the average response time will be extended. 
         * In this example, a single image is moderated. If you need to moderate multiple images at a time, create one task for each image to be moderated. 
        JSONObject task = new JSONObject();
        task.put("dataId", UUID.randomUUID().toString());

        // Specify the image URL. 
        task.put("url", "https://xxx.jpg");
        httpBody.put("tasks", Arrays.asList(task));

        imageSyncScanRequest.setHttpContent(org.apache.commons.codec.binary.StringUtils.getBytesUtf8(httpBody.toJSONString()), "UTF-8", FormatType.JSON);
         * Specify the connection timeout and read timeout. The timeout period for the server to complete an image moderation request is 10s. Specify the timeout based on this period. 
         * If you set the read timeout to a period shorter than 10s, the server is prone to generate a read timeout error during request processing. 
        HttpResponse httpResponse = null;
        try {
            httpResponse = client.doAction(imageSyncScanRequest);
        } catch (ServerException e) {
        } catch (ClientException e) {
        } catch (Exception e){

        // The results returned after the server receives and processes your request. 
        if(httpResponse != null && httpResponse.isSuccess()){
            JSONObject scrResponse = JSON.parseObject(org.apache.commons.codec.binary.StringUtils.newStringUtf8(httpResponse.getHttpContent()));
            int requestCode = scrResponse.getIntValue("code");
            // The moderation result of each image. 
            JSONArray taskResults = scrResponse.getJSONArray("data");
            if (200 == requestCode) {
                for (Object taskResult : taskResults) {
                    // The moderation result of a single image. 
                    int taskCode = ((JSONObject)taskResult).getIntValue("code");
                    // The moderation result of the image in the specified moderation scenario. If you specified multiple moderation scenarios in the request, the moderation result of the image in each scenario is returned. 
                    JSONArray sceneResults = ((JSONObject)taskResult).getJSONArray("results");
                    if(200 == taskCode){
                        for (Object sceneResult : sceneResults) {
                            String scene = ((JSONObject)sceneResult).getString("scene");
                            String suggestion = ((JSONObject)sceneResult).getString("suggestion");
                            //do something
                            // The text in the moderated image. 
                            if("review" .equals(suggestion) && "ocr".equals(scene)){
                                JSONObject idCardInfo =  ((JSONObject) sceneResult).getJSONObject("idCardInfo");
                        // A single image failed to be moderated. Analyze the failure based on the actual situation. 
                        System.out.println("task process fail. task response:" + JSON.toJSONString(taskResult));
            } else {
                 * Your whole request failed to be processed. Analyze the failure based on the actual situation. 
                System.out.println("the whole image scan request failed. response:" + JSON.toJSONString(scrResponse));