PG 결제창 연동

<script src="https://js.bootpay.co.kr/bootpay-5.3.0.min.js"></script>html

dependencies {
    implementation 'io.github.bootpay:android:5.1.1'
}

target 'YourApp' do
  pod 'Bootpay', '~> 5.1.1'
endruby

flutter pub add bootpaybash

npm install react-native-bootpay-api
cd ios && pod install && cd ..bash

pip install bootpay-backendbash

composer require bootpay/server-phpbash

dependencies {
    implementation 'io.github.bootpay:backend:3.0.5'
}

gem install bootpaybash

go get github.com/bootpay/backend-go/v2bash

dotnet add package Bootpaybash

<script src="https://js.bootpay.co.kr/bootpay-5.3.0.min.js"></script>
<script>
Bootpay.requestPayment({
    client_key: '[ Client Key ]',
    price: 50000,
    order_name: '나이키 운동화 외 2건',
    order_id: 'order_' + Date.now(), // 테스트용. 실제로는 서버에서 생성한 주문번호 사용
    pg: 'nicepay',
    method: 'card',
    user: {
        username: '홍길동',
        phone: '01012345678'
    },
    extra: {
        separately_confirmed: true,
        open_type: 'redirect',
        // Web redirect에서는 인증 완료 후 이 서버 URL이 confirm을 먼저 받는다.
        redirect_url: 'https://yoursite.com/order/result'
    }
})
</script>html

// UIViewController 내부에서 호출
let payload = Payload()
payload.clientKey = "[ Client Key ]"
payload.price = 50000
payload.orderName = "나이키 운동화 외 2건"
payload.orderId = "order_\(Int(Date().timeIntervalSince1970))"
payload.pg = "나이스페이"
payload.method = "카드"

let user = BootUser()
user.username = "홍길동"
user.phone = "01012345678"
user.email = "user@example.com"
payload.user = user

let extra = BootExtra()
extra.separatelyConfirmed = true
payload.extra = extra

Bootpay.requestPayment(viewController: self, payload: payload)
    .onIssued { data in
        // 가상계좌는 issued에서 계좌 발급 정보를 받는다.
        // 주문은 입금 대기 상태로 저장하고, 실제 확정은 웹훅에서 처리해야 한다.
        self.savePendingVbankOrder(data)
    }
    .onConfirm { data in
        // 앱 SDK에서는 인증 완료 후 confirm 콜백이 먼저 호출된다.
        // data.receipt_id를 백엔드 승인 API로 보내고, 앱에서 바로 주문 완료 처리하면 안 돼요.
        self.requestServerApproval(data)
        return false
    }
    .onDone { data in
        // 서버 승인(separately_confirmed: true)에서는 호출되지 않는다.
        // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
    }
    .onCancel { data in self.keepOrderUnpaid(data) }
    .onError { data in self.showPaymentError(data) }
    .onClose { self.resetPaymentUi() }swift

// Activity 내부에서 호출
val user = BootUser()
    .setUsername("홍길동")
    .setPhone("01012345678")
    .setEmail("user@example.com")

val extra = BootExtra()
    .setSeparatelyConfirmed(true)

val payload = Payload()
    .setClientKey("[ Client Key ]")
    .setOrderName("나이키 운동화 외 2건")
    .setOrderId("order_${System.currentTimeMillis()}")
    .setPg("나이스페이")
    .setMethod("카드")
    .setPrice(50000.0)
    .setUser(user)
    .setExtra(extra)

Bootpay.init(supportFragmentManager)
    .setPayload(payload)
    .setEventListener(object : BootpayEventListener {
        override fun onConfirm(data: String): Boolean {
            // 앱 SDK에서는 인증 완료 후 confirm 콜백이 먼저 호출된다.
            // data 안의 receipt_id를 백엔드 승인 API로 보내고, 앱에서 바로 주문 완료 처리하면 안 돼요.
            requestServerApproval(data)
            return false
        }

        override fun onCancel(data: String) {
            // 사용자가 결제창을 닫은 경우. 주문은 미결제 상태로 유지해야 한다.
            keepOrderUnpaid(data)
        }

        override fun onError(data: String) {
            // 결제 요청·승인 과정에서 오류가 발생한 경우.
            logPaymentError(data)
            showPaymentError(data)
        }

        override fun onClose() { Bootpay.removePaymentWindow() }

        override fun onIssued(data: String) {
            // 가상계좌는 issued에서 계좌 발급 정보를 받는다.
            // 주문은 입금 대기 상태로 저장하고, 실제 확정은 웹훅에서 처리해야 한다.
            savePendingVbankOrder(data)
        }

        override fun onDone(data: String) {
            // 서버 승인(separately_confirmed: true)에서는 호출되지 않는다.
            // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
        }
    })
    .requestPayment()kotlin

