Search

Are you looking for test card numbers?

Would you like to contact support?

Online-payment icon

Android Drop-in

Accept popular payment methods with our Drop-in solution.

See sample code

  Explore Drop-in for Android on GitHub.

Drop-in is our all-in-one UI solution you can use on your checkout page to accept payments for popular payment methods. To see a complete list of all payment methods supported by our Drop-in solution, see Drop-in payment methods.

If you are new to integrating with Adyen, see our Online payments page for an overview of integration options and available features.

Drop-in is supported from v49 of the /paymentMethods, /payments, and /payments/details endpoints.

How Drop-in works

The following general flow applies for each payment method supported in Drop-in:

On this page we talk about both server-side and client-side integration steps:

  1. From your server, submit a request to get a list of payment methods available to the shopper.
  2. Create an instance of Drop-in.
  3. From your server, submit a payment request with the data returned by Drop-in.
  4. Some payment methods require additional actions before a payment can be completed. Submit the results of the additional payment details with the data returned by Drop-in.
  5. Present the payment result to the shopper.

When you have finished integrating with our Drop-in solution, proceed to test your integration.

Before you begin

Before you start integrating, make sure that you have performed the following steps:

  1. Sign up for an Adyen test account.
  2. Get your API Key. Save a copy as you need it for API calls you make to the Adyen payments platform.
  3. Install one of our Libraries to connect with the Adyen APIs.
  4. If you're building for multiple merchants, provide some basic information so that we can offer you better support.
  5. Install Drop-in for Android.

Install Drop-in for Android

Android Components are available through jcenter, you only need to add a build dependency on Gradle.

Import the Android Drop-in by adding it to your build.gradle file.

implementation "com.adyen.checkout:drop-in:<latest-version>"

Check the latest version on GitHub.

Step 1: Get available payment methods

  1. Make a POST /paymentMethods request, providing:

    • merchantAccount: Your merchant account name.
    • countryCode: The shopper's country.
    • amount: The currency and value of the payment.
    • channel: The platform of the shopper's device. Use Android.

    We use the countryCode, amount, and channel to tailor the list of payment methods to your shopper.

    curl https://checkout-test.adyen.com/v50/paymentMethods \
    -H "x-API-key: YOUR_X-API-KEY" \
    -H "content-type: application/json" \
    -d '{
      "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
      "countryCode": "NL",
      "amount": {
        "currency": "EUR",
        "value": 1000
      },
      "channel": "Android"
    }'
    # Set your X-API-KEY with the API key from the Customer Area.
    adyen = Adyen::Client.new
    adyen.api_key = "YOUR_X-API-KEY"
    
    response = adyen.checkout.payment_methods({
      :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
      :countryCode => 'NL',
      :amount => {
        :currency => 'EUR',
        :value => 1000
      },
      :channel => 'Android'
    })
    // Set your X-API-KEY with the API key from the Customer Area.
    Client client = new Client(xApiKey,Environment.TEST);
    
    Checkout checkout = new Checkout(client);
    PaymentMethodsRequest paymentMethodsRequest = new PaymentMethodsRequest();
    paymentMethodsRequest.setMerchantAccount("YOUR_MERCHANT_ACCOUNT");
    paymentMethodsRequest.setCountryCode("NL");
    Amount amount = new Amount();
    amount.setCurrency("EUR");
    amount.setValue(1000L);
    paymentMethodsRequest.setAmount(amount);
    paymentMethodsRequest.setChannel(PaymentMethodsRequest.ChannelEnum.Android);
    PaymentMethodsResponse response = checkout.paymentMethods(paymentMethodsRequest);
    // Set your X-API-KEY with the API key from the Customer Area.
    $client = new \Adyen\Client();
    $client->setXApiKey("YOUR_X-API-KEY");
    $service = new \Adyen\Service\Checkout($client);
    
    $params = array(
      "merchantAccount" => "YOUR_MERCHANT_ACCOUNT",
      "countryCode" => "NL",
      "amount" => array(
        "currency" => "EUR",
        "value" => 1000
      ),
      "channel" => "Android"
    );
    $result = $service->paymentMethods($params);
    #Set your X-API-KEY with the API key from the Customer Area.
    adyen = Adyen.Adyen()
    adyen.client.xapikey = 'YOUR_X-API-KEY'
    
    result = adyen.checkout.payment_methods({
      'merchantAccount': 'YOUR_MERCHANT_ACCOUNT',
      'countryCode': 'NL',
      'amount': {
        'value': 1000,
        'currency': 'EUR'
      },
      'channel': 'Android'
    })
    // Set your X-API-KEY with the API key from the Customer Area.
    var client = new Client ("YOUR-X-API-KEY", Environment.Test);
    var checkout = new Checkout(client);
    var amount = new Model.Checkout.Amount("EUR", 1000);
    var paymentMethodsRequest = new Model.Checkout.PaymentMethodsRequest(MerchantAccount: "YOUR_MERCHANT_ACCOUNT")
    {
       CountryCode = "NL",
       Amount = amount,
       Channel = "Android"
    };
    const config = new Config();
    // Set your X-API-KEY with the API key from the Customer Area.
    config.apiKey = '[API_KEY]';
    config.merchantAccount = '[MERCHANT_ACCOUNT]';
    const client = new Client({ config });
    client.setEnvironment("TEST");
    const checkout = new CheckoutAPI(client);
    const paymentsResponse = checkout.paymentMethods({
        amount: {
            currency: "EUR",
            value: 1000,
        },
        countryCode: "NL",
        channel: "Android",
        merchantAccount: config.merchantAccount
    }).then(res => res);

    A list of available paymentMethods is returned in the response, including any required fields. If you want to know more about the properties returned in the response, see the response parameters in our API Explorer.

    {
     "paymentMethods":[
      {
        "details":[...],
        "name":"Credit Card",
        "type":"scheme"
        ...
      },
      {
        "details":[...],
        "name":"SEPA Direct Debit",
        "type":"sepadirectdebit"
      },
      ...
      ]
    }
  2. Pass the response to your client app. You will use this in the next step to present which payment methods are available to the shopper.

