In this article, we’ll walk through the complete process of integrating the Stripe Payment Gateway into an ASP.NET Core MVC application. By the end of this guide, you’ll have a fully functional payment system that allows users to make payments using Stripe’s secure checkout.
Introduction
Stripe is a popular payment gateway that allows businesses to accept payments online. It supports credit cards, debit cards, and other payment methods. Stripe provides a secure and easy-to-integrate API for developers.
In this article, we’ll use Stripe Checkout, which is a pre-built payment page hosted by Stripe. This approach is secure and requires minimal setup.
Prerequisites
Before starting, ensure you have the following.
- Stripe Account: Sign up at Stripe.
- .NET SDK: Install the latest .NET SDK from here.
- IDE: Use Visual Studio, Visual Studio Code, or any preferred IDE.
- Stripe API Keys: Retrieve your Publishable Key and Secret Key from the Stripe Dashboard.
Step 1. Create a Stripe Account
- Go to Stripe and sign up for an account.
- Once logged in, navigate to Developers > API Keys.
- Copy your publishable key and secret key. These will be used in your ASP.NET Core application.
Step 2. Set Up an ASP.NET Core MVC Project
- Open Visual Studio or your preferred IDE.
- Create a new ASP.NET Core Web App (Model-View-Controller) project.
- Name the project (e.g., StripePaymentDemo).
- Select .NET 6.0 or later as the framework.
- Build and run the project to ensure it’s set up correctly.
Step 3. Install Stripe.NET NuGet Package
Stripe provides an official .NET library to interact with its API. Install it via the Package Manager Console.
Install-Package Stripe.net
Step 4. Configure Stripe in appsettings.json
Add your Stripe API keys to the appsettings.json file.
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"Stripe": {
"PublishableKey": "YOUR_STRIPE_PUBLISHED_KEY",
"SecretKey": "YOUR_SECRET_KEY"
},
"AllowedHosts": "*"
}
Step 5. Configure Stripe in the Program.cs
Configure Stripe in the Program.cs file.
using Stripe;
namespace StripePaymentDemoApp
{
public class Program
{
public static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
// Add services to the container
builder.Services.AddControllersWithViews();
StripeConfiguration.ApiKey = builder.Configuration["Stripe:SecretKey"];
var app = builder.Build();
// Configure the HTTP request pipeline
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios,
// see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();
}
}
}
Step 6. Create a Payment Controller
Create a new controller named: PaymentController.cs.
using Microsoft.AspNetCore.Mvc;
using Stripe.Checkout;
namespace StripePaymentDemoApp.Controllers
{
public class PaymentController : Controller
{
private readonly IConfiguration _configuration;
public PaymentController(IConfiguration configuration)
{
_configuration = configuration;
}
public IActionResult Checkout()
{
// Pass the Stripe Publishable Key to the view
ViewBag.StripePublishableKey = _configuration["Stripe:PublishableKey"];
return View();
}
[HttpPost]
public async Task<IActionResult> CreateCheckoutSession()
{
// Create a Stripe Checkout Session
var options = new SessionCreateOptions
{
PaymentMethodTypes = new List<string> { "card" },
LineItems = new List<SessionLineItemOptions>
{
new SessionLineItemOptions
{
PriceData = new SessionLineItemPriceDataOptions
{
Currency = "usd",
ProductData = new SessionLineItemPriceDataProductDataOptions
{
Name = "Test Product",
},
UnitAmount = 2000, // $20.00 (in cents)
},
Quantity = 1,
},
},
Mode = "payment",
SuccessUrl = Url.Action("Success", "Payment", null, Request.Scheme),
CancelUrl = Url.Action("Cancel", "Payment", null, Request.Scheme),
};
var service = new SessionService();
var session = await service.CreateAsync(options);
// Redirect to Stripe Checkout
return Redirect(session.Url);
}
public IActionResult Success()
{
return View();
}
public IActionResult Cancel()
{
return View();
}
}
}
Step 7. Create Views
Checkout View (Views/Payment/Checkout.cshtml).
@{
ViewData["Title"] = "Checkout";
Layout = "~/Views/Shared/_Layout.cshtml";
}
<h1>Checkout</h1>
<form asp-action="CreateCheckoutSession" method="post">
<button type="submit" class="btn btn-primary">Pay with Stripe</button>
</form>
Success View (Views/Payment/Success.cshtml).
@{
ViewData["Title"] = "Payment Successful";
Layout = "~/Views/Shared/_Layout.cshtml";
}
<h1>Payment Successful</h1>
<p>Thank you for your payment!</p>
Cancel View (Views/Payment/Cancel.cshtml).
@{
ViewData["Title"] = "Payment Canceled";
Layout = "~/Views/Shared/_Layout.cshtml";
}
<h1>Payment Canceled</h1>
<p>Your payment was canceled.</p>
Step 8. Run and Test the Application
- Run the application using dotnet run or your IDE’s run command.
- Navigate to /Payment/Checkout in your browser.
- Click the "Pay with Stripe" button to be redirected to the Stripe Checkout page.
- Use the following test card details.
- Card Number: 4242 4242 4242 4242.
- Expiration Date: Any future date.
- CVC: Any 3 digits.
- ZIP Code: Any value.
Let's run the application and start the payments with Stripe.
![Application]()
Click the Pay with Stripe Button.
![Stripe button]()
Fill in the payment details with test credentials and click the pay button.
![Test credentials]()
Let's check the Stripe dashboard for our latest transactions.
![Latest transactions]()
Step 9. Handle Webhooks (Optional)
To handle payment confirmation and other events, set up a webhook endpoint.
- Create a Webhook Endpoint in the Stripe Dashboard.
- Go to Developers > Webhooks in the Stripe Dashboard.
- Add a new endpoint with your server's URL (e.g., https://yourdomain.com/Payment/Webhook).
- Add Webhook Secret to:appsettings.json.
{
"Stripe": {
"WebhookSecret": "your_webhook_secret_here"
}
}
- Add Webhook Handler in:PaymentController.cs.
[HttpPost]
public async Task<IActionResult> Webhook()
{
var json = await new StreamReader(HttpContext.Request.Body).ReadToEndAsync();
try
{
var stripeEvent = EventUtility.ConstructEvent(
json,
Request.Headers["Stripe-Signature"],
_configuration["Stripe:WebhookSecret"]
);
// Handle events
if (stripeEvent.Type == Events.CheckoutSessionCompleted)
{
var session = stripeEvent.Data.Object as Session;
// Handle successful payment
}
return Ok();
}
catch (StripeException e)
{
return BadRequest();
}
}
Conclusion
We’ve successfully integrated the Stripe Payment Gateway into our ASP.NET Core MVC application! This solution uses Stripe Checkout, which is secure and easy to implement. You can extend this by adding more features like:
- Custom payment forms using Stripe Elements.
- Storing payment details in a database.
- Sending email confirmations to users.
For more information, refer to the Stripe Documentation.