ocr custom api

version

Version Date Changes
v1.0.0 2019-12-05 최초작성
V1.0.1 2020-02-21 General API 호출응답에 boundingPoly 정보 제공
V2.0.0 2020-03-26 OCR프리미엄 모델 제공으로 멀티박스, 체크박스인식 기능 추가됨
요청 버전에 따라 (V1/V2) 인식결과로 bounding/boundingPloy 정보가 제공. V2 사용을 권장하며, V2사용시 boundingPloy 정보가 제공됨.

요청

Method Request URI
POST OCR 빌더에서 생성된 API Gateway의 InvokeURL로 호출합니다.
각 도메인마다 고유의 호출 URL이 생성됩니다.

TEXT OCR 인식과 Template OCR 인식 요청

구분 설명 Path Request Response
TEXT OCR 템플릿 정의없이 이미지의 모든 텍스트를 인식합니다. /general 이미지 인식 요청 형식을 따릅니다.
설정 가능한 언어값은 ‘ko’/‘ja’ 이며, lang 필드가 설정되지 않은 경우, ‘ko’가 default로 설정됩니다.
이미지 인식 결과 형식을 따릅니다.
matchedTemplate, title and validationResult 값은 전달되지 않습니다.
Template OCR 도메인에 배포된 템플릿이 포함 된 이미지를 인식합니다. /infer 이미지 인식 요청 형식을 따릅니다.
lang 필드가 설정되지 않은 경우, 도메인의 언어 설정값이 default로 설정됩니다.
이미지 인식 결과 형식을 따릅니다.

요청 헤더

헤더명 설명
X-OCR-SECRET 도메인에서 API Gateway 연동시 생성한 X-OCR-SECRET:{Client Secret}
Content-Type application/json : request use json body. Support image.url or image.data encoded with base64.
- multipart/form-data : request use multipart form body. Support image file transferred as stream.

요청 바디

Content-Type : application/json

  1. 이미지 인식 요청
구분 Json Model
이미지 인식 요청 {
“version”: “string”,
“requestId”: “string”,
“timestamp”: 0,
“lang”: “string”,
“images”: [{ “format”: “string”, “url”: “string”, “data”: “string”, “name”: “string”, “templateIds”: [ 0 ] }]
}

이미지 인식 요청 필드 상세 설명

필드명 필수 여부 타입 설명 제약 사항
version Yes string 버전 정보 필수로 V1, 혹은 V2를 입력합니다. V2 사용을 권장하며, V2사용시 boundingPloy 정보가 제공됨.
requestId Yes string API 호출 UUID입니다.
timestamp Yes 0 API 호출 Timestamp 값입니다.
lang No string OCR 인식시 요청할 언어 정보입니다. lang 필드가 설정되지 않은 경우, ‘ko’가 default로 설정됩니다.
images Yes string Json array로 입력되며, 현재는 1개의 이미지 입력만 허용 됩니다. (한국어/일본어)
images.format Yes string 이미지 포맷을 설정합니다. “jpg”, “jpeg”, “png” 이미지 형식을 지원합니다.
images.url No string images.url 혹은 image.data 중 하나가 존재해야 합니다. URL은 이미지를 가져 올 수 있는 공개 URL이어야 합니다.
image.data No string images.url 혹은 image.data 중 하나가 존재해야 합니다. URL과 데이터가 모두 존재하면 데이터를 사용하고 URL은 무시합니다. image.data는 base64 인코딩 이미지 바이트입니다.
image.name Yes string 이미지 명을 입력합니다. 이미지를 식별하는데 사용되며, 응답 결과 확인에 사용됩니다.
image.templateIds No json array 텍스트 OCR API에서는 사용되지 않습니다. Template OCR API에서는 이 필드를 설정하지 않으면 도메인에 배포된 모든 서비스 템플릿으로 자동 분류됩니다.

CURL example:

curl --request POST 'your apigw invoke url' \
--header 'X-OCR-SECRET: your secret key' \
--data-raw '{"images":[{"format":"jpg","name":"demo","url":"your image url"}],"requestId":"guide-json-demo","version":"V2","timestamp":1584062336793}'

Content-Type : multipart/form-data

  1. Image Recognition Request
KEY Required VALUE
message Y {“version”: “string”,“requestId”: “string”,“timestamp”: 0,“lang”: “string”,“images”: [{ “format”: “string”, “name”: “string”, “templateIds”: [ 0 ] }]}
file Y image file steam data

