인증창 없이 연동

from bootpay_backend import BootpayBackend

bootpay = BootpayBackend(client_key='[ Client Key ]', secret_key='[ Secret Key ]')

# 사용자 휴대폰으로 인증번호가 전송된다.
requested = bootpay.request_authentication(
    authentication_id=f'auth_{int(time.time())}',
    pg='다날',
    method='본인인증',
    order_name='회원가입 본인인증',
    authenticate_type='sms',
    username='홍길동',
    identity_no='9001011',  # 생년월일 6자리 + 주민등록번호 뒤 첫 1자리 = 7자리
    carrier='SKT',
    phone='01012345678',
    client_ip=request.headers.get('X-Forwarded-For', request.remote_addr).split(',')[0]
)

# receipt_id를 세션·DB에 보관했다가 승인 단계에서 사용한다.
print(requested.get('receipt_id'))python

BootpayApi::setClientKeyConfiguration('[ Client Key ]', '[ Secret Key ]');

// 사용자 휴대폰으로 인증번호가 전송된다.
$requested = BootpayApi::requestAuthentication([
    'authentication_id' => 'auth_' . time(),
    'pg' => '다날',
    'method' => '본인인증',
    'order_name' => '회원가입 본인인증',
    'authenticate_type' => 'sms',
    'username' => '홍길동',
    'identity_no' => '9001011',  // 생년월일 6자리 + 주민등록번호 뒤 첫 1자리 = 7자리
    'carrier' => 'SKT',
    'phone' => '01012345678',
    'client_ip' => $_SERVER['HTTP_X_FORWARDED_FOR'] ?? $_SERVER['REMOTE_ADDR']
]);

// receipt_id를 세션·DB에 보관했다가 승인 단계에서 사용한다.
echo $requested->receipt_id;php

import kr.co.bootpay.pg.Bootpay;
import kr.co.bootpay.pg.model.request.Authentication;

Bootpay bootpay = Bootpay.withClientKey("[ Client Key ]", "[ Secret Key ]");

Authentication auth = new Authentication();
auth.authenticationId = "auth_" + System.currentTimeMillis();
auth.pg = "다날";
auth.method = "본인인증";
auth.orderName = "회원가입 본인인증";
auth.authenticateType = "sms";
auth.username = "홍길동";
auth.identityNo = "9001011"; // 생년월일 6자리 + 주민등록번호 뒤 첫 1자리 = 7자리
auth.carrier = "SKT";
auth.phone = "01012345678";
auth.clientIp = clientIp;

// 사용자 휴대폰으로 인증번호가 전송된다.
HashMap<String, Object> requested = bootpay.requestAuthentication(auth);

// receipt_id를 세션·DB에 보관했다가 승인 단계에서 사용한다.
String receiptId = (String) requested.get("receipt_id");java

bootpay = Bootpay::Api.new(client_key: '[ Client Key ]', secret_key: '[ Secret Key ]')

# 사용자 휴대폰으로 인증번호가 전송된다.
requested = bootpay.request_authentication(
  authentication_id: "auth_#{Time.now.to_i}",
  pg: '다날',
  method: '본인인증',
  order_name: '회원가입 본인인증',
  authenticate_type: 'sms',
  username: '홍길동',
  identity_no: '9001011',  # 생년월일 6자리 + 주민등록번호 뒤 첫 1자리 = 7자리
  carrier: 'SKT',
  phone: '01012345678',
  client_ip: request.env['HTTP_X_FORWARDED_FOR'] || request.ip
)

# receipt_id를 세션·DB에 보관했다가 승인 단계에서 사용한다.
receipt_id = requested.data['receipt_id']ruby

api := bootpay.NewAPIWithClientKey("[ Client Key ]", "[ Secret Key ]", nil, "")

authData := bootpay.Authentication{
	AuthenticationId: fmt.Sprintf("auth_%d", time.Now().UnixMilli()),
	Pg:               "다날",
	Method:           "본인인증",
	OrderName:        "회원가입 본인인증",
	AuthenticateType: "sms",
	Username:         "홍길동",
	IdentityNo:       "9001011", // 생년월일 6자리 + 주민등록번호 뒤 첫 1자리 = 7자리
	Carrier:          "SKT",
	Phone:            "01012345678",
	ClientIp:         clientIp,
}

// 사용자 휴대폰으로 인증번호가 전송된다.
requested, err := api.RequestAuthentication(authData)
if err != nil {
	return err
}

// receipt_id를 세션·DB에 보관했다가 승인 단계에서 사용한다.
receiptId := requested["receipt_id"].(string)go

using Bootpay;
using Bootpay.models;

var api = BootpayApi.WithClientKey("[ Client Key ]", "[ Secret Key ]");

