Accept Payments with Paystack in FastAPI

pip install fastapi uvicorn httpx python-decouple

Create a .env file:

PAYSTACK_SECRET_KEY=sk_test_xxxxxxxxxxxxxxxxxxxxx
BASE_URL=http://localhost:8000

# main.py
from fastapi import FastAPI
from decouple import config

app = FastAPI()

PAYSTACK_SECRET = config('PAYSTACK_SECRET_KEY')
BASE_URL = config('BASE_URL')

# schemas.py
from pydantic import BaseModel, EmailStr

class PaymentRequest(BaseModel):
    email: EmailStr
    amount: float

class PaymentResponse(BaseModel):
    authorization_url: str
    access_code: str
    reference: str

class VerifyResponse(BaseModel):
    success: bool
    amount: float = 0
    currency: str = ''
    email: str = ''

# main.py
import httpx
import uuid

@app.post('/api/pay', response_model=PaymentResponse)
async def initialize_payment(payment: PaymentRequest):
    reference = 'order_' + uuid.uuid4().hex[:12]

    async with httpx.AsyncClient() as client:
        response = await client.post(
            'https://api.paystack.co/transaction/initialize',
            json={
                'email': payment.email,
                'amount': int(payment.amount * 100),
                'reference': reference,
                'callback_url': BASE_URL + '/api/payment/callback',
            },
            headers={
                'Authorization': 'Bearer ' + PAYSTACK_SECRET,
                'Content-Type': 'application/json',
            },
        )

    data = response.json()

    if not data.get('status'):
        raise HTTPException(status_code=400, detail=data.get('message', 'Failed'))

    # TODO: Save order to database

    return PaymentResponse(
        authorization_url=data['data']['authorization_url'],
        access_code=data['data']['access_code'],
        reference=data['data']['reference'],
    )

# main.py
from fastapi import Query
from fastapi.responses import RedirectResponse, HTMLResponse

@app.get('/api/payment/callback')
async def payment_callback(reference: str = Query(None), trxref: str = Query(None)):
    ref = reference or trxref

    if not ref:
        return HTMLResponse('Missing reference', status_code=400)

    async with httpx.AsyncClient() as client:
        response = await client.get(
            'https://api.paystack.co/transaction/verify/' + ref,
            headers={'Authorization': 'Bearer ' + PAYSTACK_SECRET},
        )

    data = response.json()

    if data.get('status') and data['data']['status'] == 'success':
        amount = data['data']['amount'] / 100
        # TODO: Verify amount against database, mark order as paid
        return HTMLResponse(
            'Payment successful! Amount: ' + str(amount) + ' ' + data['data']['currency']
        )

    return HTMLResponse('Payment not successful', status_code=400)

@app.get('/api/verify', response_model=VerifyResponse)
async def verify_payment(reference: str):
    async with httpx.AsyncClient() as client:
        response = await client.get(
            'https://api.paystack.co/transaction/verify/' + reference,
            headers={'Authorization': 'Bearer ' + PAYSTACK_SECRET},
        )

    data = response.json()

    if data.get('status') and data['data']['status'] == 'success':
        return VerifyResponse(
            success=True,
            amount=data['data']['amount'] / 100,
            currency=data['data']['currency'],
            email=data['data']['customer']['email'],
        )

    return VerifyResponse(success=False)

1. Use httpx connection pooling. Create a single AsyncClient instance and reuse it across requests instead of creating a new one per request.
2. Add CORS middleware. Use FastAPI's CORSMiddleware to allow requests from your frontend domain.
3. Set up webhooks. See Handle Paystack Webhooks in FastAPI.
4. Use HTTPS. Required for callback and webhook URLs in production.
5. Validate amounts. Look up the price from your database. Never trust client-submitted amounts.

This guide is part of the Paystack integration guides by language and framework series.

Sign up for the McTaba newsletter