Form Data Message Value Description

Field name Required Type Description Constraints
version Yes string 버전 정보 필수로 V1, 혹은 V2를 입력합니다. V2 사용을 권장하며, V2사용시 boundingPloy 정보가 제공됨.
requestId Yes string API 호출 UUID입니다.
timestamp Yes integer API 호출 Timestamp 값입니다.
lang No string OCR 인식시 요청할 언어 정보입니다. lang 필드가 설정되지 않은 경우, ‘ko’가 default로 설정됩니다.
images Yes string It is entered as Json array and currently only one image input is allowed (Korean/Japanese)
images.format Yes string 이미지 포맷을 설정합니다. “jpg”, “jpeg”, “png” 이미지 형식을 지원합니다.
image.name Yes string 이미지 명을 입력합니다. 이미지를 식별하는데 사용되며, 응답 결과 확인에 사용됩니다.
image.templateIds No json array 텍스트 OCR API에서는 사용되지 않습니다. Template OCR API에서는 이 필드를 설정하지 않으면 도메인에 배포된 모든 서비스 템플릿으로 자동 분류됩니다.

CURL example:

curl --request POST 'your apigw invoke url' \
--header 'X-OCR-SECRET: your secret key' \
--form 'message={"images":[{"format":"png","name":"demo"}],"requestId":"guide-demo","version":"V2","timestamp":1584062336793}' \
--form 'file=@image.png'

응답

V1 응답 바디

Request version is ‘V1’

  1. 이미지 인식 결과
구분 Json Model
이미지 인식 결과 {
“uid”: “string”,
“name”: “string”,
“inferResult”: “string”,
“message”: “string”,
“matchedTemplate”: { “id”: 0, “name”: “string” },
“title”: {},
“fields”: [ {} ],
“validationResult”: { “result”: “string”, “message”: “string”}
}

이미지 인식 결과 필드 상세 설명

필드 이름 데이터 타입 설명
uid string API의 유효성을 검사하기 위해 제공되는 고유 ID로, 유효성 검사 요청을 추적하는 데 사용됩니다.
name string 요청한 이미지 이름입니다.
inferResult string 이미지 추론 결과.
“SUCCESS”: 이미지 인식 성공. “FAILURE”: 이미지 인식 실패.
message string 이미지 인식 성공 시 “SUCCESS”
이미지 인식 실패의 경우 오류 메시지가 표시됩니다.
오류 메시지는 하단에 자세하게 안내
matchedTemplate json object 이미지 인식에 일치한 템플릿 정보로 템플릿 ID와 이름을 포함합니다.
추론이 실패하거나 일치하는 템플릿을 찾을 수없는 경우이 필드에 응답하지 않습니다.
matchedTemplate.id 0 템플릿 ID입니다.
matchedTemplate.name string 템플릿의 이름입니다.
title string 이미지 타이틀입니다.
fields Json array object ImageField 객체 참조
validationResult string 유효성 검사 결과입니다.
validationResult.result string 결과 코드.
“NO_REQUESTED”: 검증 작업이 실행되지 않았습니다.
“UNCHECKED”: 동작 응답이 확인되지 않았거나 응답이 수락되지 않습니다.
“ERROR”: 검증 실행에 오류가 발생하였습니다.
“VALID”: 검증 결과가 유효합니다.
“INVALID”: 검증 결과가 유효하지 않습니다.
“UNCHECHED”,“ERROR”및“INVALID”는 유효성 검사 실패로 표시됩니다.
validationResult.message json object Validation 세부 메시지로 항상 응답되는 값은 아닙니다.
  1. ImageField 객체
구분 Json Model
Image Field {
“name”: “string”,
“valueType”: “string”,
“inferText”: “string”,
“inferConfidence”: 0.0,
“bounding”: {}
}

ImageField 객체 필드 상세 설명

필드 이름 데이터 타입 설명
name string 이미지 명입니다.
valueType string 항상 리턴되는 값은 아니며 필드의 텍스트 값 유형입니다.
“ALL”: 텍스트와 숫자
inferText string 인식결과 텍스트
inferConfidence 0.0 유추 된 결과에 대한 확신. 0-1 값이 클수록 더 정확합니다.
bounding bounding 객체 bounding 객체 참조
  1. bounding객체
구분 Json Model
bounding {
“top”: 0.0,
“left”: 0.0,
“width”: 0.0,
“height”: 0.0
}

