Marriage certificate identification

Update time ： 2023-04-12

Interface description

It supports structural identification of marriage certificate, including 14 fields including name male, ID number male, date of birth male, nationality male, gender male, name female, ID number female, date of birth female, nationality female, gender female, marriage certificate number, holder, remarks, and registration date.

Online debugging

You can visit Sample Code Center Debug the interface in , you can perform signature verification, view the request content and return results of online calls, and automatically generate sample code.

Request Description

Request Example

HTTP method: POST

Request URL: https://aip.baidubce.com/rest/2.0/ocr/v1/marriage_certificate

URL parameter:

parameter	value
access_token	Access_token obtained through API Key and Secret Key, refer to“ Access Token acquisition ”

The headers are as follows:

parameter	value
Content-Type	application/x-www-form-urlencoded

Place the request parameters in the body. The details of the parameters are as follows:

Request Parameters

parameter	Required	type	Optional value range	explain
image	And url/pdf_file	string	-	Image data is encoded with urlencode after base64 encoding. The size after base64 encoding and urlencode is required not to exceed 4M, the shortest side is at least 15px, and the longest side is at most 4096px. It supports jpg/jpeg/png/bmp format priority : image>url>pdf_file, when the image field exists, the url and pdf_file fields become invalid
url	And image/pdf_file	string	-	The image is a complete url with a length of no more than 1024 bytes. The size of the image corresponding to the url after encoding in base64 is no more than 4M. The shortest side is at least 15px, and the longest side is at most 4096px. It supports the jpg/jpeg/png/bmp format priority : image>url>pdf_file, when the image field exists, the url field is invalid Please close the URL anti-theft chain
pdf_file	And image/url	string	-	PDF files are urlencoded after base64 encoding. It is required that the size of base64 encoding and urlencoded files should not exceed 4M, the shortest side should be at least 15px, and the longest side should be at most 4096px priority : image>url>pdf_file, when the image and url fields exist, the pdf_file field is invalid
pdf_file_num	no	string	-	The corresponding page number of the PDF file that needs to be identified. When the pdf_file parameter is valid, identify the corresponding page content of the incoming page number. If not, identify the first page by default
probability	no	string	true/false	Whether to return the field confidence. The default value is false, that is, no return
location	no	string	true/false	Whether to return the position coordinate of the field. The default value is false, that is, it does not return

Request Code Example

Prompt 1 : Before using the sample code, remember to replace the sample token, image address or Base64 information.