// State 안에서 호출
final payload = Payload()
    ..clientKey = '[ Client Key ]'
    ..price = 50000
    ..orderName = '나이키 운동화 외 2건'
    ..orderId = 'order_${DateTime.now().millisecondsSinceEpoch}'
    ..pg = '나이스페이'
    ..method = '카드'
    ..user = (User()
        ..username = '홍길동'
        ..phone = '01012345678'
        ..email = 'user@example.com')
    ..extra = (Extra()
        ..separatelyConfirmed = true);

Bootpay().requestPayment(
    context: context,
    payload: payload,
    onConfirm: (data) {
        // 앱 SDK에서는 인증 완료 후 confirm 콜백이 먼저 호출된다.
        // data의 receipt_id를 백엔드 승인 API로 보내고, 앱에서 바로 주문 완료 처리하면 안 돼요.
        requestServerApproval(data);
        return false;
    },
    onCancel: (data) => debugPrint('cancel: $data'),
    onError: (data) => debugPrint('error: $data'),
    onIssued: (data) {
        // 가상계좌는 issued에서 계좌 발급 정보를 받는다.
        // 주문은 입금 대기 상태로 저장하고, 실제 확정은 웹훅에서 처리해야 한다.
        savePendingVbankOrder(data);
    },
    onDone: (data) {
        // 서버 승인(separatelyConfirmed: true)에서는 호출되지 않는다.
        // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
    },
    onClose: () => resetPaymentUi(),
);dart

// web/index.html <head>에 JS SDK 스크립트 추가 필수:
// <script src="https://js.bootpay.co.kr/bootpay-5.3.0.min.js"></script>

Payload payload = Payload();
payload.clientKey = '[ Client Key ]';
payload.price = 50000;
payload.orderName = '나이키 운동화 외 2건';
payload.orderId = DateTime.now().millisecondsSinceEpoch.toString();
payload.pg = 'nicepay';
payload.method = 'card';

User user = User();
user.username = '홍길동';
user.phone = '01012345678';
user.email = 'user@example.com';
payload.user = user;

// Flutter Web에서는 redirect 방식 권장
payload.extra = Extra();
payload.extra?.separatelyConfirmed = true;
payload.extra?.openType = 'redirect';
// Web redirect에서는 인증 완료 후 이 서버 URL이 confirm을 먼저 받는다.
payload.extra?.redirectUrl = 'https://yoursite.com/order/result';

Bootpay().requestPayment(
    context: context,
    payload: payload,
    onIssued: (data) {
        // 가상계좌는 issued에서 계좌 발급 정보를 받는다.
        savePendingVbankOrder(data);
    },
    onDone: (data) {
        // 서버 승인(separatelyConfirmed: true)에서는 호출되지 않는다.
        // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
    },
    onCancel: (data) => keepOrderUnpaid(data),
    onError: (data) => showPaymentError(data),
    onClose: () => resetPaymentUi(),
);dart

import React, { useRef } from 'react'
import Bootpay from 'react-native-bootpay-api'

export default function OrderScreen() {
    const bootpay = useRef(null)

    const requestPayment = () => {
        const payload = {
            pg: '나이스페이',
            method: '카드',
            order_name: '나이키 운동화 외 2건',
            order_id: `order_${Date.now()}`,
            price: 50000
        }

        const user = {
            username: '홍길동',
            phone: '01012345678',
            email: 'user@example.com'
        }

        const extra = {
            separately_confirmed: true,
            app_scheme: 'bootpaySample'
        }

        bootpay.current?.requestPayment(payload, [], user, extra)
    }

    return (
        <Bootpay
            ref={bootpay}
            client_key={'[ Client Key ]'}
            onConfirm={(data) => {
                // 앱 SDK에서는 인증 완료 후 confirm 콜백이 먼저 호출된다.
                // data.receipt_id를 백엔드 승인 API로 보내고, 앱에서 바로 주문 완료 처리하면 안 돼요.
                requestServerApproval(data)
                return false
            }}
            onIssued={(data) => {
                // 가상계좌는 issued에서 계좌 발급 정보를 받는다.
                // 주문은 입금 대기 상태로 저장하고, 실제 확정은 웹훅에서 처리해야 한다.
                savePendingVbankOrder(data)
            }}
            onDone={(data) => {
                // 서버 승인(separately_confirmed: true)에서는 호출되지 않는다.
                // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
            }}
            onCancel={(data) => console.log('cancel', data)}
            onError={(data) => console.log('error', data)}
            onClose={() => resetPaymentUi()}
        />
    )
}jsx