bounding 객체 필드 상세 설명

필드 이름 데이터 타입 설명
top 0.0 Bounding Y 좌표
left 0.0 Bounding X 좌표
width 0.0 Bounding width.
height 0.0 Bounding height.

V2 응답 바디

Request version is ‘V2’

  1. Image Recognition Results
Classification Json Model
Image Recognition Results {
“uid”: “string”,
“name”: “string”,
“inferResult”: “string”,
“message”: “string”,
“matchedTemplate”: { “id”: 0, “name”: “string” },
“title”: {},
“fields”: [ {} ],
“validationResult”: { “result”: “string”, “message”: “string”}
}

Detailed description of the Image Recognition Results field

Field Name Data Type Description
uid string A unique ID that is provided to validate the API, which is used to track validation requests.
name string The requested image name.
inferResult string Image inference result.
“SUCCESS”: Image recognition successful. “FAILURE”: Image recognition failed.
message string Successful image recognition, “SUCCESS”
If image recognition fails, an error message is displayed.
Error messages are detailed at the bottom
matchedTemplate json object Include the template ID and name with template information that matches image recognition.
This field does not respond if recognition fails or a matched template cannot be found.
matchedTemplate.id integer Template ID.
matchedTemplate.name string Name of the template.
title json object ImageField Object Reference
fields Json array object ImageField Object Reference
validationResult string Validation result.
validationResult.result string Result Code.
“NO_REQUESTED”: The validation task did not run.
“UNCHECKED”: Action response not confirmed or not accepted
“ERROR”: Error executing validation.
“VALID”: The verification result is valid.
“INVALID”: The verification result is invalid.
“UNCHECHED”,“ERROR” and “INVALID” are marked as validation failures.
validationResult.message json object It is not always the value that is returned in the Validation detail message.
  1. ImageField object
Classification Json Model
Image Field {
“name”: “string”,
“valueType”: “string”,
“inferText”: “string”,
“inferConfidence”: 0.0,
“boundingPoly”: {},
“type”: “string”,
“subFields”: [{}],
“checked”:true
}

ImageField Object Field Details

Field Name Data Type Description
name string Image name.
valueType string It is the text value type of the field.
“ALL”: text and numbers
“NUMERIC”:numbers
inferText string Recognition Result Text
inferConfidence float Confidence of infer result. Larger values of 0-1 are more accurate.
boundingPoly boundingPoly Object boundingPoly Object reference
type string - NORMAL
- MULTI_BOX
- CHECKBOX
subFields Json Array Only ‘MULTI_BOX’ type supported.
SubField Object reference
checked boolean Only ‘CHECKBOX’ type supported.
Whether the field is checked or not.
  1. boundingPoly object
Classification Json Model
boundingPoly {
“vertices”:[{}]
}

boundingPoly Object Field Details

Field Name Data Type Description
vertices vertices object vertices object reference
  1. vertices object
Classification Json Model
vertices {
“x”: 0.0,
“y”: 0.0
}

vertices Object Field Details

Field Name Data Type Description
x float X coodinate
y float y coodinate
  1. SubField Object
Classification Json Model
subField {
“boundingPoly”: {},
“inferText”: “string”,
“inferConfidence”:0.0
}

subField Object Field Details

Field Name Data Type Description
boundingPoly boundingPoly Object boundingPoly Object reference
inferText string Recognition Result Text
inferConfidence float Confidence of infer result. Larger values of 0-1 are more accurate.

예시

TEXT OCR 요청 예시

{
  "version": "V2",
  "requestId": "string",
  "timestamp": 0,
  "lang":"ko",
  "images": [
    {
      "format": "jpg",
      "name": "test 1",
      "url": "https://www.ncloud.com/ocr-test/test.jpg"
    }
  ]
}

TEXT OCR 응답 예시

