PayPal Here SDK

Get started with the SDK

  1. Set up your development environment
  2. Get the SDK
  3. Work with the SDK
  4. SDK capabilities
  5. SDK best practices

Set up your development environment

Before you install the SDK:

  • Download and configure the sample apps.
  • Before you can integrate PayPal Here SDK, you must set up your development environment. After you get a token that lets you access protected REST API resources, you create sandbox accounts to test your web and mobile apps. For details, see Get Started.

    Then, return to this page to integrate PayPal Here SDK.

  • Read the Merchant Onboarding Guide to understand how accounts can sign up for PayPal Here and grant permissions to your app.

Get the SDK

To get the SDK:

  1. Visit the GitHub repository to get the software for either:
  2. Review the SDK's Readme file in the GitHub repository, and try building the SDK.

Work with the SDK

To prepare to process transactions with the SDK for the first time, an app must complete these setup operations:

  1. Initialize the SDK each time the app starts.
  2. Initialize the merchant by passing their credentials into the SDK.
  3. Find and Connect to a card reader (for card-present transactions).

After setup is complete, an app must complete these steps to process a basic card-present transaction:

  1. Create an invoice.
  2. Add items to the invoice.
  3. Take a payment using a credit card reader.
  4. Capture the customer's signature, if required for the transaction.
  5. Send a receipt.

Note: The SDK provides the UI to capture the signature and display the receipt options.

Note: These are samples only. You should review the sample apps to see how they are used in an actual application.

Initialize the SDK

  1. Initialize the SDK.
PayPalRetailSDK.initializeSDK()
[PayPalRetailSDK initializeSDK];
RetailSDK.initialize(this, new RetailSDK.AppState()
{
  /**
   * The integrating App should return an activity on which the SDK will launch it's UI elements like card reader finder, payment processing alerts
   */
  @Override
  public Activity getCurrentActivity()
  {
    // Return an activity for SDK UI
  }
  @Override
  public boolean getIsTabletMode()
  {
    // return True for tablet mode
  }
});
RetailSDK.Initialize();
  1. Initialize the merchant. You pass an SdkCredential object, which includes the access token, refresh URL, and the environment. For details, see Token Management.

    Note: For iOS, initializeMerchant also initializes the SDK if it is not already initialized. For iOS, you can call initializeMerchant directly without calling initializeSDK.

let sdkCreds = SdkCredential.init()
sdkCreds.accessToken = "access token of merchant"
sdkCreds.refreshUrl = "refresh URL to use to refresh access token after expiry"
sdkCreds.environment = "either live or sandbox"