import Foundation
import UIKit

final class OrderViewController: UIViewController {
    func requestPayment() {
        let payload = Payload()
        payload.clientKey = "[ Client Key ]"
        payload.price = 50000
        payload.orderName = "나이키 운동화 외 2건"
        payload.orderId = "order_\(Int(Date().timeIntervalSince1970))"
        payload.pg = "나이스페이"
        payload.method = "카드"

        let extra = BootExtra()
        extra.separatelyConfirmed = true
        payload.extra = extra

        Bootpay.requestPayment(viewController: self, payload: payload)
            .onIssued { data in
                // 가상계좌는 issued에서 계좌 발급 정보를 받는다.
                // 실제 결제 확정은 입금 웹훅에서 처리해야 한다.
                self.savePendingVbankOrder(data)
            }
            .onConfirm { data in
                // iOS 앱은 인증 완료 후 confirm을 앱 콜백으로 먼저 받는다.
                // 이 자리에서 주문 완료 처리하면 안 되고, receipt_id를 서버 승인 API로 보내야 한다.
                self.requestServerApproval(
                    receiptId: data["receipt_id"] as? String,
                    orderId: payload.orderId
                )
                return false
            }
            .onDone { data in
                // 서버 승인(separately_confirmed: true)에서는 호출되지 않는다.
                // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
            }
            .onCancel { _ in self.showCancel() }
            .onError { data in self.showError(data) }
            .onClose { self.resetPaymentUi() }
    }

    private func requestServerApproval(receiptId: String?, orderId: String?) {
        guard let receiptId, let orderId else { return }

        var request = URLRequest(url: URL(string: "https://yoursite.com/order/result")!)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try? JSONSerialization.data(withJSONObject: [
            "event": "confirm",
            "receipt_id": receiptId,
            "order_id": orderId
        ])

        URLSession.shared.dataTask(with: request) { _, _, _ in
            // 서버가 금액·주문 상태·재고를 검증한 뒤 Bootpay 승인 API를 호출한다.
            // 앱은 서버 응답을 받은 뒤 완료 화면으로 이동해야 한다.
        }.resume()
    }
}swift

import java.io.IOException
import okhttp3.Call
import okhttp3.Callback
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.Response
import org.json.JSONObject

class OrderActivity : AppCompatActivity() {
    private val httpClient = OkHttpClient()

    fun requestPayment() {
        val orderId = "order_${System.currentTimeMillis()}"
        val extra = BootExtra().setSeparatelyConfirmed(true)
        val payload = Payload()
            .setClientKey("[ Client Key ]")
            .setOrderName("나이키 운동화 외 2건")
            .setOrderId(orderId)
            .setPg("나이스페이")
            .setMethod("카드")
            .setPrice(50000.0)
            .setExtra(extra)

        Bootpay.init(supportFragmentManager)
            .setPayload(payload)
            .setEventListener(object : BootpayEventListener {
                override fun onConfirm(data: String): Boolean {
                    // Android 앱은 인증 완료 후 confirm을 앱 콜백으로 먼저 받는다.
                    // data에서 receipt_id를 꺼내 서버 승인 API로 보내고, 앱에서는 승인 결과만 화면에 반영한다.
                    requestServerApproval(data, orderId)
                    return false
                }

                override fun onCancel(data: String) { showCancel() }
                override fun onError(data: String) { showError(data) }
                override fun onClose() { Bootpay.removePaymentWindow() }
                override fun onIssued(data: String) {
                    // 가상계좌는 issued에서 계좌 발급 정보를 받는다.
                    // 실제 결제 확정은 입금 웹훅에서 처리해야 한다.
                    savePendingVbankOrder(data)
                }
                override fun onDone(data: String) {
                    // 서버 승인(separately_confirmed: true)에서는 호출되지 않는다.
                    // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
                }
            })
            .requestPayment()
    }

    private fun requestServerApproval(confirmData: String, orderId: String) {
        val receiptId = JSONObject(confirmData).getString("receipt_id")
        val body = JSONObject()
            .put("event", "confirm")
            .put("receipt_id", receiptId)
            .put("order_id", orderId)
            .toString()
            .toRequestBody("application/json".toMediaType())

        val request = Request.Builder()
            .url("https://yoursite.com/order/result")
            .post(body)
            .build()

        httpClient.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                showError(e.message ?: "서버 승인 요청 실패")
            }

            override fun onResponse(call: Call, response: Response) {
                response.use {
                    // 서버가 금액·주문 상태·재고를 검증한 뒤 Bootpay 승인 API를 호출한다.
                    // 앱은 서버 응답을 받은 뒤 완료 화면으로 이동해야 한다.
                }
            }
        })
    }
}kotlin

