Python - Dodo Payments Documentation

Le SDK Python offre une interface Pythonique à l’API Dodo Payments, fournissant à la fois des clients synchrones et asynchrones avec des définitions de types pour les requêtes et les réponses. Il prend en charge Python 3.9+ et inclut une couverture de test complète.

Installation

Installez le SDK en utilisant pip :

pip install dodopayments

Pour des performances async améliorées avec aiohttp :

pip install dodopayments[aiohttp]

Le SDK nécessite Python 3.9 ou une version supérieure. Nous recommandons d’utiliser la dernière version stable de Python pour bénéficier de la meilleure expérience et des mises à jour de sécurité.

Démarrage rapide

Client synchrone

import os
from dodopayments import DodoPayments

client = DodoPayments(
    bearer_token=os.environ.get("DODO_PAYMENTS_API_KEY"),  # This is the default and can be omitted
    environment="test_mode",  # defaults to "live_mode"
)

checkout_session_response = client.checkout_sessions.create(
    product_cart=[
        {
            "product_id": "product_id",
            "quantity": 1
        }
    ],
)
print(checkout_session_response.session_id)

Client asynchrone

import os
import asyncio
from dodopayments import AsyncDodoPayments

client = AsyncDodoPayments(
    bearer_token=os.environ.get("DODO_PAYMENTS_API_KEY"),
    environment="test_mode",
)

async def main() -> None:
    checkout_session_response = await client.checkout_sessions.create(
        product_cart=[
            {
                "product_id": "product_id",
                "quantity": 1,
            }
        ],
    )
    print(checkout_session_response.session_id)

asyncio.run(main())

Stockez toujours vos clés d’API de manière sécurisée en utilisant des variables d’environnement. Ne les committez jamais dans le contrôle de version.

Fonctionnalités principales

Pythonic Interface

Code Python propre et idiomatique respectant les directives PEP 8 et les conventions Python

Async/Await

Prise en charge complète des opérations asynchrones avec asyncio et intégration aiohttp facultative

Type Hints

Annotations de type complètes pour une meilleure prise en charge par les IDE et la vérification de type avec mypy

Auto-Pagination

Pagination automatique des réponses listées avec une itération simple

Configuration

Variables d’environnement

Configurez en utilisant des variables d’environnement :

.env

DODO_PAYMENTS_API_KEY=your_api_key_here

Délais d’attente

Configurez les délais d’attente des requêtes globalement ou par requête :

import httpx
from dodopayments import DodoPayments

# Configure default for all requests (default is 1 minute)
client = DodoPayments(
    timeout=20.0,  # 20 seconds
)

# More granular control
client = DodoPayments(
    timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
)

# Override per-request
client.with_options(timeout=5.0).checkout_sessions.create(
    product_cart=[
        {
            "product_id": "product_id",
            "quantity": 1,
        }
    ],
)

Réessais

Configurez le comportement de réessai automatique :

from dodopayments import DodoPayments

# Configure default for all requests (default is 2)
client = DodoPayments(
    max_retries=0,  # disable retries
)

# Override per-request
client.with_options(max_retries=5).checkout_sessions.create(
    product_cart=[
        {
            "product_id": "product_id",
            "quantity": 1,
        }
    ],
)

Opérations courantes

Créer une session de paiement

Générez une session de paiement :

session = client.checkout_sessions.create(
    product_cart=[
        {
            "product_id": "prod_123",
            "quantity": 1
        }
    ],
    return_url="https://yourdomain.com/return"
)

print(f"Checkout URL: {session.checkout_url}")

Gérer les clients

Créez et récupérez des informations sur les clients :

# Create a customer
customer = client.customers.create(
    email="customer@example.com",
    name="John Doe",
    metadata={
        "user_id": "12345"
    }
)

# Retrieve customer
customer = client.customers.retrieve("cus_123")
print(f"Customer: {customer.name} ({customer.email})")

Gérer les abonnements

Créez et gérez des abonnements récurrents :

# Create a subscription
subscription = client.subscriptions.create(
    billing={
        "country": "US",
        "city": "San Francisco",
        "state": "CA",
        "street": "1 Market St",
        "zipcode": "94105",
    },
    customer={"customer_id": "cus_123"},  # or {"email": "...", "name": "..."} for a new customer
    product_id="pdt_456",
    quantity=1,
)

# Charge an on-demand subscription
# product_price is in the lowest currency denomination (e.g., 2500 = $25.00 USD)
charge_response = client.subscriptions.charge(
    subscription_id=subscription.subscription_id,
    product_price=2500,
)

# Retrieve usage history (for metered subscriptions)
usage_history = client.subscriptions.retrieve_usage_history(
    subscription_id=subscription.subscription_id,
    start_date="2024-01-01T00:00:00Z",
)

billing nécessite au minimum le code pays ISO à deux lettres. customer accepte soit {"customer_id": ...} pour attacher un client existant, soit {"email": ..., "name": ...} pour en créer un nouveau. product_price est dans la plus petite unité monétaire.

Facturation à l’usage

Intégrer les événements d’usage

Suivez des événements personnalisés pour la facturation à l’usage :

response = client.usage_events.ingest(
    events=[
        {
            "event_id": "api_call_12345",
            "customer_id": "cus_abc123",
            "event_name": "api_request",
            "timestamp": "2024-01-15T10:30:00Z",
            "metadata": {
                "endpoint": "/api/v1/users",
                "method": "GET",
                "tokens_used": "150"
            }
        }
    ]
)

Lister et récupérer les événements

# Get a specific event
event = client.usage_events.retrieve("api_call_12345")

# List events with filtering
events = client.usage_events.list(
    customer_id="cus_abc123",
    event_name="api_request",
    limit=20
)