PayPalRetailSDK.initializeMerchant(withCredentials: sdkCreds) { (error, merchant) in
    // Code to handle success or failure
    // To continue, this must succeed
}
SdkCredential *sdkCreds = [[SdkCredential alloc] init];
sdkCreds.accessToken = @"access token of merchant";
sdkCreds.refreshUrl = @"refresh URL to use to refresh access token after expiry";
sdkCreds.environment = @"either live or sandbox";
[PayPalRetailSDK initializePPHRetailMerchantwithCredentials:sdkCreds completionHandler:^(PPRetailError *error, PPRetailMerchant merchant) {
     // Code to handle success or failure
     // To continue, this must succeed
}
// credential declarations
SdkCredential credential = new SdkCredential("environment", "access-token");
credential.setTokenRefreshCredentials("refresh URL to use to refresh access token after expiry")
RetailSDK.initializeMerchant(credential, new RetailSDK.MerchantInitializedCallback()
{
  @Override
  public void merchantInitialized(RetailSDKException error, Merchant merchant)
  {
    if (error != null) {
        // handle error situation and try to re-initialize
    } else {
        // merchant initialization success - continue on to card reader connection
    }
  }
});
var merchant = await RetailSDK.InitializeMerchant(new SdkCredentials(sdkToken));
  1. Device discovery. After you initialize the SDK and merchant, connect to a card reader. The following code demonstrates how to connect:

    • You can look for the last known reader.
    • You can search for a reader.
    • You can auto-connect to the last known reader.

    Note: When you use the auto connect method, no SDK UI appears to select a reader because it tries to connect in the background. If you cannot connect to the last known reader, you must use one of the other methods.

// previous declaration of deviceManager
let deviceManager = PayPalRetailSDK.deviceManager()

// code to connect to last known reader or find another
deviceManager.connect(toLastActiveReader: { (error, paymentDevice) -> Void in
    // Code to handle success or failure
    // On error, check the error and retry
    // On success for a Braintree reader, check for software update
})

// code to search and connect
deviceManager.searchAndConnect({ (error, paymentDevice) -> Void in
    // Code to handle success or failure
    // On error, check the error and retry
    // On success for a Braintree reader, check for software update
})

// code to auto-connect to the last known reader
let lastActiveReader = deviceManager?.getLastActiveBluetoothReader()
deviceManager.scanAndAutoConnect(toBluetoothReader: lastActiveReader, callback: { (error, paymentDevice) in
    // Code to handle success or failure
    // On error, check error and connect by another method
    // On success for a Braintree reader, check for software update
})
// previous declaration of deviceManager
PPRetailDeviceManager *deviceManager = [PayPalRetailSDK deviceManager];
// code to connect to last known reader or find another
[deviceManager connectToLastActiveReader:^(PPRetailError *error, PPRetailPaymentDevice *cardReader) {
    // Code to handle success or failure
    // On error, check the error and retry
    // On success for a Braintree reader, check for software update
}];
// code to search and connect
[deviceManager searchAndConnect:^(PPRetailError *error, PPRetailPaymentDevice *cardReader) {
    // Code to handle success or failure
    // On error, check the error and retry
    // On success for a Braintree reader, check for software update
}];
// code to auto-connect to the last known reader
NSString *lastActiveReader = [self.deviceManager getLastActiveBluetoothReader];
[deviceManager scanAndAutoConnectToBluetoothReader:lastActiveReader callback:^(PPRetailError *error, PPRetailPaymentDevice *cardReader) {
    // Code to handle success or failure
    // On error, check error and connect by another method
    // On success for a Braintree reader, check for software update
}];
// code to connect to last known reader or find another
RetailSDK.getDeviceManager().connectToLastActiveReader(new DeviceManager.ConnectionCallback()
{
   @Override
   public void connection(RetailSDKException error, PaymentDevice cardReader)
   {
     if (error == null && cardReader != null)
     {
       // Successfully connected to last active reader
       // For a connected Braintree reader, check for software update
     }
     else if (error != null)
     {
       // Card reader connection failed
     }
     else
     {
       // Could not find the last card reader to connect to
     }
   }
});
// code to search and connect
RetailSDK.getDeviceManager().searchAndConnect(new DeviceManager.ConnectionCallback()
{
  @Override
  public void connection(final RetailSDKException error, final PaymentDevice cardReader)
  {
    if (error == null && cardReader != null)
     {
       // Successfully connected to card reader
       // For a connected Braintree reader, check for software update
     }
     else if (error != null)
     {
       // Card reader connection failed
     }
  }
});
// code to auto-connect to the last known reader
String lastReader = RetailSDK.getDeviceManager().getLastActiveBluetoothReader();
  RetailSDK.getDeviceManager().scanAndAutoConnectToBluetoothReader(lastReader, new DeviceManager.ConnectionCallback()
  {
    @Override
    public void connection(final RetailSDKException error, final PaymentDevice cardReader)
    {
      if (error == null && cardReader != null)
       {
         // Successfully connected to card reader
         // For a connected Braintree reader, check for software update
       }
       else if (error != null)
       {
         // Card reader connection failed
       }
      });
    }
  });
RetailSDK.DeviceDiscovered += (sender, device) =>
{
    device.Connected += (pd) =>
    {
        // Device is connected
    }
    device.ConnectionError += (pd, error) =>
    {
        // Device connection was not successful
    }
    device.Disconnected += (pd, error) =>
    {
        // Device was disconnected
    }
    device.UpdateRequired += (pd, update) =>
    {
        device.PendingUpdate.Begin((error, upgraded) =>
        {
           // Update executed
        });
    }
};
  1. Reader firmware update. If the connected card reader is a Bluetooth reader, you must check for and start the firmware update.
// previous declaration of deviceManager
let deviceManager = PayPalRetailSDK.deviceManager()