import 'dart:convert';
import 'package:http/http.dart' as http;

class OrderPage extends StatefulWidget {
  const OrderPage({super.key});

  @override
  State<OrderPage> createState() => _OrderPageState();
}

class _OrderPageState extends State<OrderPage> {
  void requestPayment() {
    final orderId = 'order_${DateTime.now().millisecondsSinceEpoch}';
    final payload = Payload()
      ..clientKey = '[ Client Key ]'
      ..price = 50000
      ..orderName = '나이키 운동화 외 2건'
      ..orderId = orderId
      ..pg = '나이스페이'
      ..method = '카드'
      ..extra = (Extra()..separatelyConfirmed = true);

    Bootpay().requestPayment(
      context: context,
      payload: payload,
      onConfirm: (data) {
        // Flutter 앱은 인증 완료 후 confirm을 onConfirm으로 먼저 받는다.
        // receipt_id를 서버 승인 API로 보내고, 서버 응답 전에는 주문 완료로 표시하면 안 돼요.
        requestServerApproval(data, orderId);
        return false;
      },
      onCancel: (data) => showCancel(),
      onError: (data) => showError(data),
      onIssued: (data) {
        // 가상계좌는 issued에서 계좌 발급 정보를 받는다.
        // 실제 결제 확정은 입금 웹훅에서 처리해야 한다.
        savePendingVbankOrder(data);
      },
      onDone: (data) {
        // 서버 승인(separatelyConfirmed: true)에서는 호출되지 않는다.
        // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
      },
      onClose: () => resetPaymentUi(),
    );
  }

  Future<void> requestServerApproval(String data, String orderId) async {
    final confirm = jsonDecode(data) as Map<String, dynamic>;
    final response = await http.post(
      Uri.parse('https://yoursite.com/order/result'),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({
        'event': 'confirm',
        'receipt_id': confirm['receipt_id'],
        'order_id': orderId,
      }),
    );

    // 서버가 금액·주문 상태·재고를 검증한 뒤 Bootpay 승인 API를 호출한다.
    // 앱은 서버 응답을 받은 뒤 완료 화면으로 이동해야 한다.
    if (response.statusCode != 200) showError(response.body);
  }
}dart

class WebOrderPage extends StatelessWidget {
  const WebOrderPage({super.key});

  void requestPayment(BuildContext context) {
    final payload = Payload()
      ..clientKey = '[ Client Key ]'
      ..price = 50000
      ..orderName = '나이키 운동화 외 2건'
      ..orderId = 'order_${DateTime.now().millisecondsSinceEpoch}'
      ..pg = 'nicepay'
      ..method = 'card'
      ..extra = (Extra()
        ..separatelyConfirmed = true
        ..openType = 'redirect'
        ..redirectUrl = 'https://yoursite.com/order/result');

    // Flutter Web은 Web redirect와 동일하게 인증 완료 후 서버 URL이 confirm을 먼저 받는다.
    Bootpay().requestPayment(
      context: context,
      payload: payload,
      onIssued: (data) {
        // 가상계좌는 issued에서 계좌 발급 정보를 받는다.
        savePendingVbankOrder(data);
      },
      onDone: (data) {
        // 서버 승인(separatelyConfirmed: true)에서는 호출되지 않는다.
        // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
      },
      onCancel: (data) => keepOrderUnpaid(data),
      onError: (data) => showPaymentError(data),
      onClose: () => resetPaymentUi(),
    );
  }
}dart

import React, { useRef } from 'react'
import Bootpay from 'react-native-bootpay-api'

export default function OrderScreen() {
    const bootpay = useRef(null)
    const orderId = useRef(`order_${Date.now()}`)

    const requestPayment = () => {
        const payload = {
            pg: '나이스페이',
            method: '카드',
            order_name: '나이키 운동화 외 2건',
            order_id: orderId.current,
            price: 50000
        }
        const extra = { separately_confirmed: true, app_scheme: 'bootpaySample' }

        bootpay.current?.requestPayment(payload, [], {}, extra)
    }

    const requestServerApproval = async (data) => {
        // React Native는 인증 완료 후 confirm을 앱 콜백으로 먼저 받는다.
        // data.receipt_id를 서버 승인 API로 보내고, 앱에서 직접 승인 완료 처리하면 안 돼요.
        await fetch('https://yoursite.com/order/result', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                event: 'confirm',
                receipt_id: data.receipt_id,
                order_id: orderId.current
            })
        })
    }

    return (
        <Bootpay
            ref={bootpay}
            client_key={'[ Client Key ]'}
            onConfirm={(data) => {
                requestServerApproval(data)
                return false
            }}
            onIssued={(data) => {
                // 가상계좌는 issued에서 계좌 발급 정보를 받는다.
                // 실제 결제 확정은 입금 웹훅에서 처리해야 한다.
                savePendingVbankOrder(data)
            }}
            onDone={(data) => {
                // 서버 승인(separately_confirmed: true)에서는 호출되지 않는다.
                // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
            }}
            onCancel={(data) => console.log('cancel', data)}
            onError={(data) => console.log('error', data)}
            onClose={() => resetPaymentUi()}
        />
    )
}jsx

