CheckoutComponents

Last updated: March 18, 2026

Initializes a CheckoutComponentConfiguration instance.


1/**
2 * Common configurations for all payment components
3 *
4 * @property [Context] represents the application context
5 * @property [PaymentSessionResponse] paymentSession represents the payment session response
6 * @property publicKey represents the public API key, prefixed with pk_
7 * @property [Environment] represents the environment that the library points to, and sends requests to
8 * @property locale represents the customer’s locale and preferred language, used to localize the CheckoutComponents
9 * @property componentOptions [ComponentOptions] configures the component's behavior for different payment methods
10 * @property componentCallback [ComponentCallback] is a generic ComponentCallback for all payment methods
11 * @property translations contains translations for the component, including a map of Locale, with the value of another map of ComponentTranslationKey and the translation string
12 * @property flowCoordinators is a map containing all flow coordinators
13 * @property appearance contains the design tokens for customizing the component's appearance
14 */
15public data class CheckoutComponentConfiguration @JvmOverloads constructor(
16  val context: Context,
17  val paymentSession: PaymentSessionResponse,
18  val publicKey: String,
19  val environment: Environment,
20  val locale: Locale?,
21  val componentOptions: ComponentOptions,
22  val componentCallback: ComponentCallback?,
23  val translations: Translations?,
24  val flowCoordinators: Map<PaymentMethodName, FlowCoordinator>,
25  val appearance: DesignTokens? = null,
26)

Initializes a CheckoutComponent instance.


1val configuration = CheckoutComponentConfiguration(
2  context = context,
3  paymentSession = PaymentSessionResponse(
4  paymentSessionId,
5  paymentSessionToken,
6  paymentSessionSecret,
7  ),
8  publicKey = "YOUR_PUBLIC_KEY",
9  environment = Environment.SANDBOX,
10)
11
12// Create CheckoutComponents
13CoroutineScope(Dispatchers.IO).launch {
14  try {
15    val checkoutComponents = CheckoutComponentsFactory(config = configuration).create()
16  } catch (checkoutError: CheckoutError) {
17    handleError(checkoutError)
18  }
19}

Initializes a PaymentMethodComponent instance.


1val options = ComponentOption(
2  callback = ComponentCallback(
3    onSuccess = {
4      // Handle payment success
5    },
6  ),
7  addressConfiguration = AddressConfiguration(
8    // optional, prefilled address
9    data = ContactData(
10      address = Address(
11        addressLine1 = "123 Main St",
12        addressLine2 = "Sakura apartments",
13        city = "Tokyo",
14        state = "Shanghai",
15        country = Country.JAPAN,
16        zip = "100-0001",
17      ),
18      phone = Phone(country = Country.UNITED_KINGDOM, number = "7425125181"),
19      name = Name(firstName = "John", lastName = "Doe"),
20      email = "johndoe@email.com"
21    ),
22    // optional, what address fields to collect. Defaults to billing address
23    fields = listOf(
24      AddressField.Country,
25      AddressField.AddressLine1(),
26      AddressField.AddressLine2(),
27      AddressField.City(),
28      AddressField.State()
29    ),
30    // optional, handle when contact data is saved
31    onComplete = { contactData -> handleContactData(contactData) }
32  ),
33  // optional, enable Remember Me functionality
34  rememberMeConfiguration = RememberMeConfiguration(
35    data = RememberMeConfiguration.Data(
36      email = "jia.tsang@example.com",
37      phone = Phone(countryCode = "44", number = "7700900000")
38    ),
39    showPayButton = true,
40    acceptedCardSchemes = listOf(CardSchemeName.Visa, CardSchemeName.AmericanExpress),
41    acceptedCardTypes = listOf(CardTypeName.Debit, CardTypeName.Credit, CardTypeName.Prepaid)
42  )
43)
44
45
46try {
47  val flowComponent = checkoutComponents.create(ComponentName.Flow, options)
48
49  val cardComponent = checkoutComponents.create(PaymentMethodName.Card, options)
50} catch (checkoutError: CheckoutError) {
51  handleError(error = checkoutError)
52}

Initializes an address component instance.


1// Step 1: Create a configuration
2val configuration = CheckoutComponentConfiguration(
3    context = context,
4    publicKey = "PUBLIC KEY",
5    environment = environment,
6    locale = Locale.EN,
7)
8
9// Step 2: Initialize an instance of Checkout Components SDK
10val checkoutComponents = CheckoutComponentsFactory(config = configuration).create()
11
12// Step 3: Initialize an instance of prefilled address data (optional)
13val prefilledData = ContactData(
14    address = Address(
15        country = Country.UNITED_KINGDOM,
16        addressLine1 = "Checkout.com",
17    ),
18    phone = Phone(
19        countryCode = "+44",
20        number = "12345678",
21    ),
22    name = Name(
23        firstName = "John",
24        lastName = "Doe",
25    ),
26    email = "johnDoe@domain.com",
27)
28
29// Step 4: Create address with fields (optional)
30val fields = listOf(
31    AddressField.Country,
32    AddressField.AddressLine1(),
33    AddressField.AddressLine2(isOptional = true),
34    AddressField.City(isOptional = false),
35)
36
37// Step 5: Create an address configuration
38val configuration = AddressConfiguration(
39  data = data,
40  fields = fields,
41  onComplete = { contactData ->
42    handleContactData(contactData)
43  }
44)
45
46// Step 6: Create address component
47val addressComponent = checkoutComponent.create(
48  ComponentName.Address(configuration)
49)
50
51// Step 7: Render the address component
52addressComponent.Render()

CheckoutComponents

CheckoutComponentConfiguration

Initialization

Methods

create(paymentMethodName, checkoutOption)

create(Component.Address)