// adds the listener to know whether a firmware update is available or not for the active reader
deviceManager.getActiveReader().addUpdateRequiredListener({ (update) -> Void in
    if(update.isRequired) {
        update.offer({ (error, deviceUpdated) in
            if(deviceUpdated) {
                // device was updated
            } else {
                // check error and action accordingly
            }
        })
    } else {
        // firmware update not required at this time
    }
})
// previous declaration of deviceManager
PPRetailDeviceManager *deviceManager = [PayPalRetailSDK deviceManager];
// adds the listener to know whether a firmware update is available or not for the active reader
[[deviceManager getActiveReader] addUpdateRequiredListener:^(PPRetailDeviceUpdate *update) {
    if (update.isRequired) {
        [update offer:^(PPRetailError *error, BOOL deviceUpdated) {
            if(deviceUpdated) {
                // firmware update was completed
            } else {
                // check error and action accordingly
            }
         }];
    } else {
        // firmware update not required at this time
    }
}];
RetailSDK.addDeviceDiscoveredObserver(discoveredObserver);
RetailSDK.DeviceDiscoveredObserver discoveredObserver = new RetailSDK.DeviceDiscoveredObserver()
{
    @Override
    public void deviceDiscovered(PaymentDevice device)
    {
      device.addUpdateRequiredObserver(updateRequiredObserver);
    }
};
PaymentDevice.UpdateRequiredObserver updateRequiredObserver = new PaymentDevice.UpdateRequiredObserver()
{
    @Override
    public void updateRequired(DeviceUpdate update)
    {
      update.offer(new DeviceUpdate.CompletedCallback()
      {
        @Override
        public void completed(RetailSDKException error, Boolean deviceUpgraded)
        {
          if (error != null)
          {
            // Update was successful
          }
        }
      });
    }
};

SDK capabilities

Payment

  1. Create an invoice. Be sure to provide a unique invoice number to protect against duplicate transactions.
var invoice: PPRetailInvoice?
invoice = PPRetailInvoice.init(currencyCode: "USD")
invoice.addItem("My Order", quantity: 1, unitPrice: 1.00, itemId: 123, detailId: nil)
invoice.number = "unique_invoice_number"
PPRetailInvoice invoice = [[PPRetailInvoice alloc] initWithCurrencyCode:@"USD"];
[invoice addItem:@"Amount" quantity:1 unitPrice:1 itemId:@"Id" detailId:nil];
[invoice number:@"unique_invoice_number"];
Invoice invoice = new Invoice(null);
invoice.addItem("Item", new BigDecimal(1), new BigDecimal(1), 1, null);
var invoice = new Invoice(null);
invoice.AddItem("Amount", decimal.One, amount, "", "");
invoice.Number("unique_invoice_number");
  1. Create a TransactionContext using the previously created invoice.
var tc: PPRetailTransactionContext?
PayPalRetailSDK.transactionManager().createTransaction(invoice, callback: { (error, context) in
    // On error, handle error. Else, set transaction context to call beginPayment in next step
    self.tc = context
})
[PayPalRetailSDK.transactionManager createTransaction:invoice callback:^(PPRetailError *error, PPRetailTransactionContext *context) {
    // On error, handle error. Else, set transaction context to call beginPayment in next step
    self.tc = context
}];
TransactionContext currentTransaction;
RetailSDK.getTransactionManager().createTransaction(invoice, new TransactionManager.TransactionCallback()
{
  @Override
  public void transaction(RetailSDKException error, TransactionContext context)
  {
    currentTransaction = context;
    }
});
var transaction = RetailSDK.CreateTransaction(invoice);
  1. Accept a transaction. This part activates the reader so that the customer can select their payment method and then also adds the listeners that will fire when the payment method is chosen.
// Listener called once the transaction is completed
tc.setCompletedHandler { (error, txnRecord) -> Void in

    // if error, handle accordingly, else pop back to view controller and handle success

    self.navigationController?.popToViewController(self, animated: false)

    // txnRecord would have any info needed to record the successful transaction
}
// Setting up the options for the transaction.
let options = PPRetailTransactionBeginOptions()
options.showPromptInCardReader = true
options.showPromptInApp = true
options.preferredFormFactors = []
options.tippingOnReaderEnabled = false
options.amountBasedTipping = false
options.isAuthCapture = false
options.quickChipEnabled = false

// Activates the reader to show the payment options
tc.beginPayment(options)
// Listener called once the transaction is completed
[self.transactionContext setCompletedHandler:^(PPRetailError *error, PPRetailTransactionRecord *txnRecord) {
    // if error, handle accordingly, else pop back to view controller and handle success

    [self.navigationController popToViewController:self animated:YES];

    // txnRecord would have any info needed to record the successful transaction
}];