@app.route('/order/result', methods=['GET', 'POST'])
def payment_result():
    # Web redirect는 인증 완료 후 GET query, App SDK는 POST JSON으로 confirm을 보낸다.
    data = request.args if request.method == 'GET' else request.get_json()
    event = data.get('event', 'confirm')
    receipt_id = data.get('receipt_id')
    order_id = data.get('order_id')

    if event == 'cancel':
        return render_template('payment/cancel.html')

    if event == 'error':
        return render_template('payment/fail.html', message='결제 중 오류가 발생했다.')

    if event != 'confirm' or not receipt_id or not order_id:
        return render_template('payment/fail.html', message='결제 결과를 확인할 수 없다.')

    order = Order.find(order_id)
    if not order or order.status != 'pending':
        return render_template('payment/fail.html', message='승인할 수 없는 주문')

    if not check_inventory(order):
        return render_template('payment/fail.html', message='재고가 부족하다.')

    confirmed = bootpay.confirm_payment(receipt_id)
    if confirmed.get('status') != 1 or confirmed.get('price') != order.price:
        return render_template('payment/fail.html', message='결제 조회에 실패했다.')

    order.update(status='done', bootpay_receipt_id=receipt_id)
    return render_template('payment/complete.html', order_id=order_id)python

// Web redirect는 인증 완료 후 GET query, App SDK는 POST JSON으로 confirm을 보낸다.
$input = $_SERVER['REQUEST_METHOD'] === 'GET'
    ? $_GET
    : json_decode(file_get_contents('php://input'), true);

$event = $input['event'] ?? 'confirm';
$receipt_id = $input['receipt_id'] ?? '';
$order_id = $input['order_id'] ?? '';

if ($event === 'cancel') {
    include 'views/payment/cancel.php';
    exit;
}

if ($event === 'error') {
    $message = '결제 중 오류가 발생했다.';
    include 'views/payment/fail.php';
    exit;
}

if ($event !== 'confirm' || !$receipt_id || !$order_id) {
    $message = '결제 결과를 확인할 수 없다.';
    include 'views/payment/fail.php';
    exit;
}

$order = Order::find($order_id);
if (!$order || $order->status !== 'pending') {
    $message = '승인할 수 없는 주문';
    include 'views/payment/fail.php';
    exit;
}

if (!checkInventory($order)) {
    $message = '재고가 부족하다.';
    include 'views/payment/fail.php';
    exit;
}

$confirmed = BootpayApi::confirmPayment($receipt_id);
if ($confirmed['status'] !== 1 || $confirmed['price'] !== $order->price) {
    $message = '결제 조회에 실패했다.';
    include 'views/payment/fail.php';
    exit;
}

$order->update([
    'status' => 'done',
    'bootpay_receipt_id' => $receipt_id,
]);

include 'views/payment/complete.php';php

@RequestMapping(value = "/order/result", method = {RequestMethod.GET, RequestMethod.POST})
public String paymentResult(
    @RequestParam(required = false) Map<String, String> query,
    @RequestBody(required = false) Map<String, String> body,
    Model model
) throws Exception {
    // Web redirect는 인증 완료 후 GET query, App SDK는 POST body로 confirm을 보낸다.
    Map<String, String> input = body != null ? body : query;
    String event = input.getOrDefault("event", "confirm");
    String receiptId = input.get("receipt_id");
    String orderId = input.get("order_id");

    if ("cancel".equals(event)) return "payment/cancel";

    if ("error".equals(event)) {
        model.addAttribute("message", "결제 중 오류가 발생했다.");
        return "payment/fail";
    }

    if (!"confirm".equals(event) || receiptId == null || orderId == null) {
        model.addAttribute("message", "결제 결과를 확인할 수 없다.");
        return "payment/fail";
    }

    var order = orderRepository.findById(orderId);
    if (order.isEmpty() || !"pending".equals(order.get().getStatus())) {
        model.addAttribute("message", "승인할 수 없는 주문");
        return "payment/fail";
    }

    if (!checkInventory(order.get())) {
        model.addAttribute("message", "재고가 부족하다.");
        return "payment/fail";
    }

    var confirmed = bootpay.confirm(receiptId);
    int status = ((Number) confirmed.get("status")).intValue();
    double price = ((Number) confirmed.get("price")).doubleValue();

    if (status != 1 || price != order.get().getPrice()) {
        model.addAttribute("message", "결제 조회에 실패했다.");
        return "payment/fail";
    }

    order.get().setStatus("done");
    order.get().setBootpayReceiptId(receiptId);
    orderRepository.save(order.get());

    model.addAttribute("order_id", orderId);
    return "payment/complete";
}java