Step 2: Add Drop-in to your payment form

  1. Deserialize the /paymentMethods response with the SERIALIZER object.

    val paymentMethodsApiResponse = PaymentMethodsApiResponse.SERIALIZER.deserialize(paymentMethodsResponse)
  2. Extend the DropInService class and use the makePaymentsCall and makeDetailsCall methods to pass data between your client app and your server.

    class YourDropInService : DropInService() {
       // Handling for submitting a payment request
       override fun makePaymentsCall(paymentComponentData: JSONObject): CallResult {
           ...
           // See step 3 - Your server should make a /payments call containing the `paymentComponentData`
           // Create the `CallResult` based on the /payments response
           return CallResult(CallResult.ResultType.ACTION, "action JSON object")
       }
       // Handling for submitting additional payment details
       override fun makeDetailsCall(actionComponentData: JSONObject): CallResult {
           ...
           // See step 4 - Your server should make a /payments/details call containing the `actionComponentData`
           // Create the `CallResult` based on the /payments/details response
           return CallResult(CallResult.ResultType.FINISHED, "Authorised")
       }
    }

    Both methods are expected to return the CallResult, which should contain the result of the API calls from your server. Depending on the results from your /payments or /payments/details requests, return any of the following ResultType values in the CallResult:

    • ACTION: If you received an action object from the /payments or /payments/details response, return ACTION and the action object.
    • FINISHED: If you did not receive an action object from the /payments or /payments/details response, return FINISHED and the resultCode from the response.
    • ERROR: Return this if an error happened during the connection.

    Drop-in uses the CallResult to determine if additional actions are required to complete the payment, such as redirecting the shopper to another site or to perform 3D Secure authentication.

    The API requests in the sample code are discussed in detail in step 3 for making a payment and step 4 for submitting additional payment details.

  3. Make sure to add the service to your manifest file.

    <service
       android:name=".YourDropInService"
       android:permission="android.permission.BIND_JOB_SERVICE"/>
  4. Check specific payment method pages to confirm if you need to configure additional required parameters. For example, to enable the Card form, Drop-in needs your public key to use for encryption. Include additional configuration in the DropInConfiguration:

    val cardConfiguration =
      CardConfiguration.Builder(context, "<publicKey>")
      .build()
    
    val dropInConfiguration = DropInConfiguration.Builder(this@MainActivity, YourDropInService::class.java)
       .setEnvironment(Environment.TEST)
       // When you're ready to accept live payments, change the value to one of our live environments.
       .addCardConfiguration(cardConfiguration)
       .build()
  5. Call the .startPayment() method to initialize Drop-in. Drop-in calls the resultIntent when the payment flow has been completed.

    DropIn.INSTANCE.startPayment(this@YourActivity, mPaymentMethodsApiResponse, dropInConfiguration, resultIntent)
  6. After the payment flow has been completed, get the message from the resultIntent in intent.getStringExtra(DropIn.RESULT_KEY).

    When the resultIntent is pointing to an Activity responsible for showing the payment results to the shopper, check for the resultCode inside DropIn.RESULT_KEY and present the result to the shopper.