// Setting up the options for the transaction.
PPRetailTransactionBeginOptions *options = [[PPRetailTransactionBeginOptions alloc] init];
options.showPromptInCardReader = YES;
options.showPromptInApp = YES;
options.preferredFormFactors = @[];
options.tippingOnReaderEnabled = NO;
options.amountBasedTipping = NO;
options.isAuthCapture = NO;
options.quickChipEnabled = NO;

// Activates the reader to show the payment options
[self.transactionContext beginPayment:options];
currentTransaction.setCompletedHandler(new TransactionContext.TransactionCompletedCallback()
{
  @Override
  public void transactionCompleted(RetailSDKException error, TransactionRecord record)
  {
    TransactionActivity.this.transactionCompleted(error, record);
  }
});

TransactionBeginOptions options = new TransactionBeginOptions();
options.setShowPromptInCardReader(true);
options.setShowPromptInApp(false);
options.setIsAuthCapture(false);
options.setAmountBasedTipping(false);
options.setQuickChipEnabled(false);
options.setTippingOnReaderEnabled(false);

currentTransaction.beginPayment(options);
transaction.Begin();
transaction.SetCompletedHandler((error, record) =>
{
    if (error != null)
    {
        // Error - handle accordingly
    } else {
        // Success - do something with the transaction record
    }

});
Payment option Type Description
showPromptInCardReader Bool Prompts the customer to tap/insert/swipe the card and whether that appears on the reader.
showPromptInApp Bool Prompts the customer to tap/insert/swipe the card and whether that UI shows in the integrating app.
preferredFormFactors Array Restricts accepted payment methods (contactless, swipe, chip).
tippingOnReaderEnabled Bool Defines whether the customer is prompted for a tip on the card reader.
amountBasedTipping Bool Defines whether the tipping is amount based or percentage based.
isAuthCapture Bool Defines whether the transaction runs as an authorization or a sale. If true, you also must implement the Receipts API.
quickChipEnabled Bool Enables quick chip processing so customers don't have to leave their card inserted the whole time the transaction is processing.

Offline payment

This feature is currently only available to US merchants.

Important: To use offline payments, you must enable it on your PayPal account. To enable it, send your account email address and a business case to use offline payments to pph-sdk@paypal.com.

Offline mode is only available with EMV-capable card readers. Also, offline mode forces the supported card readers to only accept swipe transactions.

To use the offline payments feature, your app must check for Internet connectivity. If you have no connectivity, your app must request that the PayPal Here SDK store the transaction as offline on the mobile device. When the Internet connectivity is regained, your app must request that PayPal Here SDK process the pending offline transaction.

You are subject to the following limits on activity with the offline payments feature:

  • You can only process transactions under USD $5,000.
  • You can only process a total of USD $50,000.
  • You must reconnect to the Internet within 72 hours or the offline transactions expire.

These limits are subject to change at PayPal's sole discretion. PayPal informs you of changes by email.

As a partner, your end-user merchants assume all liability for any offline transactions, including those that are subsequently declined, expired, or disputed. Your end-user merchants cannot dispute declined offline transactions. Your end-user merchants also assume all liability for offline transactions if the device is lost, stolen, damaged, or you delete your app before re-connecting to the Internet. Any refunds are processed in the normal course after your end user merchants are re-connected to the Internet.

Before you enable the offline payments feature, you agree to communicate these terms and conditions to your end users and secure their agreement to those terms and conditions before your end users can use the feature.

  1. Merchant initialization If you have an Internet connection and can call initializeMerchant successfully, you can proceed to step 2 to enable offline mode. You do not need to call initializeMerchantOffline if you've already completed a successful online merchant initialization. However, if you do not have an Internet connection to call initializeMerchant, you can call intializeMerchantOffline to successfully initialize the merchant before processing offline transactions.

Notes:

  • Call initializeMerchantOffline only if you cannot initially call initializeMerchant.

  • You can complete an offline merchant initialization only after successfully completing at least one online merchant initialization on the device.

  • If you cannot initially call initializeMerchant and instead called initializeMerchantOffline, you must call initializeMerchant before replaying offline transactions. Before you can process online transactions, online merchant initialization must succeed.