route :get, :post, '/order/result' do
  # Web redirect는 인증 완료 후 GET query, App SDK는 POST JSON으로 confirm을 보낸다.
  data = request.get? ? params : JSON.parse(request.body.read)
  event = data['event'] || 'confirm'
  receipt_id = data['receipt_id']
  order_id = data['order_id']

  return erb :'payment/cancel' if event == 'cancel'
  return erb :'payment/fail', locals: { message: '결제 중 오류가 발생했다.' } if event == 'error'

  unless event == 'confirm' && receipt_id && order_id
    return erb :'payment/fail', locals: { message: '결제 결과를 확인할 수 없다.' }
  end

  order = Order.find(order_id)
  unless order && order.status == 'pending'
    return erb :'payment/fail', locals: { message: '승인할 수 없는 주문' }
  end

  unless check_inventory(order)
    return erb :'payment/fail', locals: { message: '재고가 부족하다.' }
  end

  confirmed = bootpay.confirm(receipt_id).data
  if confirmed['status'] != 1 || confirmed['price'] != order.price
    return erb :'payment/fail', locals: { message: '결제 조회에 실패했다.' }
  end

  order.update(status: 'done', bootpay_receipt_id: receipt_id)
  erb :'payment/complete', locals: { order_id: order_id }
endruby

func paymentResult(w http.ResponseWriter, r *http.Request) {
	// Web redirect는 인증 완료 후 GET query, App SDK는 POST JSON으로 confirm을 보낸다.
	input := r.URL.Query()
	if r.Method == http.MethodPost {
		var body map[string]string
		json.NewDecoder(r.Body).Decode(&body)
		input = url.Values{}
		for key, value := range body {
			input.Set(key, value)
		}
	}

	event := input.Get("event")
	if event == "" { event = "confirm" }
	receiptId := input.Get("receipt_id")
	orderId := input.Get("order_id")

	if event == "cancel" {
		renderTemplate(w, "payment/cancel", nil)
		return
	}

	if event == "error" {
		renderTemplate(w, "payment/fail", map[string]string{"message": "결제 중 오류가 발생했다."})
		return
	}

	if event != "confirm" || receiptId == "" || orderId == "" {
		renderTemplate(w, "payment/fail", map[string]string{"message": "결제 결과를 확인할 수 없다."})
		return
	}

	order, err := findOrder(orderId)
	if err != nil || order.Status != "pending" {
		renderTemplate(w, "payment/fail", map[string]string{"message": "승인할 수 없는 주문"})
		return
	}

	if !checkInventory(order) {
		renderTemplate(w, "payment/fail", map[string]string{"message": "재고가 부족하다."})
		return
	}

	confirmed, err := api.ServerConfirm(receiptId)
	if err != nil {
		renderTemplate(w, "payment/fail", map[string]string{"message": "결제 조회에 실패했다."})
		return
	}

	status := int(confirmed["status"].(float64))
	price := confirmed["price"].(float64)
	if status != 1 || price != order.Price {
		renderTemplate(w, "payment/fail", map[string]string{"message": "결제 조회에 실패했다."})
		return
	}

	markOrderDone(orderId, receiptId)
	renderTemplate(w, "payment/complete", map[string]string{"order_id": orderId})
}go

public class PaymentConfirmRequest
{
    public string Event { get; set; }
    [JsonPropertyName("receipt_id")] public string ReceiptId { get; set; }
    [JsonPropertyName("order_id")] public string OrderId { get; set; }
}

