Hoppa till huvudinnehåll

GitHub Repository

Komplett FastAPI + Dodo Payments-mall

​
Översikt

FastAPI-mallen ger en produktionsklar startpunkt för att integrera Dodo Payments med din Python-backend. Denna mall inkluderar hantering av kassa-sessioner, verifiering av webhook, integration av kundportal och asynkrona API-mönster för att hjälpa dig att börja ta emot betalningar snabbt.
Denna mall använder FastAPI med asynkron/await-mönster, Pydantic för validering och dodopayments Python SDK för sömlös API-integration.

​
Funktioner

  • Snabb installation - Kom igång på mindre än 5 minuter
  • Asynkront stöd - Byggd med FastAPIs inbyggda asynkron/await-mönster
  • Kassa-sessioner - Förkonfigurerad kassa-flöde med Python SDK
  • Webhook-hantering - Säker webhook-slutpunkt med signaturverifiering
  • Kundportal - Enkel skapelse av kundportal-sessioner
  • Typ-säkerhet - Full Pydantic-validering och typ-hints
  • Miljökonfiguration - Klar att använda miljövariabelinställning

​
Förutsättningar

Innan du börjar, se till att du har:
  • Python 3.9+ (rekommenderat: Python 3.11+)
  • pip eller uv för paketförvaltning
  • Dodo Payments-konto (för att få tillgång till API- och Webhook-nycklar från instrumentpanelen)

​
Snabbstart

1

Klona Repositoriet

git clone https://github.com/dodopayments/fastapi-boilerplate.git
cd fastapi-boilerplate
2

Skapa Virtuell Miljö

Ställ in en isolerad Python-miljö:
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
Eller använd uv för snabbare hantering av beroenden:
uv venv
source .venv/bin/activate
3

Installera Beroenden

pip install -r requirements.txt
Eller med uv:
uv pip install -r requirements.txt
4

Få API-uppgifter

Registrera dig på Dodo Payments och få dina uppgifter från instrumentpanelen:
Se till att du är i Testläge medan du utvecklar!
5

Konfigurera Miljövariabler

Skapa en .env fil i rotkatalogen:
cp .env.example .env
Uppdatera värdena med dina Dodo Payments-uppgifter:
.env
DODO_PAYMENTS_API_KEY=your_api_key_here
DODO_PAYMENTS_WEBHOOK_KEY=your_webhook_signing_key_here
DODO_PAYMENTS_ENVIRONMENT=test_mode
Kom ihåg att aldrig begå din .env fil till versionskontroll. Den är redan inkluderad i .gitignore.
6

Kör Utvecklingsservern

uvicorn main:app --reload
Öppna http://localhost:8000/docs för att se den interaktiva API-dokumentationen!
Du bör se FastAPIs Swagger UI med alla tillgängliga slutpunkter redo att testas.

​
Projektstruktur

fastapi-boilerplate/
├── main.py                 # FastAPI application entry point
├── routers/
│   ├── checkout.py         # Checkout session endpoints
│   ├── webhook.py          # Webhook handler endpoint
│   └── customer_portal.py  # Customer portal endpoints
├── config.py               # Environment configuration
├── requirements.txt        # Python dependencies
├── .env.example            # Environment template
└── README.md

​
API-slutpunkter

Mallen inkluderar följande förkonfigurerade slutpunkter:
SlutpunktMetodBeskrivning
/checkoutPOSTSkapa en ny kassa-session
/webhookPOSTHantera Dodo Payments-webhooks
/customer-portalPOSTGenerera kundportal-URL

​
Kodexempel

​
Skapa en Kassa-session

from fastapi import APIRouter, HTTPException
from dodopayments import AsyncDodoPayments
from pydantic import BaseModel
from config import settings

router = APIRouter()
dodo = AsyncDodoPayments(
    bearer_token=settings.DODO_PAYMENTS_API_KEY,
    environment=settings.DODO_PAYMENTS_ENVIRONMENT
)

class CheckoutRequest(BaseModel):
    product_id: str
    quantity: int = 1
    customer_email: str | None = None
    customer_name: str | None = None

@router.post("/checkout")
async def create_checkout(request: CheckoutRequest):
    try:
        session = await dodo.checkout_sessions.create(
            product_cart=[{
                "product_id": request.product_id,
                "quantity": request.quantity
            }],
            customer={
                "email": request.customer_email,
                "name": request.customer_name
            } if request.customer_email else None,
            return_url="http://localhost:8000/success"
        )
        return {"checkout_url": session.url, "session_id": session.session_id}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