PayPalRetailSDK.initializeMerchantOffline { (error, merchant) in
    // Code to handle success or failure
}
[PayPalRetailSDK initializeMerchantOffline:^(PPRetailError *error, PPRetailMerchant *merchant) {
    // Code to handle success or failure
}];
RetailSDK.initializeMerchantOffline(new RetailSDK.MerchantInitializedCallback()
  {
    @Override
    public void merchantInitialized(RetailSDKException error, Merchant merchant)
    {
      // Code to handle success or failure
    }
  });
  1. Enable offline payments to accept payments when you have no internet connection. This will start the offline processing of transactions and save them on the device.
PayPalRetailSDK.transactionManager().startOfflinePayment(callback: { (error, offlinePaymentStatusList) in
    // Status of all the processed and unprocessed offline transactions
})
[PayPalRetailSDK.transactionManager startOfflinePayment:^(PPRetailError *error, NSArray *status) {
    // Status of all the processed and unprocessed offline transactions
}];
RetailSDK.getTransactionManager().startOfflinePayment(new TransactionManager.OfflinePaymentStatusCallback()
{
  @Override
  public void offlinePaymentStatus(RetailSDKException error, List < OfflinePaymentStatus > status)
  {
    // Status of all the processed and unprocessed offline transactions
  }
});
  1. Create a TransactionContext using the previously created invoice in the same way as one would for a normal payment.

  2. Accept a transaction in the same way as a normal payment. For offline payments the reader will only accept swipe transactions at this time. Transaction options are not available when processing offline payments.

  3. Check the status of the offline payment saved on the device.

PayPalRetailSDK.transactionManager().getOfflinePaymentStatus(callback: { (error, offlinePaymentStatusList) in
    // Status of the accepted transaction
})
[PayPalRetailSDK.transactionManager getOfflinePaymentStatus:^(PPRetailError *error, NSArray *status) {
    // Status of the accepted transaction
}];
RetailSDK.getTransactionManager().getOfflinePaymentStatus(new TransactionManager.OfflinePaymentStatusCallback()
{
  @Override
  public void offlinePaymentStatus(RetailSDKException error, List < OfflinePaymentStatus > status)
  {
    // Status of the accepted transaction
  }
});
  1. Start processing the offline payments.
PayPalRetailSDK.transactionManager().startReplayOfflineTxns(callback: { (error, offlinePaymentStatusList) in
    // Status of the accepted offline transaction after attempting to process it
})
[PayPalRetailSDK.transactionManager startReplayOfflineTxns:^(PPRetailError *error, NSArray *status) {
    // Status of the accepted offline transaction after attempting to process it
}];
RetailSDK.getTransactionManager().startReplayOfflineTxns(new TransactionManager.OfflinePaymentStatusCallback()
{
  @Override
  public void offlinePaymentStatus(RetailSDKException error, List < OfflinePaymentStatus > status)
  {
    // Status of the accepted offline transaction after attempting to process it
  }
});
  1. Stop processing the offline payments at any time.
PayPalRetailSDK.transactionManager().stopReplayOfflineTxns(callback: { (error, offlinePaymentStatusList) in
    // Status of the offline transactions
})
[PayPalRetailSDK.transactionManager stopReplayOfflineTxns:^(PPRetailError *error, NSArray *status) {
    // Status of the offline transactions
}];
RetailSDK.getTransactionManager().stopReplayOfflineTxns(new TransactionManager.OfflinePaymentStatusCallback()
{
  @Override
  public void offlinePaymentStatus(RetailSDKException error, List < OfflinePaymentStatus > status)
  {
    // Status of the offline transactions
  }
});
  1. Disable offline payments.

Note: The SDK is brought back into online mode once startReplayOfflineTxns is called. When this happens, the app does not need to call stopOfflinePayment to return to online mode.

PayPalRetailSDK.transactionManager().stopOfflinePayment();
[PayPalRetailSDK.transactionManager stopOfflinePayment];
RetailSDK.getTransactionManager().stopOfflinePayment();

Refund

Refunds can either be done within your app or you can use our Refund API to incorporate refund functionality in your back-office. These steps outline how to complete a refund within your app:

  1. Create a TransactionContext for the invoice you would like to refund. The createRefundTransaction method takes in the following parameters: PayPal invoice ID, transaction ID, payment method of the transaction, and a callback handler.