var auth = new Authentication
{
    authenticationId = $"auth_{DateTimeOffset.Now.ToUnixTimeMilliseconds()}",
    pg = "다날",
    method = "본인인증",
    orderName = "회원가입 본인인증",
    authenticateType = "sms",
    username = "홍길동",
    identityNo = "9001011", // 생년월일 6자리 + 주민등록번호 뒤 첫 1자리 = 7자리
    carrier = "SKT",
    phone = "01012345678",
    clientIp = clientIp
};

// 사용자 휴대폰으로 인증번호가 전송된다.
var response = await api.RequestAuthentication(auth);
var requested = JsonConvert.DeserializeObject<Dictionary<string, object>>(
    await response.Content.ReadAsStringAsync()
);

// receipt_id를 세션·DB에 보관했다가 승인 단계에서 사용한다.
var receiptId = requested["receipt_id"].ToString();csharp

confirmed = bootpay.confirm_authentication(receipt_id=receipt_id, otp=otp)

# status 12(본인인증완료)일 때만 인증 완료로 처리한다.
if confirmed.get('status') != 12:
    raise Exception('본인인증이 완료되지 않았습니다.')

# unique = CI(연계정보, 기관 공통), di = DI(중복가입 확인정보, 가맹점별)
data = confirmed.get('authenticate_data')
save_verified_user(
    name=data.get('name'),
    birth=data.get('birth'),
    ci=data.get('unique'),
    di=data.get('di')
)python

$confirmed = BootpayApi::confirmAuthentication($receiptId, $otp);

// status 12(본인인증완료)일 때만 인증 완료로 처리한다.
if ($confirmed->status !== 12) {
    throw new Exception('본인인증이 완료되지 않았습니다.');
}

// unique = CI(연계정보, 기관 공통), di = DI(중복가입 확인정보, 가맹점별)
$data = $confirmed->authenticate_data;
saveVerifiedUser($data->name, $data->birth, $data->unique, $data->di);php

HashMap<String, Object> confirmed = bootpay.confirmAuthentication(receiptId, otp);

// status 12(본인인증완료)일 때만 인증 완료로 처리한다.
if (((Number) confirmed.get("status")).intValue() != 12) {
    throw new IllegalStateException("본인인증이 완료되지 않았습니다.");
}

// unique = CI(연계정보, 기관 공통), di = DI(중복가입 확인정보, 가맹점별)
@SuppressWarnings("unchecked")
Map<String, Object> data = (Map<String, Object>) confirmed.get("authenticate_data");
saveVerifiedUser(data.get("name"), data.get("birth"), data.get("unique"), data.get("di"));java

confirmed = bootpay.confirm_authentication(receipt_id, otp: otp).data

# status 12(본인인증완료)일 때만 인증 완료로 처리한다.
raise '본인인증이 완료되지 않았습니다.' if confirmed['status'] != 12

# unique = CI(연계정보, 기관 공통), di = DI(중복가입 확인정보, 가맹점별)
data = confirmed['authenticate_data']
save_verified_user(name: data['name'], birth: data['birth'], ci: data['unique'], di: data['di'])ruby

confirmed, err := api.ConfirmAuthentication(bootpay.AuthenticationParams{
	ReceiptId: receiptId,
	Otp:       otp,
})
if err != nil {
	return err
}

// status 12(본인인증완료)일 때만 인증 완료로 처리한다.
if int(confirmed["status"].(float64)) != 12 {
	return errors.New("본인인증이 완료되지 않았습니다.")
}

// unique = CI(연계정보, 기관 공통), di = DI(중복가입 확인정보, 가맹점별)
data := confirmed["authenticate_data"].(map[string]interface{})
saveVerifiedUser(data["name"], data["birth"], data["unique"], data["di"])go

var confirmResponse = await api.ConfirmAuthentication(new AuthenticationParams
{
    receiptId = receiptId,
    otp = otp
});
var confirmed = JsonConvert.DeserializeObject<Dictionary<string, object>>(
    await confirmResponse.Content.ReadAsStringAsync()
);

// status 12(본인인증완료)일 때만 인증 완료로 처리한다.
if (Convert.ToInt32(confirmed["status"]) != 12)
{
    throw new InvalidOperationException("본인인증이 완료되지 않았습니다.");
}

// unique = CI(연계정보, 기관 공통), di = DI(중복가입 확인정보, 가맹점별)
var data = (JObject)confirmed["authenticate_data"];
SaveVerifiedUser(data["name"], data["birth"], data["unique"], data["di"]);csharp

bootpay.realarm_authentication(receipt_id=receipt_id)python

BootpayApi::realarmAuthentication($receiptId);php

bootpay.realarmAuthentication(receiptId);java

bootpay.realarm_authentication(receipt_id)ruby

_, err := api.RealarmAuthentication(bootpay.AuthenticationParams{ReceiptId: receiptId})go

await api.RealarmAuthentication(new AuthenticationParams { receiptId = receiptId });csharp