{
    "version": "V2",
    "requestId": "string",
    "timestamp": 1576569034247,
    "images": [{
        "uid": "9fd73a6aacad4025b3099a36ee55aacd",
        "name": "medium",
        "inferResult": "SUCCESS",
        "message": "SUCCESS",
        "fields": [{
                "valueType": "ALL",
                "inferText": "아름다운",
                "inferConfidence": 0.99992156,
                "type": "NORMAL",
                "boundingPoly": {
                    "vertices": [{
                        "x": 2713.7295,
                        "y": 1277.0492
                    }, {
                        "x": 2713.7295,
                        "y": 977.7408
                    }, {
                        "x": 2841.4343,
                        "y": 977.7408
                    }, {
                        "x": 2841.4343,
                        "y": 1277.0492
                    }]
                }
            },
            {
                "valueType": "ALL",
                "inferText": "이",
                "inferConfidence": 0.99958915,
                "type": "NORMAL",
                "boundingPoly": {
                    "vertices": [{
                        "x": 2314.6516,
                        "y": 1468.6066
                    }, {
                        "x": 2314.6516,
                        "y": 1328.9293
                    }, {
                        "x": 2426.3936,
                        "y": 1328.9293
                    }, {
                        "x": 2426.3936,
                        "y": 1468.6066
                    }]
                }
            },
            {
                "valueType": "ALL",
                "inferText": "세상",
                "inferConfidence": 0.9998707,
                "type": "NORMAL",
                "boundingPoly": {
                    "vertices": [{
                        "x": 2314.6516,
                        "y": 1604.2931
                    }, {
                        "x": 2314.6516,
                        "y": 1460.625
                    }, {
                        "x": 2430.3843,
                        "y": 1460.625
                    }, {
                        "x": 2430.3843,
                        "y": 1604.2931
                    }]
                }
            }
        ],
        "validationResult": {
            "result": "NO_REQUESTED"
        }
    }]
}

Template OCR 요청 예시

{
  "version": "V1",
  "requestId": "string",
  "timestamp": 0,
  "lang":"ko",
  "images": [
    {
      "format": "jpg",
      "name": "test 1",
      "url": "https://www.ncloud.com/ocr-test/test.jpg",
      "templateIds":[390]
    }
  ]
}

Template OCR 응답 예시