Prompt 2 : Some languages depend on classes or libraries. Please check the download address in the code comment.

 curl -i -k ' https://aip.baidubce.com/rest/2.0/ocr/v1/marriage_certificate?access_token= [Call the token obtained from the authentication interface] ' --data 'image=[Picture Base64 encoding, UrlEncode required]' -H 'Content-Type:application/x-www-form-urlencoded'

 # encoding:utf-8

 import requests import base64 ''' Marriage certificate identification ''' request_url =  " https://aip.baidubce.com/rest/2.0/ocr/v1/marriage_certificate "
 #Open picture file in binary mode f =  open ( '[Local file]' ,  'rb' ) img = base64 . b64encode ( f . read ( ) ) params =  { "image" : img } access_token =  '[Token obtained by calling the authentication interface]' request_url = request_url +  "?access_token="  + access_token headers =  { 'content-type' :  'application/x-www-form-urlencoded' } response = requests . post ( request_url , data = params , headers = headers )
 if response :
     print  ( response . json ( ) )

 package  com . baidu . ai . aip ;

 import  com . baidu . ai . aip . utils . Base64Util ;
 import  com . baidu . ai . aip . utils . FileUtil ;
 import  com . baidu . ai . aip . utils . HttpUtil ;

 import  java . net . URLEncoder ;

 /** *Marriage certificate identification */
 public  class  MarriageCertificate {

     /** *Tool class required in important tip code *FileUtil, Base64Util, HttpUtil, GsonUtils *  https://ai.baidu.com/file/658A35ABAB2D404FBF903F64D47C1F72 *  https://ai.baidu.com/file/C8D81F3301E24D2892968F09AE1AD6E2 *  https://ai.baidu.com/file/544D677F5D4E4F17B4122FBD60DB82B3 *  https://ai.baidu.com/file/470B3ACCA3FE43788B5A963BF0B625F3 *Download */
     public  static  String  marriageCertificate ( )  {
         //Request url
         String url =  " https://aip.baidubce.com/rest/2.0/ocr/v1/marriage_certificate " ;
         try  {
             //Local file path
             String filePath =  [Local file path] ;
             byte [ ] imgData =  FileUtil . readFileByBytes ( filePath ) ;
             String imgStr =  Base64Util . encode ( imgData ) ;
             String imgParam =  URLEncoder . encode ( imgStr ,  "UTF-8" ) ;

             String param =  "image="  + imgParam ;

             //Note that the purpose here is to simplify the encoding and obtain access_token for each request. The online environment access_token has an expiration time, and the client can cache it and retrieve it after expiration.
             String accessToken =  "[Token obtained by calling the authentication interface]" ;

             String result =  HttpUtil . post ( url , accessToken , param ) ;
             System . out . println ( result ) ;
             return result ;
         }  catch  ( Exception e )  { e . printStackTrace ( ) ;
         }
         return  null ;
     }

     public  static  void  main ( String [ ] args )  { marriageCertificate . marriageCertificate ( ) ;
     }
 }

 # include  <iostream>
 # include  <curl/curl.h>

 //Download link of libcurl library: https://curl.haxx.se/download.html
 //Download link of jsoncpp library: https://github.com/open-source-parsers/jsoncpp/
 const  static std :: string request_url =  " https://aip.baidubce.com/rest/2.0/ocr/v1/marriage_certificate " ;
 static std :: string marriageCertificate_result ;
 /** *The curl sends the callback function called by the http request. The returned body in json format is parsed in the callback function, and the parsing result is stored in the global static variable *See the libcurl document for @ param parameter definitions *@ return See the libcurl document for the definition of the return value */
 static size_t callback ( void  * ptr , size_t size , size_t nmemb ,  void  * stream )  {
     //The obtained body is stored in ptr and converted to string format first marriageCertificate_result = std :: string ( ( char  * ) ptr , size * nmemb ) ;
     return size * nmemb ;
 }
 /** *Marriage certificate identification *@ return If the call is successful, 0 will be returned. If an error occurs, other error codes will be returned */
 int  marriageCertificate ( std :: string & json_result ,  const std :: string & access_token )  { std :: string url = request_url +  "?access_token="  + access_token ; CURL * curl =  NULL ; CURLcode result_code ;
     int is_success ; curl =  curl_easy_init ( ) ;
     if  ( curl )  {
         curl_easy_setopt ( curl , CURLOPT_URL , url . data ( ) ) ;
         curl_easy_setopt ( curl , CURLOPT_POST ,  one ) ; curl_httppost * post =  NULL ; curl_httppost * last =  NULL ;
         curl_formadd ( & post ,  & last , CURLFORM_COPYNAME ,  "image" , CURLFORM_COPYCONTENTS ,  "【base64_img】" , CURLFORM_END ) ;

         curl_easy_setopt ( curl , CURLOPT_HTTPPOST , post ) ;
         curl_easy_setopt ( curl , CURLOPT_WRITEFUNCTION , callback ) ; result_code =  curl_easy_perform ( curl ) ;
         if  ( result_code != CURLE_OK )  {
             fprintf ( stderr ,  "curl_easy_perform() failed: %s\n" ,
                     curl_easy_strerror ( result_code ) ) ; is_success =  one ;
             return is_success ;
         } json_result = marriageCertificate_result ;
         curl_easy_cleanup ( curl ) ; is_success =  zero ;
     }  else  {
         fprintf ( stderr ,  "curl_easy_init() failed." ) ; is_success =  one ;
     }
     return is_success ;
 }

 <? php
 /** *Initiate http post requests (REST APIs) and obtain the results of REST requests * @param string $url * @param string $param * @return - http response body if succeeds, else false. */
 function  request_post ( $url  =  '' ,  $param  =  '' )
 {
     if  ( empty ( $url )  ||  empty ( $param ) )  {
         return  false ;
     }

     $postUrl  =  $url ;
     $curlPost  =  $param ;
     //Initialize curl
     $curl  =  curl_init ( ) ;
     curl_setopt ( $curl ,  CURLOPT_URL ,  $postUrl ) ;
     curl_setopt ( $curl ,  CURLOPT_HEADER ,  zero ) ;
     //The result is required to be a string and output to the screen
     curl_setopt ( $curl ,  CURLOPT_RETURNTRANSFER ,  one ) ;
     curl_setopt ( $curl ,  CURLOPT_SSL_VERIFYPEER ,  false ) ;
     //Post submission method
     curl_setopt ( $curl ,  CURLOPT_POST ,  one ) ;
     curl_setopt ( $curl ,  CURLOPT_POSTFIELDS ,  $curlPost ) ;
     //Run curl
     $data  =  curl_exec ( $curl ) ;
     curl_close ( $curl ) ;

     return  $data ;
 }

 $token  =  '[Token obtained by calling the authentication interface]' ;
 $url  =  ' https://aip.baidubce.com/rest/2.0/ocr/v1/marriage_certificate?access_token= '  .  $token ;
 $img  =  file_get_contents ( '[Local file path]' ) ;
 $img  =  base64_encode ( $img ) ;
 $bodys  =  array (
     'image'  = >  $img
 ) ;
 $res  =  request_post ( $url ,  $bodys ) ;

 var_dump ( $res ) ;

 using System ;
 using System . IO ;
 using System . Net ;
 using System . Text ;
 using System . Web ;

 namespace com . baidu . ai {
     public  class marriageCertificate {
         //Marriage certificate identification
         public  static  string  marriageCertificate ( )
         {
             string token =  "[Token obtained by calling the authentication interface]" ;
             string host =  " https://aip.baidubce.com/rest/2.0/ocr/v1/marriage_certificate?access_token= "  + token ;
             Encoding encoding = Encoding . Default ;
             HttpWebRequest request =  ( HttpWebRequest ) WebRequest . Create ( host ) ; request . Method =  "post" ; request . KeepAlive =  true ;
             //Base64 encoding of pictures
             string base64 =  getFileBase64 ( [Local picture file] ) ;
             String str =  "image="  + HttpUtility . UrlEncode ( base64 ) ;
             byte [ ] buffer = encoding . GetBytes ( str ) ; request . ContentLength = buffer . Length ; request . GetRequestStream ( ) . Write ( buffer ,  zero , buffer . Length ) ;
             HttpWebResponse response =  ( HttpWebResponse ) request . GetResponse ( ) ;
             StreamReader reader =  new  StreamReader ( response . GetResponseStream ( ) , Encoding . Default ) ;
             string result = reader . ReadToEnd ( ) ; Console . WriteLine ( "Marriage certificate identification:" ) ; Console . WriteLine ( result ) ;
             return result ;
         }

         public  static  String  getFileBase64 ( String fileName )  {
             FileStream filestream =  new  FileStream ( fileName , FileMode . Open ) ;
             byte [ ] arr =  new  byte [ filestream . Length ] ; filestream . Read ( arr ,  zero ,  ( int ) filestream . Length ) ;
             string baser64 = Convert . ToBase64String ( arr ) ; filestream . Close ( ) ;
             return baser64 ;
         }
     }
 }