[AcceptVerbs("GET", "POST")]
[Route("/order/result")]
public async Task<IActionResult> PaymentResult(
    [FromQuery] string @event,
    [FromQuery(Name = "receipt_id")] string queryReceiptId,
    [FromQuery(Name = "order_id")] string queryOrderId,
    [FromBody] PaymentConfirmRequest body)
{
    // Web redirect는 인증 완료 후 query, App SDK는 body로 confirm을 보낸다.
    var eventName = body?.Event ?? @event ?? "confirm";
    var receiptId = body?.ReceiptId ?? queryReceiptId;
    var orderId = body?.OrderId ?? queryOrderId;

    if (eventName == "cancel") return View("Payment/Cancel");

    if (eventName == "error") {
        return View("Payment/Fail", new { Message = "결제 중 오류가 발생했다." });
    }

    if (eventName != "confirm" || string.IsNullOrEmpty(receiptId) || string.IsNullOrEmpty(orderId)) {
        return View("Payment/Fail", new { Message = "결제 결과를 확인할 수 없다." });
    }

    var order = await orderRepository.FindAsync(orderId);
    if (order == null || order.Status != "pending") {
        return View("Payment/Fail", new { Message = "승인할 수 없는 주문" });
    }

    if (!CheckInventory(order)) {
        return View("Payment/Fail", new { Message = "재고가 부족하다." });
    }

    var response = await bootpay.Confirm(receiptId);
    var confirmed = JsonConvert.DeserializeObject<Dictionary<string, object>>(
        await response.Content.ReadAsStringAsync()
    );

    if (Convert.ToInt32(confirmed["status"]) != 1 || Convert.ToDecimal(confirmed["price"]) != order.Price) {
        return View("Payment/Fail", new { Message = "결제 조회에 실패했다." });
    }

    order.Status = "done";
    order.BootpayReceiptId = receiptId;
    await orderRepository.SaveAsync(order);

    return View("Payment/Complete", new { orderId = orderId });
}csharp

{
  "event": "done",
  "receipt_id": "6244f60c1fc19202e42e8c4e",
  "order_id": "order_20260428_001",
  "price": 1000,
  "status": 1,
  "method": "card",
  "method_symbol": "card",
  "purchased_at": "2026-04-28T09:30:29+09:00"
}json

{
  "event": "issued",
  "receipt_id": "6244f60c1fc19202e42e8c4e",
  "order_id": "order_20260428_001",
  "method": "vbank",
  "status": 5,
  "vbank_data": {
    "bank_name": "국민은행",
    "account": "1234567890",
    "account_holder": "부트페이",
    "expired_at": "2026-04-29T23:59:59+09:00"
  }
}json

{
  "event": "error",
  "error_code": "RC_REQUEST_FAILED",
  "message": "결제 요청이 실패했다.",
  "receipt_id": "6244f60c1fc19202e42e8c4e"
}json

{
  "event": "cancel",
  "message": "사용자가 결제를 취소했습니다.",
  "receipt_id": "6244f60c1fc19202e42e8c4e"
}json

<script src="https://js.bootpay.co.kr/bootpay-5.3.0.min.js"></script>
<script>
Bootpay.requestPayment({
    client_key: '[ Client Key ]',
    price: 50000,
    order_name: '나이키 운동화 외 2건',
    order_id: 'order_' + Date.now(),
    pg: 'nicepay',
    method: 'card',
    extra: {
        separately_confirmed: true,
        open_type: 'redirect',
        redirect_url: 'https://yoursite.com/order/result',
        // true면 오류 발생 시 부트페이 제공 결과 UI에 에러 내용을 표시해요.
        display_error_result: true
    }
}).catch(function (data) {
    // cancel: 사용자가 결제창을 닫은 경우. 주문은 미결제 상태로 유지해야 한다.
    // error: 결제 요청·승인 과정에서 오류가 발생한 경우. error_code, pg_error_code, message를 로그로 남긴다.
    if (data.event === 'cancel') {
        keepOrderUnpaid(data)
        return
    }

    if (data.event === 'error') {
        logPaymentError(data.error_code, data.pg_error_code, data.message)
        showPaymentError(data.message)
    }
})
</script>html

Bootpay.requestPayment(viewController: self, payload: payload)
    .onIssued { data in
        // issued: 가상계좌 발급. 주문은 입금 대기 상태로 저장해야 한다.
        self.savePendingVbankOrder(data)
    }
    .onConfirm { data in
        // confirm: 서버 승인 방식을 쓰면 receipt_id를 백엔드로 보내야 한다.
        self.requestServerApproval(data)
        return false
    }
    .onDone { data in
        // done: 서버 승인(separately_confirmed: true)에서는 호출되지 않는다.
        // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
    }
    .onCancel { data in
        // cancel: 사용자가 결제창을 닫은 경우. 주문은 미결제 상태로 유지해야 한다.
        self.keepOrderUnpaid(data)
    }
    .onError { data in
        // error: 결제 요청·승인 과정에서 오류가 발생한 경우.
        // error_code, pg_error_code, message를 로그로 남기고 재시도 흐름을 보여준다.
        self.logPaymentError(data)
        self.showPaymentError(data)
    }
    .onClose {
        // close: 결제창이 닫힌 경우. UI 상태만 정리하고 주문 확정 처리하면 안 돼요.
        self.resetPaymentUi()
    }swift