for event in events.data:
    print(f"Event: {event.event_id} at {event.timestamp}")

Pagination

Pagination automatique

Parcourez tous les éléments automatiquement :

from dodopayments import DodoPayments

client = DodoPayments()
all_payments = []

# Automatically fetches more pages as needed
for payment in client.payments.list():
    all_payments.append(payment)
print(all_payments)

Pagination asynchrone

import asyncio
from dodopayments import AsyncDodoPayments

client = AsyncDodoPayments()

async def main() -> None:
    all_payments = []
    # Iterate through items across all pages
    async for payment in client.payments.list():
        all_payments.append(payment)
    print(all_payments)

asyncio.run(main())

Pagination manuelle

Pour plus de contrôle sur la pagination :

# Access items from current page
first_page = client.payments.list()
for payment in first_page.items:
    print(payment.brand_id)

# Check for more pages
if first_page.has_next_page():
    next_page = first_page.get_next_page()
    print(f"Fetched {len(next_page.items)} more items")

Configuration du client HTTP

Personnalisez le client httpx sous-jacent :

import httpx
from dodopayments import DodoPayments, DefaultHttpxClient

client = DodoPayments(
    base_url="http://my.test.server.example.com:8083",
    http_client=DefaultHttpxClient(
        proxy="http://my.test.proxy.example.com",
        transport=httpx.HTTPTransport(local_address="0.0.0.0"),
    ),
)

Asynchrone avec aiohttp

Utilisez aiohttp pour des performances asynchrones améliorées :

import asyncio
from dodopayments import DefaultAioHttpClient
from dodopayments import AsyncDodoPayments

async def main() -> None:
    async with AsyncDodoPayments(
        bearer_token="My Bearer Token",
        http_client=DefaultAioHttpClient(),
    ) as client:
        checkout_session_response = await client.checkout_sessions.create(
            product_cart=[
                {
                    "product_id": "product_id",
                    "quantity": 1,
                }
            ],
        )
        print(checkout_session_response.session_id)

asyncio.run(main())

Journalisation

Activez la journalisation en définissant la variable d’environnement :

export DODO_PAYMENTS_LOG=info

Ou pour une journalisation de niveau débogage :

export DODO_PAYMENTS_LOG=debug

Intégration au framework

FastAPI

from fastapi import FastAPI, HTTPException
from dodopayments import AsyncDodoPayments
from pydantic import BaseModel
import os

app = FastAPI()
dodo = AsyncDodoPayments(bearer_token=os.getenv("DODO_API_KEY"))

class CheckoutRequest(BaseModel):
    product_id: str
    quantity: int

@app.post("/create-checkout")
async def create_checkout(request: CheckoutRequest):
    try:
        session = await dodo.checkout_sessions.create(
            product_cart=[{
                "product_id": request.product_id,
                "quantity": request.quantity
            }],
            return_url="https://yourdomain.com/return"
        )
        return {"checkout_url": session.checkout_url}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

Django

from django.http import JsonResponse
from django.views.decorators.http import require_POST
from django.views.decorators.csrf import csrf_exempt
from dodopayments import DodoPayments
import os
import json

client = DodoPayments(bearer_token=os.getenv("DODO_PAYMENTS_API_KEY"))

@csrf_exempt
@require_POST
def create_checkout(request):
    try:
        data = json.loads(request.body)
        session = client.checkout_sessions.create(
            product_cart=[{
                "product_id": data.get("product_id"),
                "quantity": data.get("quantity", 1)
            }],
            return_url="https://yourdomain.com/return"
        )
        return JsonResponse({
            "status": "success",
            "checkout_url": session.checkout_url,
            "session_id": session.session_id
        })
    except Exception as e:
        return JsonResponse({
            "status": "error",
            "message": str(e)
        }, status=400)

Ressources

GitHub Repository

Voir le code source et contribuer

API Reference

Documentation complète de l’API

Discord Community

Obtenez de l’aide et connectez-vous avec les développeurs

Report Issues

Signalez des bogues ou demandez des fonctionnalités

Support

Besoin d’aide avec le SDK Python ?

Discord : Rejoignez notre serveur communautaire pour un support en temps réel
Email : Contactez-nous à support@dodopayments.com
GitHub : Ouvrez une issue sur le repository

Contribuer

Vos contributions sont les bienvenues ! Consultez les directives de contribution pour commencer.

​Installation

​Démarrage rapide

​Client synchrone

​Client asynchrone

​Fonctionnalités principales

Pythonic Interface

Async/Await

Type Hints

Auto-Pagination

​Configuration

​Variables d’environnement

​Délais d’attente

​Réessais

​Opérations courantes

​Créer une session de paiement

​Gérer les clients

​Gérer les abonnements

​Facturation à l’usage

​Intégrer les événements d’usage

​Lister et récupérer les événements

​Pagination

​Pagination automatique

​Pagination asynchrone

​Pagination manuelle

​Configuration du client HTTP

​Asynchrone avec aiohttp

​Journalisation

​Intégration au framework

​FastAPI

​Django

​Ressources

GitHub Repository

API Reference

Discord Community

Report Issues

​Support

​Contribuer

Installation

Démarrage rapide

Client synchrone

Client asynchrone

Fonctionnalités principales

Configuration

Variables d’environnement

Délais d’attente

Réessais

Opérations courantes

Créer une session de paiement

Gérer les clients

Gérer les abonnements

Facturation à l’usage

Intégrer les événements d’usage

Lister et récupérer les événements

Pagination

Pagination automatique

Pagination asynchrone

Pagination manuelle

Configuration du client HTTP

Asynchrone avec aiohttp

Journalisation

Intégration au framework

FastAPI

Django

Ressources

Support

Contribuer