PayPalRetailSDK.transactionManager().createRefundTransaction(paypalInvoiceId, transactionNumber: transactionNumber, paymentMethod: paymentMethod, callback: refundHandler)
[PayPalRetailSDK.transactionManager createRefundTransaction:paypalInvoiceId transactionNumber:transactionNumber paymentMethod:paymentMethod callback:^(PPRetailError *error, PPRetailTransactionContext *context) {
        // refund handler
    }];
RetailSDK.getTransactionManager().createRefundTransaction(transactionRecord.getInvoiceId(), transactionRecord.getTransactionNumber(), transactionRecord.getPaymentMethod(), new TransactionManager.TransactionCallback()
{
  @Override
  public void transaction(RetailSDKException error, TransactionContext refundTransaction)
  {
    // Insert beginRefund code here
  }
});
currentTransaction = RetailSDK.createTransaction(invoice);

The callback handler accepts an error object and transaction context. If the error object is not nil, then handle accordingly. Otherwise, use the transaction context to call beginRefund.

  1. Call into beginRefund to determine whether the card is present for the refund, and to process the refund. This code would be used as part of the callbacks mentioned in the createRefundTransaction method.
// Listener that gets called once the refund processes
tc.setCompletedHandler { (error, txnRecord) -> Void in
    // if error, handle accordingly, else pop back to view controller and handle success

    self.navigationController?.popToViewController(self, animated: false)

    // txnRecord would have any info needed to record the successful refund
}

// Begins refund process and asks if a card is present for the refund
tc.beginRefund(true, amount: refundAmount)
// Listener that gets called once the refund processes
[self.transactionContext setCompletedHandler:^(PPRetailError *error, PPRetailTransactionRecord *txnRecord) {
    // if error, handle accordingly, else pop back to view controller and handle success

    [self.navigationController popToViewController:self animated:YES];

    // txnRecord would have any info needed to record the successful transaction
}];

// Begins refund process and asks if a card is present for the refund
[self.transactionContext beginRefund:YES amount:refundAmount];
// Listener that gets called once the refund processes
refundTransaction.setCompletedHandler(new TransactionContext.TransactionCompletedCallback()
{
  @Override
  public void transactionCompleted(RetailSDKException error, TransactionRecord record)
  {
    RefundActivity.this.refundCompleted(error, record);
  }
});

// Begins refund process by asking if a card is present for the refund
refundTransaction.beginRefund(true, currentAmount);
if(cardPresent) {
    currentTransaction.beginRefund(true, new BigDecimal(amount));
} else {
    TransactionContext noCardTransaction =  currentTransaction.beginRefund(false, new BigDecimal(amount));
    noCardTransaction.continueWithCard(null);
}

Additional capabilities

The SDK also supports several additional capabilities:

  • Adding a referrer code to a transaction
  • Accepting keyed-in card payments
  • Adding a unique invoice ID to a transaction

Best practices

  • Title the REST Application that you created on developer.paypal.com appropriately with the business name so that merchants have a clear understanding of to whom they are providing permissions.
  • Do not store the client ID and client secret on the mobile device storage. These should be stored securely on your server or back-end server for security reasons.
  • Ensure the option to connect a merchant's PayPal account for PayPal Here processing is clear and concise. Once connected, show the email address of the connected account so the merchant is aware of which account they are using at all times.
  • Provide an option for the merchant to disconnect their account from processing. When a merchant chooses this option, remove all refresh and access tokens for that merchant from your system.
  • Use official images supplied by PayPal for any PayPal Here imagery.
  • Initialize the SDK and merchant immediately after the merchant logs into your app to allow for the app to be ready to transact on the checkout page right away.
  • Implement the appropriate listeners for the reader software update so that mandatory updates are handled accordingly.
  • Utilize your own invoice number as part of the invoice object. This parameter is used for duplicate transaction prevention in the event you need to retry a payment attempt.
  • For successful transactions, keep track of the PayPal invoice ID along with the transaction ID. These values can be used later on for refunds, get details calls, etc.
  • For error scenarios, keep track of the correlation ID, date/time of the error, and the error message itself. The correlation ID greatly decreases resolution time if it is able to be provided to PayPal support teams at all times.

When your integration is complete, check the going live page to ensure that you have everything ready for activation. Once that is working, you can implement other customizations that are available with the SDK into your integration.

Feedback