How To Integrate Paypal Payment Gateway In Asp Net Mvc

People are currently reading this guide.

Alright fellow developers! Ready to dive into the world of seamless online transactions? Integrating a payment gateway into your web application is a crucial step for any e-commerce venture. Today, we're going to tackle a popular and reliable choice: PayPal. This comprehensive guide will walk you through the process of integrating the PayPal payment gateway into your ASP.NET MVC application, step by step. Let's get started!

Step 1: Setting Up Your PayPal Developer Account and Creating Sandbox Credentials

Before we even touch our ASP.NET MVC project, we need to configure our PayPal developer environment. This is where you'll get the necessary credentials for testing your integration in a safe, non-live environment.

Sub-heading: Creating a PayPal Developer Account

  1. Navigate to the PayPal Developer website.
  2. Click on the "Log in to Dashboard" button. If you don't have an account, you'll be prompted to create one. Choose a business account for development purposes.
  3. Once logged in, you'll be directed to your developer dashboard.

Sub-heading: Generating Sandbox API Credentials

The sandbox environment allows you to simulate transactions without using real money. You'll need API credentials for this.

  1. On your developer dashboard, go to "Apps & Credentials" in the left-hand menu.
  2. Make sure the "Sandbox" tab is selected.
  3. Scroll down to the "REST API apps" section and click on the "Create App" button.
  4. Enter a name for your application (e.g., "My ASP.NET MVC App Sandbox").
  5. Click "Create App".
  6. You will now see the Client ID and Secret for your sandbox application. Keep these credentials secure as you will need them later in your ASP.NET MVC application.

Step 2: Installing the PayPal .NET SDK via NuGet Package Manager

Now, let's switch gears and head over to your ASP.NET MVC project. We'll use the official PayPal .NET SDK to simplify the integration process.

  1. Open your ASP.NET MVC project in Visual Studio.

  2. Go to "Tools" > "NuGet Package Manager" > "Package Manager Console".

  3. In the Package Manager Console, type the following command 1 and press Enter:  

    1. locall.host
    locall.host

    PowerShell
    Install-Package PayPalCheckoutSdk

    This command will download and install the necessary PayPal .NET SDK libraries into your project.

Step 3: Configuring Your ASP.NET MVC Application

With the SDK installed, we need to configure our application to use our PayPal sandbox credentials.

Sub-heading: Storing PayPal Configuration

It's best practice to store sensitive information like API credentials in your application's configuration files.

  1. Open your Web.config file (or appsettings.json if you are using .NET Core).

  2. Add the following keys within the <appSettings> (or "AppSettings" section in appsettings.json):

    XML
    <add key="PayPalClientId" value="YOUR_SANDBOX_CLIENT_ID" />
    <add key="PayPalClientSecret" value="YOUR_SANDBOX_CLIENT_SECRET" />
    <add key="PayPalMode" value="sandbox" /> ```
    
    ```json
    // For appsettings.json
    "AppSettings": {
      "PayPalClientId": "YOUR_SANDBOX_CLIENT_ID",
        "PayPalClientSecret": "YOUR_SANDBOX_CLIENT_SECRET",
          "PayPalMode": "sandbox" // Use "live" for production
          }

    Replace YOUR_SANDBOX_CLIENT_ID and YOUR_SANDBOX_CLIENT_SECRET with the actual credentials you obtained in Step 1.

Sub-heading: Creating a PayPal Service Class (Optional but Recommended)