{
    "version": "V2",
    "requestId": "string",
    "timestamp": 1584067653255,
    "images": [
        {
            "uid": "1b220cd049de4a7c9e0dc1942d982867",
            "name": "test 1",
            "inferResult": "SUCCESS",
            "message": "SUCCESS",
            "matchedTemplate": {
                "id": 390,
                "name": "template"
            },
            "validationResult": {
                "result": "NO_REQUESTED"
            },
            "title": {
                "name": "title",
                "boundingPoly": {
                    "vertices": [
                        {
                            "x": 453.7125,
                            "y": 54.1125
                        },
                        {
                            "x": 961.5375,
                            "y": 54.1125
                        },
                        {
                            "x": 961.5375,
                            "y": 108.225
                        },
                        {
                            "x": 453.7125,
                            "y": 108.225
                        }
                    ]
                },
                "inferText": "보험금 청구서 (인보험月)",
                "inferConfidence": 0.94674826
            },
            "fields": [
                {
                    "name": "id",
                    "valueType": "NUMERIC",
                    "boundingPoly": {
                        "vertices": [
                            {
                                "x": 488.88235,
                                "y": 284.92896
                            },
                            {
                                "x": 550.3732,
                                "y": 284.93716
                            },
                            {
                                "x": 550.39166,
                                "y": 333.93698
                            },
                            {
                                "x": 488.90073,
                                "y": 333.9292
                            }
                        ]
                    },
                    "inferText": "102831",
                    "inferConfidence": 0.9319761,
                    "type": "MULTI_BOX",
                    "subFields": [
                        {
                            "boundingPoly": {
                                "vertices": [
                                    {
                                        "x": 488.88235,
                                        "y": 284.92896
                                    },
                                    {
                                        "x": 550.3732,
                                        "y": 284.93716
                                    },
                                    {
                                        "x": 550.39166,
                                        "y": 333.93698
                                    },
                                    {
                                        "x": 488.90073,
                                        "y": 333.9292
                                    }
                                ]
                            },
                            "inferText": "1",
                            "inferConfidence": 0.9798796
                        },
                        {
                            "boundingPoly": {
                                "vertices": [
                                    {
                                        "x": 551.37305,
                                        "y": 284.9373
                                    },
                                    {
                                        "x": 612.86285,
                                        "y": 284.9455
                                    },
                                    {
                                        "x": 612.88153,
                                        "y": 333.94495
                                    },
                                    {
                                        "x": 551.39154,
                                        "y": 333.9371
                                    }
                                ]
                            },
                            "inferText": "0",
                            "inferConfidence": 0.6391636
                        },
                        {
                            "boundingPoly": {
                                "vertices": [
                                    {
                                        "x": 613.86273,
                                        "y": 284.94562
                                    },
                                    {
                                        "x": 675.3515,
                                        "y": 284.95383
                                    },
                                    {
                                        "x": 675.3702,
                                        "y": 333.95288
                                    },
                                    {
                                        "x": 613.8812,
                                        "y": 333.94504
                                    }
                                ]
                            },
                            "inferText": "2",
                            "inferConfidence": 0.99591047
                        },
                        {
                            "boundingPoly": {
                                "vertices": [
                                    {
                                        "x": 676.3513,
                                        "y": 284.95395
                                    },
                                    {
                                        "x": 737.8392,
                                        "y": 284.9622
                                    },
                                    {
                                        "x": 737.8579,
                                        "y": 333.96082
                                    },
                                    {
                                        "x": 676.37006,
                                        "y": 333.953
                                    }
                                ]
                            },
                            "inferText": "8",
                            "inferConfidence": 0.99782735
                        },
                        {
                            "boundingPoly": {
                                "vertices": [
                                    {
                                        "x": 738.83887,
                                        "y": 284.96228
                                    },
                                    {
                                        "x": 800.3257,
                                        "y": 284.97052
                                    },
                                    {
                                        "x": 800.34454,
                                        "y": 333.96872
                                    },
                                    {
                                        "x": 738.8577,
                                        "y": 333.9609
                                    }
                                ]
                            },
                            "inferText": "3",
                            "inferConfidence": 0.99916536
                        },
                        {
                            "boundingPoly": {
                                "vertices": [
                                    {
                                        "x": 801.3255,
                                        "y": 284.97064
                                    },
                                    {
                                        "x": 862.8112,
                                        "y": 284.97882
                                    },
                                    {
                                        "x": 862.8301,
                                        "y": 333.97662
                                    },
                                    {
                                        "x": 801.3443,
                                        "y": 333.96884
                                    }
                                ]
                            },
                            "inferText": "1",
                            "inferConfidence": 0.9799099
                        }
                    ]
                },
                {
                    "name": "name",
                    "valueType": "ALL",
                    "boundingPoly": {
                        "vertices": [
                            {
                                "x": 287.2125,
                                "y": 287.2125
                            },
                            {
                                "x": 380.86874,
                                "y": 287.2125
                            },
                            {
                                "x": 380.86874,
                                "y": 328.8375
                            },
                            {
                                "x": 287.2125,
                                "y": 328.8375
                            }
                        ]
                    },
                    "inferText": "David",
                    "inferConfidence": 0.99630755,
                    "type": "NORMAL"
                },
                {
                    "name": "fax-checkbox",
                    "valueType": "ALL",
                    "boundingPoly": {
                        "vertices": [
                            {
                                "x": 87.08151,
                                "y": 736.90735
                            },
                            {
                                "x": 140.0801,
                                "y": 736.91125
                            },
                            {
                                "x": 140.10016,
                                "y": 791.9156
                            },
                            {
                                "x": 87.101494,
                                "y": 791.9121
                            }
                        ]
                    },
                    "inferText": "",
                    "inferConfidence": 0.99464625,
                    "type": "CHECKBOX",
                    "checked": true
                }
            ]
        }
    ]
}

###

API 예제

다음은 각 언어별 OCR API 구현 예제입니다

  • Request with multipart/form-data
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.UUID;

import org.json.JSONArray;
import org.json.JSONObject;

public class OCRGeneralAPIDemo {

	public static void main(String[] args) {
		String apiURL = "YOUR_API_URL";
		String secretKey = "YOUR_SECRET_KEY";
		String imageFile = "YOUR_IMAGE_FILE";

		try {
			URL url = new URL(apiURL);
			HttpURLConnection con = (HttpURLConnection)url.openConnection();
			con.setUseCaches(false);
			con.setDoInput(true);
			con.setDoOutput(true);
			con.setReadTimeout(30000);
			con.setRequestMethod("POST");
			String boundary = "----" + UUID.randomUUID().toString().replaceAll("-", "");
			con.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
			con.setRequestProperty("X-OCR-SECRET", secretKey);

			JSONObject json = new JSONObject();
			json.put("version", "V2");
			json.put("requestId", UUID.randomUUID().toString());
			json.put("timestamp", System.currentTimeMillis());
			JSONObject image = new JSONObject();
			image.put("format", "jpg");
			image.put("name", "demo");
			JSONArray images = new JSONArray();
			images.put(image);
			json.put("images", images);
			String postParams = json.toString();

			con.connect();
			DataOutputStream wr = new DataOutputStream(con.getOutputStream());
			long start = System.currentTimeMillis();
			File file = new File(imageFile);
			writeMultiPart(wr, postParams, file, boundary);
			wr.close();

			int responseCode = con.getResponseCode();
			BufferedReader br;
			if (responseCode == 200) {
				br = new BufferedReader(new InputStreamReader(con.getInputStream()));
			} else {
				br = new BufferedReader(new InputStreamReader(con.getErrorStream()));
			}
			String inputLine;
			StringBuffer response = new StringBuffer();
			while ((inputLine = br.readLine()) != null) {
				response.append(inputLine);
			}
			br.close();

			System.out.println(response);
		} catch (Exception e) {
			System.out.println(e);
		}
	}