Bootpay.init(supportFragmentManager)
    .setPayload(payload)
    .setEventListener(object : BootpayEventListener {
        override fun onConfirm(data: String): Boolean {
            requestServerApproval(data)
            return false
        }

        override fun onCancel(data: String) {
            // 사용자가 결제창을 닫은 경우. 주문은 미결제 상태로 유지해야 한다.
            keepOrderUnpaid(data)
        }

        override fun onError(data: String) {
            // 결제 요청·승인 과정에서 오류가 발생한 경우.
            // data에서 error_code, pg_error_code, message를 확인해 로그로 남긴다.
            logPaymentError(data)
            showPaymentError(data)
        }

        override fun onClose() {
            // close: 결제창이 닫힌 경우. UI 상태만 정리하고 주문 확정 처리하면 안 돼요.
            Bootpay.removePaymentWindow()
        }

        override fun onIssued(data: String) {
            // issued: 가상계좌 발급. 주문은 입금 대기 상태로 저장해야 한다.
            savePendingVbankOrder(data)
        }

        override fun onDone(data: String) {
            // done: 서버 승인(separately_confirmed: true)에서는 호출되지 않는다.
            // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
        }
    })
    .requestPayment()kotlin

Bootpay().requestPayment(
  context: context,
  payload: payload,
  onConfirm: (data) {
    // confirm: 서버 승인 방식을 쓰면 receipt_id를 백엔드로 보내야 한다.
    requestServerApproval(data);
    return false;
  },
  onIssued: (data) {
    // issued: 가상계좌 발급. 주문은 입금 대기 상태로 저장해야 한다.
    savePendingVbankOrder(data);
  },
  onDone: (data) {
    // done: 서버 승인(separatelyConfirmed: true)에서는 호출되지 않는다.
    // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
  },
  onCancel: (data) {
    // cancel: 사용자가 결제창을 닫은 경우. 주문은 미결제 상태로 유지해야 한다.
    keepOrderUnpaid(data);
  },
  onError: (data) {
    // error: 결제 요청·승인 과정에서 오류가 발생한 경우.
    // data에서 error_code, pg_error_code, message를 확인해 로그로 남긴다.
    logPaymentError(data);
    showPaymentError(data);
  },
  onClose: () => resetPaymentUi(),
);dart

Bootpay().requestPayment(
  context: context,
  payload: payload,
  onIssued: (data) {
    // issued: 가상계좌 발급. 주문은 입금 대기 상태로 저장해야 한다.
    savePendingVbankOrder(data);
  },
  onDone: (data) {
    // done: 서버 승인(separatelyConfirmed: true)에서는 호출되지 않는다.
    // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
  },
  onCancel: (data) {
    // cancel: Flutter Web에서 결제창이 닫히면 주문은 미결제 상태로 유지해야 한다.
    keepOrderUnpaid(data);
  },
  onError: (data) {
    // error: 결제 요청·승인 과정에서 오류가 발생한 경우.
    // redirect_url로 넘어온 error 결과도 서버에서 같은 기준으로 처리해야 한다.
    logPaymentError(data);
    showPaymentError(data);
  },
  onClose: () => resetPaymentUi(),
);dart

<Bootpay
    ref={bootpay}
    client_key={'[ Client Key ]'}
    onConfirm={(data) => {
        // confirm: 서버 승인 방식을 쓰면 receipt_id를 백엔드로 보내야 한다.
        requestServerApproval(data)
        return false
    }}
    onIssued={(data) => {
        // issued: 가상계좌 발급. 주문은 입금 대기 상태로 저장해야 한다.
        savePendingVbankOrder(data)
    }}
    onDone={(data) => {
        // done: 서버 승인(separately_confirmed: true)에서는 호출되지 않는다.
        // 클라이언트 자동 승인 방식에서만 결제 완료 후 호출된다.
    }}
    onCancel={(data) => {
        // cancel: 사용자가 결제창을 닫은 경우. 주문은 미결제 상태로 유지해야 한다.
        keepOrderUnpaid(data)
    }}
    onError={(data) => {
        // error: 결제 요청·승인 과정에서 오류가 발생한 경우.
        // error_code, pg_error_code, message를 로그로 남기고 재시도 흐름을 보여준다.
        logPaymentError(data)
        showPaymentError(data.message)
    }}
    onClose={() => {
        // close: 결제창이 닫힌 경우. UI 상태만 정리하고 주문 확정 처리하면 안 돼요.
        resetPaymentUi()
    }}
/>jsx