To keep your controllers clean and maintainable, consider creating a dedicated service class to handle PayPal interactions.

  1. Create a new folder named "Services" in your project.

  2. Add a new C# class named PayPalService.cs (or similar).

  3. Add the following code to this class:

    C#
    using PayPalCheckoutSdk.Core;
    using PayPalCheckoutSdk.Orders;
    using Microsoft.Extensions.Configuration;
    using System.Collections.Generic;
    using System.Threading.Tasks;
    
    public class PayPalService
    {
        private readonly string _clientId;
            private readonly string _clientSecret;
                private readonly string _mode;
                
                    public PayPalService(IConfiguration configuration)
                        {
                                _clientId = configuration["AppSettings:PayPalClientId"];
                                        _clientSecret = configuration["AppSettings:PayPalClientSecret"];
                                                _mode = configuration["AppSettings:PayPalMode"];
                                                    }
                                                    
                                                        private PayPalEnvironment Environment()
                                                            {
                                                                    return _mode.ToLower() == "live" ?
                                                                                new LiveEnvironment(_clientId, _clientSecret) :
                                                                                            new SandboxEnvironment(_clientId, _clientSecret);
                                                                                                }
                                                                                                
                                                                                                    private PayPalHttpClient Client()
                                                                                                        {
                                                                                                                return new PayPalHttpClient(Environment());
                                                                                                                    }
                                                                                                                    
                                                                                                                        public async Task<Order> CreateOrder(decimal amount, string currency = "USD")
                                                                                                                            {
                                                                                                                                    var order = new OrderRequest()
                                                                                                                                            {
                                                                                                                                                        CheckoutPaymentIntent = "CAPTURE",
                                                                                                                                                                    PurchaseUnits = new List<PurchaseUnitRequest>()
                                                                                                                                                                                {
                                                                                                                                                                                                new PurchaseUnitRequest()
                                                                                                                                                                                                                {
                                                                                                                                                                                                                                    AmountWithBreakdown = new AmountWithBreakdown()
                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                                                CurrencyCode = currency,
                                                                                                                                                                                                                                                                                                        Value = amount.ToString("0.00")
                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                        var request = new OrdersCreateRequest();
                                                                                                                                                                                                                                                                                                                                                                                request.Prefer("return=representation");
                                                                                                                                                                                                                                                                                                                                                                                        request.RequestBody(order);
                                                                                                                                                                                                                                                                                                                                                                                                var response = await Client().Execute(request);
                                                                                                                                                                                                                                                                                                                                                                                                        var result = response.Result<Order>();
                                                                                                                                                                                                                                                                                                                                                                                                                return result;
                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                        public async Task<Order> CaptureOrder(string orderId)
                                                                                                                                                                                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                                                                                                                                                                                    var request = new OrdersCaptureRequest(orderId);
                                                                                                                                                                                                                                                                                                                                                                                                                                            request.RequestBody(new OrderActionRequest());
                                                                                                                                                                                                                                                                                                                                                                                                                                                    var response = await Client().Execute(request);
                                                                                                                                                                                                                                                                                                                                                                                                                                                            var result = response.Result<Order>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    return result;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

    Don't forget to inject IConfiguration in your Startup.cs or Program.cs if you are using .NET Core.

Step 4: Implementing the Checkout Process in Your Controller and View

Now, let's build the user interface and the controller logic to initiate the PayPal payment.

Sub-heading: Creating the View for Checkout

Create a view (e.g., Checkout.cshtml) where the user can review their order and initiate the PayPal payment. You might have a button that triggers the PayPal process.

Razor CSHTML
@model YourWebApp.Models.OrderViewModel <h2>Checkout</h2>
  
  <div>
      <p>Order Total: $@Model.TotalAmount</p>
          <div id="paypal-button-container"></div>
          </div>
          
          @section scripts {
              <script src="https://www.paypal.com/sdk/js?client-id=@Configuration["AppSettings:PayPalClientId"]&currency=USD"></script>
                  <script>
                          paypal.Buttons({
                                      createOrder: function(data, actions) {
                                                      return fetch('/Payment/CreatePayPalOrder', { // Replace with your controller action URL
                                                                          method: 'post',
                                                                                              headers: {
                                                                                                                      'Content-Type': 'application/json'
                                                                                                                                          },
                                                                                                                                                              body: JSON.stringify({
                                                                                                                                                                                      amount: '@Model.TotalAmount' // Send the order amount to the server
                                                                                                                                                                                                          })
                                                                                                                                                                                                                          }).then(function(res) {
                                                                                                                                                                                                                                              return res.json();
                                                                                                                                                                                                                                                              }).then(function(orderData) {
                                                                                                                                                                                                                                                                                  return orderData.id;
                                                                                                                                                                                                                                                                                                  });
                                                                                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                                                                                                          onApprove: function(data, actions) {
                                                                                                                                                                                                                                                                                                                                          return fetch('/Payment/CapturePayPalOrder/' + data.orderID, { // Replace with your capture action URL
                                                                                                                                                                                                                                                                                                                                                              method: 'post'
                                                                                                                                                                                                                                                                                                                                                                              }).then(function(res) {
                                                                                                                                                                                                                                                                                                                                                                                                  return res.json();
                                                                                                                                                                                                                                                                                                                                                                                                                  }).then(function(orderData) {
                                                                                                                                                                                                                                                                                                                                                                                                                                      // Successful capture, redirect or display success message
                                                                                                                                                                                                                                                                                                                                                                                                                                                          alert('Payment successful! Order ID: ' + orderData.id);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              window.location.href = '/Order/Success/' + orderData.id; // Redirect to a success page
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onError: function(err) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // Handle errors
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      console.error('An error occurred during payment', err);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      alert('An error occurred during payment. Please try again.');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }).render('#paypal-button-container');
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              </script>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

Remember to replace YourWebApp.Models.OrderViewModel, /Payment/CreatePayPalOrder, /Payment/CapturePayPalOrder/, and /Order/Success/ with your actual model and route URLs.

Sub-heading: Creating the Controller Actions

Now, create a controller (e.g., PaymentController.cs) with actions to handle the PayPal order creation and capture.

C#
using Microsoft.AspNetCore.Mvc;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              using Microsoft.Extensions.Configuration;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              using System.Threading.Tasks;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              using YourWebApp.Services; // Assuming you created the PayPalService
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              using YourWebApp.Models; // Assuming you have an OrderViewModel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              public class PaymentController : Controller
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  private readonly PayPalService _payPalService;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      private readonly IConfiguration _configuration;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          public PaymentController(PayPalService payPalService, IConfiguration configuration)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      _payPalService = payPalService;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _configuration = configuration;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [HttpPost]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          public async Task<IActionResult> CreatePayPalOrder([FromBody] OrderViewModel model)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (ModelState.IsValid)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          var order = await _payPalService.CreateOrder(model.TotalAmount);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      return Json(new { id = order.Id });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      return BadRequest();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [HttpPost]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  public async Task<IActionResult> CapturePayPalOrder(string orderID)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (!string.IsNullOrEmpty(orderID))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  var order = await _payPalService.CaptureOrder(orderID);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (order.Status.ToLower() == "completed")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          // Process your order fulfillment logic here
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          // Save order details to your database, etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return Json(new { id = order.Id, status = order.Status });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              return BadRequest(new { message = "Payment capture failed." });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return BadRequest();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

Ensure you have injected the PayPalService and IConfiguration into your controller.

Step 5: Testing Your PayPal Integration (Sandbox Environment)

With everything set up, it's time to test your integration in the PayPal sandbox environment.

  1. Run your ASP.NET MVC application.
  2. Navigate to your checkout page.
  3. Click the PayPal button. This should redirect you to the PayPal sandbox login page.
  4. Log in using a sandbox buyer account. You can create test buyer accounts on the PayPal Developer website under "Sandbox" > "Accounts".
  5. Complete the payment process.
  6. You should be redirected back to your application. Verify that the onApprove JavaScript function is executed and that your capture action is called successfully.
  7. Check your PayPal sandbox account to see the transaction details.

Step 6: Going Live (Production Environment)

Once you've thoroughly tested your integration in the sandbox, you can prepare to go live.

  1. Obtain live API credentials from your PayPal developer dashboard (switch to the "Live" tab under "Apps & Credentials" and create a new app).
  2. Update your Web.config or appsettings.json file with your live Client ID and Secret.
  3. Change the PayPalMode setting to "live".
  4. Thoroughly test your live integration with small, real transactions before fully launching. Ensure you have proper error handling and logging in place.

Frequently Asked Questions (How to...)

How to get PayPal API credentials?

Navigate to the PayPal Developer website, log in to your dashboard, go to "Apps & Credentials," and create or view your REST API apps for either the Sandbox or Live environment.

How to install the PayPal .NET SDK?

Open the NuGet Package Manager Console in Visual Studio and run the command Install-Package PayPalCheckoutSdk.

How to configure PayPal settings in ASP.NET MVC?

Store your Client ID, Secret, and Mode ("sandbox" or "live") in your Web.config (under <appSettings>) or appsettings.json (under the "AppSettings" section).

How to create a PayPal order from my ASP.NET MVC controller?

Use the OrdersCreateRequest from the PayPal .NET SDK within your controller action, providing details like the amount and currency. You can utilize a service class to encapsulate this logic.

How to capture a PayPal order after the user approves?

Use the OrdersCaptureRequest with the orderID obtained from the client-side onApprove callback. Execute this request on your server-side controller.

How to handle payment success and failure?

Implement the onApprove and onError callbacks in your client-side JavaScript. On the server-side, check the status of the captured order and handle success or failure accordingly (e.g., update your database, send confirmation emails).

How to test PayPal integration in a sandbox environment?

Use the sandbox API credentials and create test buyer accounts on the PayPal Developer website to simulate transactions without using real money.

How to switch from sandbox to live environment?

Obtain live API credentials and update the PayPalClientId, PayPalClientSecret, and PayPalMode settings in your configuration files to their live values.

How to handle different currencies with PayPal?

Modify the CurrencyCode property in the PurchaseUnitRequest when creating the order. Ensure your PayPal account supports the desired currencies.

How to implement recurring payments or subscriptions with PayPal in ASP.NET MVC?

The basic integration shown here is for one-time payments. For recurring payments, you would need to explore the PayPal Subscriptions API, which involves a more complex setup with plans and agreements. The PayPal .NET SDK provides functionalities for this, but it's a more advanced topic.

Congratulations! You've now taken a significant step towards integrating the PayPal payment gateway into your ASP.NET MVC application. Remember to always prioritize security and thoroughly test your integration in both sandbox and live environments. Happy coding!

5798240817082240430
How To Integrate Paypal Payment Gateway In Asp Net Mvc

You have our undying gratitude for your visit!