Cybersource - KCP

Configure KCP via CyberSource as a payment method in Gr4vy.

Cybersource is a Visa solution that provides comprehensive payment processing solutions across multiple payment methods and regions.

KCP (Korea Cyber Payment) is a popular online payment method in South Korea that allows customers to pay using various Korean payment options including credit cards, bank transfers, and mobile payments. It is widely used for e-commerce transactions in Korea.

Setup

Please follow the common Cybersource instructions to get set up with CyberSource.

After setting up your Cybersource account, make sure KCP is enabled as a payment method on your account.

Capabilities

Supported countries

Supported currencies

Integration

For KCP, the default integration for CyberSource is through a redirect to a hosted payments page.

Start by creating a new transaction with the following required fields.

C#

var transaction = await client.Transactions.CreateAsync(
  transactionCreate: new TransactionCreate()
  {
    Amount = 1299,
    Currency = "KRW",
    Country = "KR",
    PaymentMethod =
      TransactionCreatePaymentMethod.CreateRedirectPaymentMethodCreate(
        new RedirectPaymentMethodCreate()
        {
          Method = "kcp",
          Country = "KR",
          Currency = "KRW",
          RedirectUrl = "https://example.com/callback",
        }
      ),
  }
);

amount := int64(1299)
currency := "KRW"
country := "KR"
method := components.RedirectPaymentMethodCreateMethodKcp
redirectUrl := "https://example.com/callback"

redirectPaymentMethodCreate := components.RedirectPaymentMethodCreate{
  Method: method,
  Country: country,
  Currency: currency,
  RedirectURL: redirectUrl,
}
paymentMethod := components.CreateTransactionCreatePaymentMethodRedirectPaymentMethodCreate(redirectPaymentMethodCreate)

transactionCreate := components.TransactionCreate{
  Amount:        amount,
  Currency:      currency,
  Country:       &country,
  PaymentMethod: &paymentMethod,
}

transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil, nil)

CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
  .transactionCreate(TransactionCreate.builder()
    .amount(1299L)
    .currency("KRW")
    .country("KR")
    .paymentMethod(TransactionCreatePaymentMethod.of(RedirectPaymentMethodCreate.builder()
      .method(RedirectPaymentMethodCreateMethod.KCP)
      .country("KR")
      .currency("KRW")
      .redirectUrl("https://example.com/callback")
      .build()))
    .build())
  .call();

Transaction transaction = transactionResponse.transaction().orElse(null);

$transactionCreate = new TransactionCreate(
  amount: 1299,
  currency: 'KRW',
  country: 'KR',
  paymentMethod: new RedirectPaymentMethodCreate(
    method: 'kcp',
    country: 'KR',
    currency: 'KRW',
    redirectUrl: 'https://example.com/callback'
  )
);
$response = self::$sdk->transactions->create($transactionCreate);
$transaction = $response->transaction;

transaction: models.Transaction = client.transactions.create(
  amount=1299,
  currency="KRW",
  country="KR",
  payment_method={
    "method": "kcp",
    "country": "KR",
    "currency": "KRW",
    "redirect_url": "https://example.com/callback",
  }
)

const transaction = await gr4vy.transactions.create({
  amount: 1299,
  currency: "KRW",
  country: "KR",
  paymentMethod: {
    method: "kcp",
    country: "KR",
    currency: "KRW",
    redirectUrl: "https://example.com/callback"
  }
})

After the transaction is created, the API response includes payment_method.approval_url and the buyer_approval_pending status.

{
  "type": "transaction",
  "id": "ea1efdd0-20f9-44d9-9b0b-0a3d71e9b625",
  "payment_method": {
    "type": "payment-method",
    "approval_url": "https://cdn.sandbox.spider.gr4vy.app/connectors/cybersource/apm.html?token=..."
  },
  "method": "kcp"
}

Redirect the buyer to the approval_url so they can complete authentication and approve the payment. After approval the buyer is redirected to the redirect_url you provided when creating the transaction. Do not rely solely on the redirect - either poll the transaction or (recommended) rely on webhooks to detect the final status (for example capture_succeeded or failure states).

Pending transactions

Cybersource does not support webhooks for KCP transactions yet. This means that any payment in a pending status requires a query to the Cybersource API to get the latest status. The system automatically polls for status updates.

Canceled transactions

The KCP sandbox allows for canceling a transaction, but on return to the server the status of the transaction is checked with Cybersource. It has been noticed that sometimes the server returns a completed status for canceled transactions, resulting in a captured status. This is likely only an issue in sandbox, and this issue has been raised with KCP and Cybersource.

Testing

Cybersource has instructions on how to test KCP.