---
title: "Partial authorizations"
description: "Allow partial authorizations to reduce declined transactions due to insufficient funds."
url: "https://docs.adyen.com/online-payments/partial-authorizations"
source_url: "https://docs.adyen.com/online-payments/partial-authorizations.md"
canonical: "https://docs.adyen.com/online-payments/partial-authorizations"
last_modified: "2023-07-31T13:36:00+02:00"
language: "en"
---

# Partial authorizations

Allow partial authorizations to reduce declined transactions due to insufficient funds.

[View source](/online-payments/partial-authorizations.md)

To reduce the number of declined transactions due to insufficient funds, you can integrate partial authorizations (or "partial approvals"). This feature allows an issuing bank to return an authorization for the available amount when the requested amount is higher than the shopper's balance, instead of declining the transaction. You can decide how to follow up, such as prompting the shopper for a second payment method to collect the outstanding balance or canceling the transaction to remove the hold on funds.

## Requirements

Before you begin, take into account the following requirements, limitations, and preparations

| Requirement          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Integration type** | An online payments integration that uses the [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) endpoint, with Checkout API v69 or later:- An [API only](/online-payments/build-your-integration/advanced-flow?platform=Web\&integration=API%20only\&version=latest) integration.
- A [Web Drop-in/Components integration that uses the Advanced flow](/online-payments/build-your-integration/advanced-flow?platform=Web\&integration=Drop-in\&version=latest). |
| **Limitations**      | * Partial authorization is supported for **Visa** and **Mastercard** payments, but there is no guarantee that all issuers support partial authorizations.
* You can not integrate with partial authorizations if you are using the [Sessions flow](/online-payments/build-your-integration#sessions-flow-a-single-api-request).                                                                                                                                                              |
| **Setup steps**      | Before you begin, ask our [Support Team](https://ca-test.adyen.com/ca/ca/contactUs/support.shtml?form=other) to enable partial authorizations.                                                                                                                                                                                                                                                                                                                                               |

## How it works

Partial authorization allows you to authorize a portion of the payment when the shopper has insufficient funds, and then collect the remaining balance.

1. You [make a payment request with `allowPartialAuth`](#make-the-initial-payment) to indicate you accept partial amounts.
2. If the shopper does not have sufficient funds, the issuer only authorizes the amount available on the card.
3. You receive a response with the authorized amount.
4. You [follow up the partial authorization](#follow-up) by prompting the shopper for the remaining balance, canceling the transaction, or taking no further action.
5. If you choose to collect the remaining balance, you connect multiple partial authorizations to the same transaction using the `reference` field.

## Make the initial payment

1. Send a [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) request specifying:

   * `additionalData.allowPartialAuth`: set to **true**. When the requested amount is higher than the amount available in the account, this parameter asks the issuing bank to return an authorization for the available amount, instead of declining the transaction.
   * `reference`: your order reference. If you need to follow up a partial authorization with another payment method for the outstanding balance, the `reference` values must be the same to let you connect the payments for reconciliation.

   **Make a payment request with allowPartialAuth**

   #### curl

   ```bash
   curl https://checkout-test.adyen.com/v72/payments \
   -H 'x-api-key: ADYEN_API_KEY' \
   -H 'content-type: application/json' \
   -d '{
     "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
     "amount": {
        "currency": "EUR",
        "value": 1139
     },
     "paymentMethod":{
        "type": "scheme",
        "number": "4166676667666746",
        "expiryMonth": "03",
        "expiryYear": "2030",
        "cvc": "737"
     },
     "additionalData": {
        "allowPartialAuth": true
     },
     "reference": "YOUR_ORDER_NUMBER",
     "returnUrl": "https://your-company.example.com/checkout?shopperOrder=12xy.."
   }'
   ```

   #### Java

   ```java
   // Adyen Java API Library v40.1.0
   import com.adyen.Client;
   import com.adyen.enums.Environment;
   import com.adyen.model.checkout.*;
   import java.time.OffsetDateTime;
   import java.util.*;
   import com.adyen.model.RequestOptions;
   import com.adyen.service.checkout.*;

   // For the LIVE environment, also include your liveEndpointUrlPrefix.
   Client client = new Client("ADYEN_API_KEY", Environment.TEST);

   // Create the request object(s)
   Amount amount = new Amount()
     .currency("EUR")
     .value(1139L);

   CardDetails cardDetails = new CardDetails()
     .number("4166676667666746")
     .cvc("737")
     .expiryMonth("03")
     .expiryYear("2030")
     .type(CardDetails.TypeEnum.SCHEME);

   PaymentRequest paymentRequest = new PaymentRequest()
     .reference("YOUR_ORDER_NUMBER")
     .amount(amount)
     .merchantAccount("YOUR_MERCHANT_ACCOUNT")
     .paymentMethod(new CheckoutPaymentMethod(cardDetails))
     .additionalData(new HashMap<String, String>(Map.of(
       "allowPartialAuth", "true"
     )))
     .returnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..");

   // Send the request
   PaymentsApi service = new PaymentsApi(client);
   PaymentResponse response = service.payments(paymentRequest, new RequestOptions().idempotencyKey("UUID"));
   ```

   #### PHP

   ```php
   <?php
   // Adyen PHP API Library v28.3.0
   use Adyen\Client;
   use Adyen\Environment;
   use Adyen\Model\Checkout\Amount;
   use Adyen\Model\Checkout\CheckoutPaymentMethod;
   use Adyen\Model\Checkout\PaymentRequest;
   use Adyen\Service\Checkout\PaymentsApi;

   $client = new Client();
   $client->setXApiKey("ADYEN_API_KEY");
   // For the LIVE environment, also include your liveEndpointUrlPrefix.
   $client->setEnvironment(Environment::TEST);


   // Create the request object(s)
   $amount = new Amount();
   $amount
     ->setCurrency("EUR")
     ->setValue(1139);

   $checkoutPaymentMethod = new CheckoutPaymentMethod();
   $checkoutPaymentMethod
     ->setNumber("4166676667666746")
     ->setCvc("737")
     ->setExpiryMonth("03")
     ->setExpiryYear("2030")
     ->setType("scheme");

   $paymentRequest = new PaymentRequest();
   $paymentRequest
     ->setReference("YOUR_ORDER_NUMBER")
     ->setAmount($amount)
     ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
     ->setPaymentMethod($checkoutPaymentMethod)
     ->setAdditionalData(
       array(
         "allowPartialAuth" => "true"
       )
     )
     ->setReturnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..");

   $requestOptions['idempotencyKey'] = 'UUID';

   // Send the request
   $service = new PaymentsApi($client);
   $response = $service->payments($paymentRequest, $requestOptions);
   ```

   #### C\#

   ```cs
   // Adyen .net API Library v33.0.0
   using Adyen;
   using Environment = Adyen.Model.Environment;
   using Adyen.Model;
   using Adyen.Model.Checkout;
   using Adyen.Service.Checkout;

   // For the LIVE environment, also include your liveEndpointUrlPrefix.
   var config = new Config()
   {
       XApiKey = "ADYEN_API_KEY",
       Environment = Environment.Test
   };
   var client = new Client(config);

   // Create the request object(s)
   Amount amount = new Amount
   {
     Currency = "EUR",
     Value = 1139
   };

   CardDetails cardDetails = new CardDetails
   {
     Number = "4166676667666746",
     Cvc = "737",
     ExpiryMonth = "03",
     ExpiryYear = "2030",
     Type = CardDetails.TypeEnum.Scheme
   };

   PaymentRequest paymentRequest = new PaymentRequest
   {
     Reference = "YOUR_ORDER_NUMBER",
     Amount = amount,
     MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
     PaymentMethod = new CheckoutPaymentMethod(cardDetails),
     AdditionalData = new Dictionary<string, string>
     {

       { "allowPartialAuth", "true" }
     },
     ReturnUrl = "https://your-company.example.com/checkout?shopperOrder=12xy.."
   };

   // Send the request
   var service = new PaymentsService(client);
   var response = service.Payments(paymentRequest, requestOptions: new RequestOptions { IdempotencyKey = "UUID"});
   ```

   #### NodeJS (JavaScript)

   ```js
   // Adyen Node API Library v30.0.1
   const { Client, CheckoutAPI } = require('@adyen/api-library');

   // For the LIVE environment, also include your liveEndpointUrlPrefix.
   const config = new Config({
     apiKey: "ADYEN_API_KEY",
     environment: EnvironmentEnum.TEST
   });

   const client = new Client(config);

   // Create the request object(s)
   const paymentRequest = {
     merchantAccount: "YOUR_MERCHANT_ACCOUNT",
     amount: {
       currency: "EUR",
       value: 1139
     },
     paymentMethod: {
       type: "scheme",
       number: "4166676667666746",
       expiryMonth: "03",
       expiryYear: "2030",
       cvc: "737"
     },
     additionalData: {
       allowPartialAuth: true
     },
     reference: "YOUR_ORDER_NUMBER",
     returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy.."
   }

   // Send the request
   const checkoutAPI = new CheckoutAPI(client);
   const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
   ```

   #### Go

   ```go
   // Adyen Go API Library v21.1.0
   import (
     "context"
     "github.com/adyen/adyen-go-api-library/v21/src/common"
     "github.com/adyen/adyen-go-api-library/v21/src/adyen"
     "github.com/adyen/adyen-go-api-library/v21/src/checkout"
   )
   // For the LIVE environment, also include your liveEndpointUrlPrefix.
   client := adyen.NewClient(&common.Config{
     ApiKey:      "ADYEN_API_KEY",
     Environment: common.TestEnv,
   })

   // Create the request object(s)
   amount := checkout.Amount{
     Currency: "EUR",
     Value: 1139,
   }

   cardDetails := checkout.CardDetails{
     Number: common.PtrString("4166676667666746"),
     Cvc: common.PtrString("737"),
     ExpiryMonth: common.PtrString("03"),
     ExpiryYear: common.PtrString("2030"),
     Type: common.PtrString("scheme"),
   }

   paymentRequest := checkout.PaymentRequest{
     Reference: "YOUR_ORDER_NUMBER",
     Amount: amount,
     MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
     PaymentMethod: checkout.CardDetailsAsCheckoutPaymentMethod(&cardDetails),
     AdditionalData: &map[string]string{
       "allowPartialAuth": "true",
     },
     ReturnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
   }

   // Send the request
   service := client.Checkout()
   req := service.PaymentsApi.PaymentsInput().IdempotencyKey("UUID").PaymentRequest(paymentRequest)
   res, httpRes, err := service.PaymentsApi.Payments(context.Background(), req)
   ```

   #### Python

   ```py
   # Adyen Python API Library v14.0.0
   import Adyen

   adyen = Adyen.Adyen()
   adyen.client.xapikey = "ADYEN_API_KEY"
   # For the LIVE environment, also include your liveEndpointUrlPrefix.
   adyen.client.platform = "test" # The environment to use library in.

   # Create the request object(s)
   json_request = {
     "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
     "amount": {
       "currency": "EUR",
       "value": 1139
     },
     "paymentMethod": {
       "type": "scheme",
       "number": "4166676667666746",
       "expiryMonth": "03",
       "expiryYear": "2030",
       "cvc": "737"
     },
     "additionalData": {
       "allowPartialAuth": True
     },
     "reference": "YOUR_ORDER_NUMBER",
     "returnUrl": "https://your-company.example.com/checkout?shopperOrder=12xy.."
   }

   # Send the request
   result = adyen.checkout.payments_api.payments(request=json_request, idempotency_key="UUID")
   ```

   #### Ruby

   ```rb
   # Adyen Ruby API Library v11.1.0
   require "adyen-ruby-api-library"

   adyen = Adyen::Client.new
   adyen.api_key = 'ADYEN_API_KEY'
   # For the LIVE environment, also include your liveEndpointUrlPrefix.
   adyen.env = :test # Set to "live" for live environment

   # Create the request object(s)
   request_body = {
     :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
     :amount => {
       :currency => 'EUR',
       :value => 1139
     },
     :paymentMethod => {
       :type => 'scheme',
       :number => '4166676667666746',
       :expiryMonth => '03',
       :expiryYear => '2030',
       :cvc => '737'
     },
     :additionalData => {
       :allowPartialAuth => true
     },
     :reference => 'YOUR_ORDER_NUMBER',
     :returnUrl => 'https://your-company.example.com/checkout?shopperOrder=12xy..'
   }

   # Send the request
   result = adyen.checkout.payments_api.payments(request_body, headers: { 'Idempotency-Key' => 'UUID' })
   ```

   #### NodeJS (TypeScript)

   ```ts
   // Adyen Node API Library v30.0.1
   import { Client, CheckoutAPI, Types } from "@adyen/api-library";

   // For the LIVE environment, also include your liveEndpointUrlPrefix.
   const config = new Config({
     apiKey: "ADYEN_API_KEY",
     environment: EnvironmentEnum.TEST
   });

   const client = new Client(config);

   // Create the request object(s)
   const amount: Types.checkout.Amount = {
     currency: "EUR",
     value: 1139
   };

   const cardDetails: Types.checkout.CardDetails = {
     number: "4166676667666746",
     cvc: "737",
     expiryMonth: "03",
     expiryYear: "2030",
     type: Types.checkout.CardDetails.TypeEnum.Scheme
   };

   const paymentRequest: Types.checkout.PaymentRequest = {
     reference: "YOUR_ORDER_NUMBER",
     amount: amount,
     merchantAccount: "YOUR_MERCHANT_ACCOUNT",
     paymentMethod: cardDetails,
     additionalData: {
       "allowPartialAuth": "true"
     },
     returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy.."
   };

   // Send the request
   const checkoutAPI = new CheckoutAPI(client);
   const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
   ```

2. In the response, check the following fields:

   * `resultCode`: the value **PartiallyAuthorised** indicates that there were insufficient funds to authorize the full amount.
   * `additionalData.authorisedAmountValue`: the authorized amount. Use this to calculate the outstanding balance.

   **Partial auth response**

   ```json
   {
      ...
      "resultCode": "PartiallyAuthorised",
      "additionalData": {
         "authorisedAmountValue": "1039",
         "authorisedAmountCurrency": "EUR"
   }
   ```

3. If only a partial amount was authorized, see what you can do to [follow up a partial authorization](#follow-up).

## Follow up a partial authorization

If the initial payment didn't cover the full amount, you can start a new transaction to authorize the outstanding amount. You have the following options:

* **Prompt the shopper to pay for the outstanding amount with another payment method**:

  1. Make a [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) request, and include the same fields you included in the [initial payment](#make-the-initial-payment).
  2. Calculate the outstanding amount to send it in [amount](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments#request-amount).
  3. In the response, check if the full amount was authorized.

  For example, to follow up the transaction in the example above, you would make the following request

  **Partial auth response**

  #### curl

  ```bash
  curl https://checkout-test.adyen.com/v72/payments \
  -H 'x-api-key: ADYEN_API_KEY' \
  -H 'content-type: application/json' \
  -d '{
    "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
    "amount": {
       "currency": "EUR",
       "value": 100
    },
    "paymentMethod":{
       "type": "scheme",
       "number": "2222 4000 1000 0008",
       "expiryMonth": "03",
       "expiryYear": "2030",
       "cvc": "737"
    },
    "additionalData": {
       "allowPartialAuth": true
    },
    "reference": "YOUR_ORDER_NUMBER",
    "returnUrl": "https://your-company.example.com/checkout?shopperOrder=12xy.."
  }'
  ```

  #### Java

  ```java
  // Adyen Java API Library v40.1.0
  import com.adyen.Client;
  import com.adyen.enums.Environment;
  import com.adyen.model.checkout.*;
  import java.time.OffsetDateTime;
  import java.util.*;
  import com.adyen.model.RequestOptions;
  import com.adyen.service.checkout.*;

  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  Client client = new Client("ADYEN_API_KEY", Environment.TEST);

  // Create the request object(s)
  Amount amount = new Amount()
    .currency("EUR")
    .value(100L);

  CardDetails cardDetails = new CardDetails()
    .number("2222 4000 1000 0008")
    .cvc("737")
    .expiryMonth("03")
    .expiryYear("2030")
    .type(CardDetails.TypeEnum.SCHEME);

  PaymentRequest paymentRequest = new PaymentRequest()
    .reference("YOUR_ORDER_NUMBER")
    .amount(amount)
    .merchantAccount("YOUR_MERCHANT_ACCOUNT")
    .paymentMethod(new CheckoutPaymentMethod(cardDetails))
    .additionalData(new HashMap<String, String>(Map.of(
      "allowPartialAuth", "true"
    )))
    .returnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..");

  // Send the request
  PaymentsApi service = new PaymentsApi(client);
  PaymentResponse response = service.payments(paymentRequest, new RequestOptions().idempotencyKey("UUID"));
  ```

  #### PHP

  ```php
  <?php
  // Adyen PHP API Library v28.3.0
  use Adyen\Client;
  use Adyen\Environment;
  use Adyen\Model\Checkout\Amount;
  use Adyen\Model\Checkout\CheckoutPaymentMethod;
  use Adyen\Model\Checkout\PaymentRequest;
  use Adyen\Service\Checkout\PaymentsApi;

  $client = new Client();
  $client->setXApiKey("ADYEN_API_KEY");
  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  $client->setEnvironment(Environment::TEST);


  // Create the request object(s)
  $amount = new Amount();
  $amount
    ->setCurrency("EUR")
    ->setValue(100);

  $checkoutPaymentMethod = new CheckoutPaymentMethod();
  $checkoutPaymentMethod
    ->setNumber("2222 4000 1000 0008")
    ->setCvc("737")
    ->setExpiryMonth("03")
    ->setExpiryYear("2030")
    ->setType("scheme");

  $paymentRequest = new PaymentRequest();
  $paymentRequest
    ->setReference("YOUR_ORDER_NUMBER")
    ->setAmount($amount)
    ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
    ->setPaymentMethod($checkoutPaymentMethod)
    ->setAdditionalData(
      array(
        "allowPartialAuth" => "true"
      )
    )
    ->setReturnUrl("https://your-company.example.com/checkout?shopperOrder=12xy..");

  $requestOptions['idempotencyKey'] = 'UUID';

  // Send the request
  $service = new PaymentsApi($client);
  $response = $service->payments($paymentRequest, $requestOptions);
  ```

  #### C\#

  ```cs
  // Adyen .net API Library v33.0.0
  using Adyen;
  using Environment = Adyen.Model.Environment;
  using Adyen.Model;
  using Adyen.Model.Checkout;
  using Adyen.Service.Checkout;

  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  var config = new Config()
  {
      XApiKey = "ADYEN_API_KEY",
      Environment = Environment.Test
  };
  var client = new Client(config);

  // Create the request object(s)
  Amount amount = new Amount
  {
    Currency = "EUR",
    Value = 100
  };

  CardDetails cardDetails = new CardDetails
  {
    Number = "2222 4000 1000 0008",
    Cvc = "737",
    ExpiryMonth = "03",
    ExpiryYear = "2030",
    Type = CardDetails.TypeEnum.Scheme
  };

  PaymentRequest paymentRequest = new PaymentRequest
  {
    Reference = "YOUR_ORDER_NUMBER",
    Amount = amount,
    MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
    PaymentMethod = new CheckoutPaymentMethod(cardDetails),
    AdditionalData = new Dictionary<string, string>
    {

      { "allowPartialAuth", "true" }
    },
    ReturnUrl = "https://your-company.example.com/checkout?shopperOrder=12xy.."
  };

  // Send the request
  var service = new PaymentsService(client);
  var response = service.Payments(paymentRequest, requestOptions: new RequestOptions { IdempotencyKey = "UUID"});
  ```

  #### NodeJS (JavaScript)

  ```js
  // Adyen Node API Library v30.0.1
  const { Client, CheckoutAPI } = require('@adyen/api-library');

  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  const config = new Config({
    apiKey: "ADYEN_API_KEY",
    environment: EnvironmentEnum.TEST
  });

  const client = new Client(config);

  // Create the request object(s)
  const paymentRequest = {
    merchantAccount: "YOUR_MERCHANT_ACCOUNT",
    amount: {
      currency: "EUR",
      value: 100
    },
    paymentMethod: {
      type: "scheme",
      number: "2222 4000 1000 0008",
      expiryMonth: "03",
      expiryYear: "2030",
      cvc: "737"
    },
    additionalData: {
      allowPartialAuth: true
    },
    reference: "YOUR_ORDER_NUMBER",
    returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy.."
  }

  // Send the request
  const checkoutAPI = new CheckoutAPI(client);
  const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
  ```

  #### Go

  ```go
  // Adyen Go API Library v21.1.0
  import (
    "context"
    "github.com/adyen/adyen-go-api-library/v21/src/common"
    "github.com/adyen/adyen-go-api-library/v21/src/adyen"
    "github.com/adyen/adyen-go-api-library/v21/src/checkout"
  )
  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  client := adyen.NewClient(&common.Config{
    ApiKey:      "ADYEN_API_KEY",
    Environment: common.TestEnv,
  })

  // Create the request object(s)
  amount := checkout.Amount{
    Currency: "EUR",
    Value: 100,
  }

  cardDetails := checkout.CardDetails{
    Number: common.PtrString("2222 4000 1000 0008"),
    Cvc: common.PtrString("737"),
    ExpiryMonth: common.PtrString("03"),
    ExpiryYear: common.PtrString("2030"),
    Type: common.PtrString("scheme"),
  }

  paymentRequest := checkout.PaymentRequest{
    Reference: "YOUR_ORDER_NUMBER",
    Amount: amount,
    MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
    PaymentMethod: checkout.CardDetailsAsCheckoutPaymentMethod(&cardDetails),
    AdditionalData: &map[string]string{
      "allowPartialAuth": "true",
    },
    ReturnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy..",
  }

  // Send the request
  service := client.Checkout()
  req := service.PaymentsApi.PaymentsInput().IdempotencyKey("UUID").PaymentRequest(paymentRequest)
  res, httpRes, err := service.PaymentsApi.Payments(context.Background(), req)
  ```

  #### Python

  ```py
  # Adyen Python API Library v14.0.0
  import Adyen

  adyen = Adyen.Adyen()
  adyen.client.xapikey = "ADYEN_API_KEY"
  # For the LIVE environment, also include your liveEndpointUrlPrefix.
  adyen.client.platform = "test" # The environment to use library in.

  # Create the request object(s)
  json_request = {
    "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
    "amount": {
      "currency": "EUR",
      "value": 100
    },
    "paymentMethod": {
      "type": "scheme",
      "number": "2222 4000 1000 0008",
      "expiryMonth": "03",
      "expiryYear": "2030",
      "cvc": "737"
    },
    "additionalData": {
      "allowPartialAuth": True
    },
    "reference": "YOUR_ORDER_NUMBER",
    "returnUrl": "https://your-company.example.com/checkout?shopperOrder=12xy.."
  }

  # Send the request
  result = adyen.checkout.payments_api.payments(request=json_request, idempotency_key="UUID")
  ```

  #### Ruby

  ```rb
  # Adyen Ruby API Library v11.1.0
  require "adyen-ruby-api-library"

  adyen = Adyen::Client.new
  adyen.api_key = 'ADYEN_API_KEY'
  # For the LIVE environment, also include your liveEndpointUrlPrefix.
  adyen.env = :test # Set to "live" for live environment

  # Create the request object(s)
  request_body = {
    :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
    :amount => {
      :currency => 'EUR',
      :value => 100
    },
    :paymentMethod => {
      :type => 'scheme',
      :number => '2222 4000 1000 0008',
      :expiryMonth => '03',
      :expiryYear => '2030',
      :cvc => '737'
    },
    :additionalData => {
      :allowPartialAuth => true
    },
    :reference => 'YOUR_ORDER_NUMBER',
    :returnUrl => 'https://your-company.example.com/checkout?shopperOrder=12xy..'
  }

  # Send the request
  result = adyen.checkout.payments_api.payments(request_body, headers: { 'Idempotency-Key' => 'UUID' })
  ```

  #### NodeJS (TypeScript)

  ```ts
  // Adyen Node API Library v30.0.1
  import { Client, CheckoutAPI, Types } from "@adyen/api-library";

  // For the LIVE environment, also include your liveEndpointUrlPrefix.
  const config = new Config({
    apiKey: "ADYEN_API_KEY",
    environment: EnvironmentEnum.TEST
  });

  const client = new Client(config);

  // Create the request object(s)
  const amount: Types.checkout.Amount = {
    currency: "EUR",
    value: 100
  };

  const cardDetails: Types.checkout.CardDetails = {
    number: "2222 4000 1000 0008",
    cvc: "737",
    expiryMonth: "03",
    expiryYear: "2030",
    type: Types.checkout.CardDetails.TypeEnum.Scheme
  };

  const paymentRequest: Types.checkout.PaymentRequest = {
    reference: "YOUR_ORDER_NUMBER",
    amount: amount,
    merchantAccount: "YOUR_MERCHANT_ACCOUNT",
    paymentMethod: cardDetails,
    additionalData: {
      "allowPartialAuth": "true"
    },
    returnUrl: "https://your-company.example.com/checkout?shopperOrder=12xy.."
  };

  // Send the request
  const checkoutAPI = new CheckoutAPI(client);
  const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
  ```

* **[Cancel the transaction](/online-payments/cancel)**.\
  This is possible if you use delayed capture or manual capture. Canceling the transaction removes the hold for the partially authorized amount.

* **[Capture](/online-payments/capture)** the partially authorized amount and take no further action\*.

* **For [tokenized payments](/online-payments/tokenization)**, you can retry the original payment method at a later time to collect the outstanding balance\*.

You can also combine these options. For example, you can set a minimum amount for a partial authorization and cancel the transaction if the shopper does not have sufficient funds to cover that minimum amount.

## Testing

The test environment simulates a partially authorized amount by deducting **100** (in minor units) from the original amount. For example, if the request amount is **1139**, the `authorisedAmountValue` in the response is **1039**.

To verify that you can process partial authorizations correctly:

1. Send a [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) request with:

   * Any `amount` that ends with **139**
   * The `additionalData.allowPartialAuth` parameter set to **true**, and details from one of the following cards:

   | Test card                        | Expiry date | CVC |
   | -------------------------------- | ----------- | --- |
   | 4166 6766 6766 6746 (Visa)       | 03/2030     | 737 |
   | 2222 4000 1000 0008 (Mastercard) | 03/2030     | 737 |

2. Check that the response shows:

   * An `authorisedAmountValue` that is **100** (in minor units) less than the original amount.
   * The **PartiallyAuthorised** result code.

## See also

* [Advanced flow integration](/online-payments/build-your-integration/advanced-flow?target=_blank)
* [Partial authorizations for in-person payments](/point-of-sale/partial-authorizations?target=_blank)