​
Hantera Webhooks

from fastapi import APIRouter, Request, HTTPException
import hmac
import hashlib
from config import settings

router = APIRouter()

def verify_webhook_signature(payload: bytes, signature: str) -> bool:
    expected = hmac.new(
        settings.DODO_PAYMENTS_WEBHOOK_KEY.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

@router.post("/webhook")
async def handle_webhook(request: Request):
    payload = await request.body()
    signature = request.headers.get("webhook-signature", "")
    
    if not verify_webhook_signature(payload, signature):
        raise HTTPException(status_code=401, detail="Invalid signature")
    
    event = await request.json()
    event_type = event.get("type")
    
    match event_type:
        case "payment.succeeded":
            # Handle successful payment
            payment_id = event["data"]["payment_id"]
            print(f"Payment succeeded: {payment_id}")
            
        case "subscription.active":
            # Handle subscription activation
            subscription_id = event["data"]["subscription_id"]
            print(f"Subscription activated: {subscription_id}")
            
        case "refund.succeeded":
            # Handle refund
            refund_id = event["data"]["refund_id"]
            print(f"Refund processed: {refund_id}")
    
    return {"status": "received"}

​
Integration av Kundportal

from fastapi import APIRouter, HTTPException
from dodopayments import AsyncDodoPayments
from pydantic import BaseModel
from config import settings

router = APIRouter()
dodo = AsyncDodoPayments(
    bearer_token=settings.DODO_PAYMENTS_API_KEY,
    environment=settings.DODO_PAYMENTS_ENVIRONMENT
)

class PortalRequest(BaseModel):
    customer_id: str

@router.post("/customer-portal")
async def create_portal_session(request: PortalRequest):
    try:
        session = await dodo.customers.create_customer_portal(
            customer_id=request.customer_id
        )
        return {"portal_url": session.url}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

​
Webhook-händelser

Mallen demonstrerar hantering av vanliga webhook-händelser:
HändelseBeskrivning
payment.succeededBetalning genomförd framgångsrikt
payment.failedBetalningsförsök misslyckades
subscription.activePrenumeration är nu aktiv
subscription.cancelledPrenumeration avbröts
refund.succeededÅterbetalning genomförd framgångsrikt
Lägg till din affärslogik inuti webhook-hanteraren för att:
  • Uppdatera användarbehörigheter i din databas
  • Skicka bekräftelsemail
  • Tillhandahålla åtkomst till digitala produkter
  • Spåra analyser och mätvärden

​
Testa Webhooks Lokalt

För lokal utveckling, använd verktyg som ngrok för att exponera din lokala server: 
ngrok http 8000
Uppdatera webhook-URL:en i din Dodo Payments Dashboard: 
https://your-ngrok-url.ngrok.io/webhook

​
Distribution

​
Docker

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
Bygg och kör: 
docker build -t fastapi-dodo .
docker run -p 8000:8000 --env-file .env fastapi-dodo

​
Produktionsöverväganden

Innan du distribuerar till produktion:
  • Byt DODO_PAYMENTS_ENVIRONMENT till live_mode
  • Använd produktions-API-nycklar från instrumentpanelen
  • Uppdatera webhook-URL:en till din produktionsdomän
  • Aktivera HTTPS för alla slutpunkter

​
Felsökning

Se till att din virtuella miljö är aktiverad och att beroenden är installerade:
source venv/bin/activate
pip install -r requirements.txt
Vanliga orsaker:
  • Ogiltigt produkt-ID - verifiera att det finns i din Dodo-instrumentpanel
  • Fel API-nyckel eller miljöinställning i .env
  • Kontrollera FastAPI-loggarna för detaljerade felmeddelanden
För lokal testning, använd ngrok för att exponera din server:
ngrok http 8000
Uppdatera webhook-URL:en i din Dodo-instrumentpanel till ngrok-URL:en. Se till att uppdatera din .env fil med den korrekta webhook-verifieringsnyckeln.
  • Se till att DODO_PAYMENTS_WEBHOOK_KEY är korrekt inställd i din .env
  • Verifiera att du använder den råa begärningskroppen för signaturverifiering
  • Kontrollera att du läser webhook-signature headern korrekt

​
Lär dig mer

Python SDK

Komplett Python SDK-dokumentation med asynkront stöd

Webhook-dokumentation

Lär dig om alla webhook-händelser och bästa praxis

Kassa-sessioner

Dyk djupt in i konfigurationen av kassa-sessioner

API-referens

Komplett Dodo Payments API-dokumentation

​
Support

Behöver du hjälp med mallen?