	private static void writeMultiPart(OutputStream out, String jsonMessage, File file, String boundary) throws
		IOException {
		StringBuilder sb = new StringBuilder();
		sb.append("--").append(boundary).append("\r\n");
		sb.append("Content-Disposition:form-data; name=\"message\"\r\n\r\n");
		sb.append(jsonMessage);
		sb.append("\r\n");

		out.write(sb.toString().getBytes("UTF-8"));
		out.flush();

		if (file != null && file.isFile()) {
			out.write(("--" + boundary + "\r\n").getBytes("UTF-8"));
			StringBuilder fileString = new StringBuilder();
			fileString
				.append("Content-Disposition:form-data; name=\"file\"; filename=");
			fileString.append("\"" + file.getName() + "\"\r\n");
			fileString.append("Content-Type: application/octet-stream\r\n\r\n");
			out.write(fileString.toString().getBytes("UTF-8"));
			out.flush();

			try (FileInputStream fis = new FileInputStream(file)) {
				byte[] buffer = new byte[8192];
				int count;
				while ((count = fis.read(buffer)) != -1) {
					out.write(buffer, 0, count);
				}
				out.write("\r\n".getBytes());
			}

			out.write(("--" + boundary + "--\r\n").getBytes("UTF-8"));
		}
		out.flush();
	}
}
import requests
import uuid
import time
import json

api_url = 'YOUR_API_URL'
secret_key = 'YOUR_SECRET_KEY'
image_file = 'YOUR_IMAGE_FILE'

request_json = {
    'images': [
        {
            'format': 'jpg',
            'name': 'demo'
        }
    ],
    'requestId': str(uuid.uuid4()),
    'version': 'V2',
    'timestamp': int(round(time.time() * 1000))
}

payload = {'message': json.dumps(request_json).encode('UTF-8')}
files = [
  ('file', open(image_file,'rb'))
]
headers = {
  'X-OCR-SECRET': secret_key
}

response = requests.request("POST", api_url, headers=headers, data = payload, files = files)

print(response.text.encode('utf8'))

<?php
  $client_secret = "YOUR_SECRET_KEY";
  $url = "YOUR_API_URL";
  $image_file = "YOUR_IMAGE_FILE";

  $params->version = "V2";
  $params->requestId = uniqid();
  $params->timestamp = time();
  $image->format = "jpg";
  $image->name = "demo";
  $images = array($image);
  $params->images = $images;
  $json = json_encode($params);
  
  $boundary = uniqid();
  $is_post = true;
  $ch = curl_init();
  curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
  curl_setopt($ch, CURLOPT_URL, $url);
  curl_setopt($ch, CURLOPT_POST, $is_post);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  $post_form = array("message" => $json, "file" => new CURLFILE($image_file));
  curl_setopt($ch, CURLOPT_POSTFIELDS, $post_form);
  $headers = array();
  $headers[] = "X-OCR-SECRET: ".$client_secret;
  curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
  $response = curl_exec($ch);
  $err = curl_error($ch);
  $status_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
  curl_close ($ch);

  echo $status_code;
  if($status_code == 200) {
    echo $response;
  } else {
    echo "ERROR: ".$response;
  }
?>
  • Request with application/json
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.UUID;

import org.json.JSONArray;
import org.json.JSONObject;

public class OCRGeneralAPIDemo {