Step 3: Make a payment

The makePaymentsCall method described in step 2 is where you should submit the shopper's payment details from the app to your server to make an API request.

  1. From your server, make a POST /payments request specifying:

    • amount
    • reference: Your unique reference for this payment.
    • paymentMethod: The paymentComponentData.paymentMethod from Drop-in.
    • returnUrl: In case of a redirection, this is the URL to where your shopper should be redirected back to after they complete the payment. Get this URL from Drop-in in the RedirectComponent.getReturnUrl(context).
    • merchantAccount: Your merchant account name.

      Additional parameters are required for some payment methods, native 3D Secure 2 authentication, and recurring payments. For information on the required fields, refer to the payment method integration guides.
      curl https://checkout-test.adyen.com/v51/payments \
      -H "x-API-key: YOUR_X-API-KEY" \
      -H "content-type: application/json" \
      -d '{
        "amount":{
          "currency":"EUR",
          "value":1000
        },
        "reference":"YOUR_ORDER_NUMBER",
        "paymentMethod": {hint:paymentComponentData.paymentMethod from app}paymentComponentData.paymentMethod{/hint},
        "returnUrl":"adyencheckout://your.package.name",
        "merchantAccount":"YOUR_MERCHANT_ACCOUNT"
      }'
      # Set your X-API-KEY with the API key from the Customer Area.
      adyen = Adyen::Client.new
      adyen.env = :test
      adyen.api_key = "YOUR_X-API-KEY"
       
      paymentMethod = DROPIN_PAYMENT_COMPONENT_DATA
      # Data object passed from paymentComponentData from the client app, parsed from JSON to a Hash.
      
      response = adyen.checkout.payments({
        :amount => {
          :currency => "EUR",
          :value => 1000
        },
        :reference => "YOUR_ORDER_NUMBER",
        :paymentMethod => paymentMethod,
        :returnUrl => "https://your-company.com/checkout?shopperOrder=12xy..",
        :merchantAccount => "YOUR_MERCHANT_ACCOUNT"
      })
      
      # Check if further action is needed.
      if response.body.has_key(:action)
         # Pass the action object to your front end
         # response.body[:action]
      else
         # No further action needed, pass the resultCode object to your front end
         # response.body[:resultCode]
      // Set your X-API-KEY with the API key from the Customer Area.
      Client client = new Client(xApiKey,Environment.TEST);
       
      Checkout checkout = new Checkout(client);
      PaymentsRequest paymentsRequest = new PaymentsRequest();
      paymentsRequest.setMerchantAccount("YOUR_MERCHANT_ACCOUNT");
      Amount amount = new Amount();
      amount.setCurrency("EUR");
      amount.setValue(15000L);
      paymentsRequest.setAmount(amount);
      String encryptedCardNumber = "adyenjs_0_1_18$...encryptedCardNumber";
      String encryptedExpiryMonth = "adyenjs_0_1_18$...encryptedExpiryMonth";
      String encryptedExpiryYear = "adyenjs_0_1_18$...encryptedExpiryYear";
      String encryptedSecurityCode = "adyenjs_0_1_18$...encryptedSecurityCode";
      paymentsRequest.setReference("Your order number");
      paymentsRequest.addEncryptedCardData(encryptedCardNumber,encryptedExpiryMonth, encryptedExpiryYear, encryptedSecurityCode, "John Smith");
      paymentsRequest.setReturnUrl("adyencheckout://your.package.name");
      PaymentsResponse paymentsResponse = checkout.payments(paymentsRequest);
      // Set your X-API-KEY with the API key from the Customer Area.
      $client = new \Adyen\Client();
      $client->setXApiKey("YOUR_X-API-KEY");
      $service = new \Adyen\Service\Checkout($client);
      
      $paymentMethod = DROPIN_PAYMENT_COMPONENT_DATA;
      // Data object passed from paymentComponentData from the client app, parsed from JSON to an array
      
      $params = array(
        "amount" => array(
          "currency" => "EUR",
          "value" => 1000
        ),
        "reference" => "YOUR_ORDER_NUMBER",
        "paymentMethod" => $paymentMethod,
        "returnUrl" => "https://your-company.com/checkout?shopperOrder=12xy..",
        "merchantAccount" => "YOUR_MERCHANT_ACCOUNT"
      );
      
      $result = $service->payments($params);
      
      // Check if further action is needed
      if (array_key_exists("action", $result){
         // Pass the action object to your front end
         // $result["action"]
      }
      else {
         // No further action needed, pass the resultCode to your front end
         // $result['resultCode']
      }
      # Set your X-API-KEY with the API key from the Customer Area.
      adyen = Adyen.Adyen()
      adyen.client.xapikey = 'YOUR_X-API-KEY'
      
      paymentMethod = DROPIN_PAYMENT_COMPONENT_DATA
      # Data object passed from paymentComponentData from the client app, parsed from JSON to a dictionary
      
      result = adyen.checkout.payments({
         'amount': {
            'value': 1000,
            'currency': 'EUR'
         },
         'reference': 'YOUR_ORDER_NUMBER',
         'paymentMethod': paymentMethod,
         'returnUrl': 'https://your-company.com/checkout?shopperOrder=12xy..',
         'merchantAccount': 'YOUR_MERCHANT_ACCOUNT'
      })
      
      # Check if further action is needed
      if 'action' in result.message:
         # Pass the action object to your front end
         # result.message['action']
      else:
         # No further action needed, pass the resultCode to your front end
         # result.message['resultCode']
      // Set your X-API-KEY with the API key from the Customer Area.
      var client = new Client ("YOUR_X-API-KEY", Environment.Test);
      var checkout = new Checkout(client);
      
      var amount = new Model.Checkout.Amount("EUR", 1000);
      var details = new Model.Checkout.DefaultPaymentMethodDetails{
        Type = "scheme",
        EncryptedCardNumber = "adyenjs_0_1_18$MT6ppy0FAMVMLH...",
        EncryptedExpiryMonth = "adyenjs_0_1_18$MT6ppy0FAMVMLH...",
        EncryptedExpiryYear = "adyenjs_0_1_18$MT6ppy0FAMVMLH...",
        EncryptedSecurityCode = "adyenjs_0_1_18$MT6ppy0FAMVMLH..."
      };
      var paymentsRequest = new Model.Checkout.PaymentRequest
      {
        Reference = "YOUR_ORDER_NUMBER",
        Amount = amount,
        ReturnUrl = @"adyencheckout://your.package.name",
        MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
        PaymentMethod = details
      };
      
      var paymentResponse = checkout.Payments(paymentsRequest);
      // Set your X-API-KEY with the API key from the Customer Area.
      const {Client, Config, CheckoutAPI} = require('@adyen/api-library');
      const config = new Config();
      // Set your X-API-KEY with the API key from the Customer Area.
      config.apiKey = '[API_KEY]';
      config.merchantAccount = '[YOUR_MERCHANT_ACCOUNT]';
      const client = new Client({ config });
      client.setEnvironment("TEST");
      const checkout = new CheckoutAPI(client);
      checkout.payments({
          amount: { currency: "EUR", value: 1000 },
          paymentMethod: {DROPIN_PAYMENT_COMPONENT_DATA}, // Data object passed from paymentComponentData from the client app
          reference: "YOUR_ORDER_NUMBER",
          merchantAccount: config.merchantAccount,
          returnUrl: "https://your-company.com/checkout?shopperOrder=12xy.."
      }).then(res => res);

    Response

    Depending on the payment result, you receive a response containing:

    • resultCode: Provides information about the result of the request.
    • pspReference: Our unique identifier for the transaction.
    • details: This array shows the fields that you need to pass in your next request.
    • action: If you receive this object, this indicates that you need to perform an additional action on your front end to complete the payment. The type field specifies the required action.

  2. The next steps depend on if you received an action object in the response.

    • If you received an action object, return CallResult with ResultType ACTION and pass the action object.
    • If you did not get an action object, return CallResult with ResultType FINISHED and the resultCode from the response. You can then proceed to step 5 to present the payment result to your shopper.

      {
      "resultCode":"IdentifyShopper",
      "action":{
       "paymentMethodType":"scheme",
       "token":"eyJ0aHJlZURTTWV0aG9kTm90aWZpY...",
       "type":"threeDS2Fingerprint"
      },
      "authentication":{
       "threeds2.fingerprintToken":"eyJ0aHJlZURTTWV0aG9kTm90aWZpY..."
      },
      "details":[
       {
         "key":"threeds2.fingerprint",
         "type":"text"
       }
      ],
      "paymentData":"Ab02b4c0!BQABAgCuZFJrQOjSsl\/zt+..."
      }

Step 4: Submit additional payment details

If the CallResult.ResultType is ACTION, Drop-in performs the makeDetailsCall method described in step 2. In this method, you should submit the results from the app to your server to make an API request.

  1. From your server, make a POST /payments/details request specifying:

    • details: The actionComponentData from Drop-in.

      curl https://checkout-test.adyen.com/v51/payments/details \
      -H "x-API-key: YOUR_X-API-KEY" \
      -H "content-type: application/json" \
      -d '{hint:actionComponentData from app}actionComponentData{/hint}'
      }'
      # Set your X-API-KEY with the API key from the Customer Area.
      adyen = Adyen::Client.new
      adyen.env = :test
      adyen.api_key = "YOUR_X-API-KEY"
      
      request = DROPIN_ACTION_COMPONENT_DATA
      #  Data object passed from actionComponentData from the client app, parsed from JSON to a Hash.
      
      response = adyen.checkout.payments.details(request)
      
      # Check if further action is needed.
      if response.body.has_key(:action)
         # Pass the action object to your frontend
         puts response.body[:action]
      else
         # No further action needed, pass the resultCode to your frontend
         puts response.body[:resultCode]
      end
      // Set your X-API-KEY with the API key from the Customer Area.
      String apiKey = "YOUR_X-API-KEY";
      
      String paymentData = "Ab02b4c0!BQABAgAKspbjN8+5...";
      String fingerPrint = "eyJ0aHJlZURTQ29tcEluZCI6IlkifQ==";
      
      Client client = new Client(apiKey,Environment.TEST);
      Checkout checkout = new Checkout(client);
      PaymentDetailsRequest paymentDetailsRequest = new PaymentDetailsRequest();
      paymentDetailsRequest.setFingerPrint();
      PaymentsResponse paymentsResponse = checkout.paymentDetails(PaymentDetailsRequest);
      // Set your X-API-KEY with the API key from the Customer Area.
      $client = new \Adyen\Client();
      $client->setXApiKey("YOUR_X-API-KEY");
      $service = new \Adyen\Service\Checkout($client);
      
      $params = DROPIN_ACTION_COMPONENT_DATA;
      //  Data object passed from actionComponentData from the client app, parsed from JSON to an array
      
      $result = $service->paymentDetails($params);
      
      // Check if further action is needed
      if (array_key_exists("action", $result){
         // Pass the action object to your frontend.
         // $result["action"]
      }
      else {
         // No further action needed, pass the resultCode to your front end
         // $result['resultCode']
      }
      #Set your X-API-KEY with the API key from the Customer Area.
      adyen = Adyen.Adyen()
      adyen.client.xapikey = 'YOUR_X-API-KEY'
      
      request = DROPIN_ACTION_COMPONENT_DATA
      #  Data object passed from actionComponentData from the client app, parsed from JSON to a dictionary
      
      result = adyen.checkout.payments_details(request)
      
      # Check if further action is needed.
      if 'action' in result.message:
         # Pass the action object to your front end
         # result.message['action']
      else:
         # No further action needed, pass the resultCode to your front end
         # result.message['resultCode']
      // Set your X-API-KEY with the API key from the Customer Area.
      var client = new Client ("YOUR_X-API-KEY", Environment.Test);
      var checkout = new Checkout(client);
      string paymentData = "Ab02b4c0!BQABAgCuZFJrQOjSsl\/zt+...";
      string fingerPrint = "eyJ0aHJlZURTQ29tcEluZCI6IlkifQ==";
      
      var details = new Dictionary<string, string>
      {
        { "threeds2.fingerprint": fingerPrint }
      };
      var paymentsDetailsRequest = new Model.Checkout.PaymentsDetailsRequest(Details: details);
      var paymentResponse = checkout.PaymentDetails(paymentsDetailsRequest);
      // Set your X-API-KEY with the API key from the Customer Area.
      const {Client, Config, CheckoutAPI} = require('@adyen/api-library');
      const config = new Config();
      // Set your X-API-KEY with the API key from the Customer Area.
      config.apiKey = '[API_KEY]';
      config.merchantAccount = '[YOUR_MERCHANT_ACCOUNT]';
      const client = new Client({ config });
      client.setEnvironment("TEST");
      const checkout = new CheckoutAPI(client);
      checkout.paymentsDetails({
          details: {DROPIN_ACTION_COMPONENT_DATA}  // Data object passed from the client app.
      }).then(res => res);

      Depending on the payment result, you receive a response containing:

      • resultCode: Provides information about the result of the request.
      • pspReference: Our unique identifier for the transaction.
      • action: If you receive this object, this indicates that Drop-in will perform additional actions on the app again.

  2. The next steps depend on if you received an action object in the response.

    • If you received an action object, return CallResult with ResultType ACTION and pass the action object.
    • If you did not get an action object, return CallResult with ResultType FINISHED, and the resultCode from the response. You can then proceed to step 5 to present the payment result to your shopper.

      {
      "pspReference": "88154795347618C",
      "resultCode": "Authorised"
      }
      {
      "pspReference": "89783918347627F",
      "refusalReason": "Not enough balance",
      "resultCode": "Refused"
      }

Step 5: Present the payment result

After the shopper completes the payment and no more further actions are required on the client app, use the resultCode inside DropIn.RESULT_KEY to present a corresponding message to the shopper.

For example:

resultCode Description Action to take
Authorised The payment was successful. Inform the shopper that the payment was successful.
Error Inform the shopper that there was an error processing their payment. You'll receive a refusalReason in the same response, indicating the cause of the error.
Pending The shopper has completed the payment but the final result is not yet known. Inform the shopper that you've received their order, and are waiting for the payment to be completed.
You will receive the final result of the payment in an AUTHORISATION notification.
Refused The payment was refused. Inform the shopper that the payment was refused. Ask the shopper to try the payment again using a different payment method or card.
Received For some payment methods, it can take some time before the final status of the payment is known. Inform the shopper that you've received their order, and are waiting for the payment to clear.
You will receive the final result of the payment in an AUTHORISATION notification.

For other possible resultCode values and recommended messages that you can present to your shopper, see Result codes.

Test and go live

Before going live, use our list of test cards and other payment methods to test your integration. We recommend testing each payment method that you intend to offer to your shoppers.

You can check the status of a test payment in your Customer Area, under Transactions > Payments.

When you are ready to go live, you need to:

  1. Complete additional steps before you can accept live payments from shoppers. Refer to Getting started with Adyen for more information. 
  2. Switch from test to our live endpoints.
  3. Load Drop-in from one of our live environments closest to where your shoppers are. Set the environment to:

    • Europe: EUROPE
    • Australia: AUSTRALIA
    • US: UNITED_STATES

Supported payment methods in Drop-in

The following payment methods are supported in Drop-in. If you have questions about payment methods not on the list below or those that do not have linked pages, contact our Support Team.

Payment method Web iOS Android
AfterPay -white_check_mark-
Apple Pay -white_check_mark- -white_check_mark-
Bancontact Mobile (Payconiq) -white_check_mark- -white_check_mark-
Boleto Bancário -white_check_mark-
Cards, including 3D Secure 1 and 3D Secure 2
authentication
-white_check_mark- -white_check_mark- -white_check_mark-
Stored card details -white_check_mark- -white_check_mark- -white_check_mark-
Dragonpay -white_check_mark-
Dotpay -white_check_mark- -white_check_mark- -white_check_mark-
Entercash -white_check_mark- -white_check_mark- -white_check_mark-
EPS -white_check_mark- -white_check_mark- -white_check_mark-
giropay -white_check_mark-
Google Pay -white_check_mark- -white_check_mark-
iDEAL -white_check_mark- -white_check_mark- -white_check_mark-
Japanese convenience stores (Konbini)/
7-Eleven Japan
-white_check_mark-
Klarna -white_check_mark- -white_check_mark- -white_check_mark-
MOLPay -white_check_mark- -white_check_mark- -white_check_mark-
Multibanco -white_check_mark-
Open banking -white_check_mark- -white_check_mark- -white_check_mark-
Online banking India -white_check_mark-
Online banking Japan -white_check_mark-
QiwiWallet -white_check_mark-
Redirect payment methods
(For example, UnionPay)
-white_check_mark- -white_check_mark- -white_check_mark-
SEPA Direct Debit -white_check_mark- -white_check_mark- -white_check_mark-
Vipps -white_check_mark-
Wallets India -white_check_mark-
WeChat Pay -white_check_mark- -white_check_mark-

We're actively adding payment methods to Drop-in. To check the latest on Drop-in and Components, see our release notes.

See also

Next steps