Scribd
Upload
83 views8 pages

How To Integrate Paystack

Uploaded by

davideneasatochibueze
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
83 views8 pages

How To Integrate Paystack

Uploaded by

davideneasatochibueze
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 8

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.

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy