Yes, you can integrate Paystack with Django to handle payments securely and
efficiently! Here's a step-by-step guide to help you learn how to set up a Paystack
payment system using Django. This method will include:
1. Initializing the transaction on the Django backend.
2. Using the Paystack payment modal on the frontend.
3. Verifying the transaction via a webhook or API.
### Prerequisites
- You should have basic knowledge of Django (models, views, templates).
- You'll need an account with Paystack to get your **public key** and **secret key**.
### Steps to Integrate Paystack in Django
#### 1. **Install Required Packages**
Install the required packages for making HTTP requests from Django:
```bash
pip install requests
```
#### 2. **Set Up Paystack Keys in Django Settings**
In your `settings.py`, store your Paystack **public** and **secret** keys as
environment variables or directly in the settings file (for simplicity here):
```python
# settings.py
PAYSTACK_PUBLIC_KEY = 'your-paystack-public-key'
PAYSTACK_SECRET_KEY = 'your-paystack-secret-key'
```
#### 3. **Create a Payment Model (Optional)**
You might want to store the details of each payment in your database. For example:
```python
# models.py
from django.db import models
class Payment(models.Model):
reference = models.CharField(max_length=100, unique=True)
email = models.EmailField()
amount = models.IntegerField() # Amount in kobo (1 NGN = 100 kobo)
verified = models.BooleanField(default=False)
created_at = models.DateTimeField(auto_now_add=True)
def __str__(self):
return f'Payment {self.reference}'
```
#### 4. **Django View to Initialize Payment**
Next, create a Django view that initializes the Paystack transaction on the backend
using their API. Paystack’s [Transaction Initialize
API](https://paystack.com/docs/api/#transaction-initialize) will return a payment
reference and authorization URL.
```python
# views.py
import requests
from django.conf import settings
from django.shortcuts import render, redirect
from django.http import JsonResponse
from .models import Payment
import random
def initialize_payment(request):
if request.method == "POST":
email = request.POST.get('email')
amount = int(request.POST.get('amount')) * 100 # Amount in kobo (1 NGN =
100 kobo)
# Generate a unique reference for the transaction
reference = f'PS_{random.randint(100000, 999999)}'
# Save the payment details in the database (optional)
payment = Payment.objects.create(
reference=reference,
email=email,
amount=amount
)
# Paystack transaction initialization request
headers = {
'Authorization': f'Bearer {settings.PAYSTACK_SECRET_KEY}',
'Content-Type': 'application/json',
}
data = {
'email': email,
'amount': amount,
'reference': reference
}
url = 'https://api.paystack.co/transaction/initialize'
try:
response = requests.post(url, json=data, headers=headers)
response_data = response.json()
if response_data['status']:
# Redirect user to the Paystack payment page
return JsonResponse({'payment_url': response_data['data']
['authorization_url']})
else:
return JsonResponse({'error': 'Payment initialization failed'}, status=400)
except Exception as e:
return JsonResponse({'error': str(e)}, status=500)
else:
return render(request, 'payment_form.html')
```
### 5. **Frontend Form to Trigger Payment**
In your Django template, create a form to collect the email and amount for the
payment. The form will send data to the `initialize_payment` view when submitted.
```html
<!-- payment_form.html -->
<form id="paymentForm" method="POST">
{% csrf_token %}
<input type="email" name="email" placeholder="Enter your email" required>
<input type="number" name="amount" placeholder="Amount" required>
<button type="submit">Pay Now</button>
</form>
<script>
document.getElementById('paymentForm').addEventListener('submit', function
(e) {
e.preventDefault();
// Fetch the form data
const formData = new FormData(this);
fetch("{% url 'initialize_payment' %}", {
method: 'POST',
body: formData,
headers: {
'X-CSRFToken': '{{ csrf_token }}'
}
})
.then(response => response.json())
.then(data => {
if (data.payment_url) {
// Redirect user to Paystack payment page
window.location.href = data.payment_url;
} else {
alert('Payment initialization failed');
}
})
.catch(error => console.log('Error:', error));
});
</script>
```
### 6. **Verify the Payment (Server-side)**
Once the user completes the payment, you should verify the transaction on the
server to confirm that it was successful. Paystack provides a **Transaction Verify
API** for this.
You can add this to your views:
```python
# views.py
def verify_payment(reference):
headers = {
'Authorization': f'Bearer {settings.PAYSTACK_SECRET_KEY}',
}
url = f'https://api.paystack.co/transaction/verify/{reference}'
try:
response = requests.get(url, headers=headers)
response_data = response.json()
if response_data['status'] and response_data['data']['status'] == 'success':
# Mark the payment as verified in your database
Payment.objects.filter(reference=reference).update(verified=True)
return True
return False
except Exception as e:
return False
```
In your **callback function** after the user pays, you can call this function to verify
the transaction using the `reference` returned from Paystack.
### 7. **Optional: Handle Webhooks**
You can also configure Paystack webhooks to automatically notify your server when
a transaction is completed. Set up an endpoint in Django to handle these
notifications.
```python
# views.py
from django.views.decorators.csrf import csrf_exempt
from django.http import HttpResponse
@csrf_exempt
def paystack_webhook(request):
if request.method == 'POST':
event = request.POST
# Check for the event type you're interested in
if event['event'] == 'charge.success':
reference = event['data']['reference']
# Verify the payment and update your database
verify_payment(reference)
return HttpResponse(status=200)
return HttpResponse(status=400)
```
### 8. **Urls Configuration**
Add the necessary URLs for initializing payments and handling webhooks in
`urls.py`:
```python
# urls.py
from django.urls import path
from .views import initialize_payment, paystack_webhook
urlpatterns = [
path('initialize-payment/', initialize_payment, name='initialize_payment'),
path('webhook/', paystack_webhook, name='paystack_webhook'),
]
```
---
### Summary of Steps:
1. **Backend Payment Initialization**: Django handles initializing the transaction via
Paystack’s API.
2. **Frontend Payment Modal**: The user is redirected to the Paystack payment
page via a generated authorization URL.
3. **Payment Verification**: After payment, you verify the transaction using
Paystack’s verification endpoint or by handling a webhook.
### Resources:
- Paystack Documentation: [https://paystack.com/docs/](https://paystack.com/docs/)
- Django Documentation:
[https://docs.djangoproject.com/](https://docs.djangoproject.com/)
This integration provides a secure and Django-friendly way to accept payments
using Paystack.