Return description

Return parameters

field	Required	type	explain
log_id	yes	uint64	Unique log ID for problem location
pdf_file_size	no	string	The total number of pages of the incoming PDF file. This field is returned when the pdf_file parameter is valid
words_result_num	yes	uint32	The number of recognition results, representing the number of words_result elements
words_result	yes	object{}	Identification results
+ word	yes	string	Field identification result, corresponding to Name: male, ID number: male, date of birth: male, nationality: male, gender: male, name: female, ID number: female, date of birth: female, nationality: female, gender: female, number of marriage certificate, holder, remarks, registration date Identification results of 14 fields
+ location	no	object{}	Field location information. This field is returned when the request parameter location=true
++ top	no	uint32	Top margin of the field
++ left	no	uint32	Left margin of the field
++ height	no	uint32	Height of field
++ width	no	uint32	Width of the field
+ probability	no	object{}	Confidence of field identification results. This field is returned when the request parameter probability=true
++ average	no	float	The average confidence value of each character in the field recognition result
++ min	no	float	The minimum confidence value of each character in the field recognition result

Return to Example

 {
     "words_result_num" :  fourteen ,
     "words_result" :  {
         "Name_men" :  [
             {
                 "word" :  "Li You"
             }
         ] ,
         "ID card number_men" :  [
             {
                 "word" :  "433024197905103103"
             }
         ] ,
         "Date of birth _ male" :  [
             {
                 "word" :  "1979-05-10"
             }
         ] ,
         "Nationality _ male" :  [
             {
                 "word" :  China
             }
         ] ,
         "Sex_Men" :  [
             {
                 "word" :  Male
             }
         ] ,
         "Name_Female" :  [
             {
                 "word" :  Liu Mei
             }
         ] ,
         "ID No. _ female" :  [
             {
                 "word" :  "433024197609160160"
             }
         ] ,
         "Date of birth _ female" :  [
             {
                 "word" :  "1976-09-16"
             }
         ] ,
         "Nationality _ female" :  [
             {
                 "word" :  China
             }
         ] ,
         "Sex_Female" :  [
             {
                 "word" :  Female
             }
         ] ,
         "Marriage Certificate No." :  [
             {
                 "word" :  "HXJZ No. 011004100"
             }
         ] ,
         "Licensee" :  [
             {
                 "word" :  "Li You"
             }
         ] ,
         Notes :  [
             {
                 "word" :  ""
             }
         ] ,
         "Registration date" :  [
             {
                 "word" :  "2010-06-10"
             }
         ]
     } ,
     "log_id" :  1645244176883578313
 }

Identification of Hong Kong, Macao and Taiwan certificates

Identification of house property certificate