	public static void main(String[] args) {
		String apiURL = "YOUR_API_URL";
		String secretKey = "YOUR_SECRET_KEY";

		try {
			URL url = new URL(apiURL);
			HttpURLConnection con = (HttpURLConnection)url.openConnection();
			con.setUseCaches(false);
			con.setDoInput(true);
			con.setDoOutput(true);
			con.setRequestMethod("POST");
			con.setRequestProperty("Content-Type", "application/json; charset=utf-8");
			con.setRequestProperty("X-OCR-SECRET", secretKey);

			JSONObject json = new JSONObject();
			json.put("version", "V2");
			json.put("requestId", UUID.randomUUID().toString());
			json.put("timestamp", System.currentTimeMillis());
			JSONObject image = new JSONObject();
			image.put("format", "jpg");
			image.put("url", "https://kr.object.ncloudstorage.com/ocr-ci-test/sample/1.jpg"); // image should be public, otherwise, should use data
			// FileInputStream inputStream = new FileInputStream("YOUR_IMAGE_FILE");
			// byte[] buffer = new byte[inputStream.available()];
			// inputStream.read(buffer);
			// inputStream.close();
			// image.put("data", buffer);
			image.put("name", "demo");
			JSONArray images = new JSONArray();
			images.put(image);
			json.put("images", images);
			String postParams = json.toString();

			DataOutputStream wr = new DataOutputStream(con.getOutputStream());
			wr.writeBytes(postParams);
			wr.flush();
			wr.close();

			int responseCode = con.getResponseCode();
			BufferedReader br;
			if (responseCode == 200) {
				br = new BufferedReader(new InputStreamReader(con.getInputStream()));
			} else {
				br = new BufferedReader(new InputStreamReader(con.getErrorStream()));
			}
			String inputLine;
			StringBuffer response = new StringBuffer();
			while ((inputLine = br.readLine()) != null) {
				response.append(inputLine);
			}
			br.close();

			System.out.println(response);
		} catch (Exception e) {
			System.out.println(e);
		}
	}

}

import requests
import uuid
import time
import base64
import json

api_url = 'YOUR_API_URL'
secret_key = 'YOUR_SECRET_KEY'
image_url = 'YOUR_IMAGE_URL'
# image_file = 'YOUR_IMAGE_FILE'
# with open(image_file,'rb') as f:
#     file_data = f.read()

request_json = {
    'images': [
        {
            'format': 'jpg',
            'name': 'demo',
#             'data': base64.b64encode(file_data).decode()
            'url': image_url
        }
    ],
    'requestId': str(uuid.uuid4()),
    'version': 'V2',
    'timestamp': int(round(time.time() * 1000))
}

payload = json.dumps(request_json).encode('UTF-8')
headers = {
  'X-OCR-SECRET': secret_key,
  'Content-Type': 'application/json'
}

response = requests.request("POST", api_url, headers=headers, data = payload)

print(response.text)

<?php
  $client_secret = "YOUR_SECRET_KEY";
  $url = "YOUR_API_URL";
  $image_url = "YOUR_IMAGE_URL";
  // $image_file = "YOUR_IMAGE_FILE";

  $params->version = "V2";
  $params->requestId = "uuid";
  $params->timestamp = time();
  $image->format = "jpg";
  $image->url = $image_url;
  // $image->data = base64_encode(file_get_contents($image_file));
  $image->name = "demo";
  $images = array($image);
  $params->images = $images;
  $json = json_encode($params);

  $is_post = true;
  $ch = curl_init();
  curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
  curl_setopt($ch, CURLOPT_URL, $url);
  curl_setopt($ch, CURLOPT_POST, $is_post);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_POSTFIELDS, $json);
  $headers = array();
  $headers[] = "X-OCR-SECRET: ".$client_secret;
  $headers[] = "Content-Type:application/json; charset=utf-8";
  curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
  $response = curl_exec($ch);
  $err = curl_error($ch);
  $status_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
  curl_close ($ch);

  echo $status_code;
  if($status_code == 200) {
    echo $response;
  } else {
    echo "ERROR: ".$response;
  }
?>

Error code

HttpStatusCode Description
400 Request parameters invalid or constraint problem.
401 Api secret(X-CHATBOT-API-KEY) wrong
500 Internal server error

Error Response Body:

{
  "code": "Error Code",
  "message": "error details message.",
  "path": "request API path",
  "timestamp": 1570776853475
}
ErrorCode Description
0001 URL is invalid.
0002 Secret key validate failed.
0011 Request body invalid.
0021 Protocol version not support.
0022 Request domain invalid.
0023 API request count reach the upper limit.
0500 Unknown service error.
0501 OCR Service error.
1021 Not found deploy infomation.