Python

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": "pdt_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 :

POST /subscriptions (la méthode subscriptions.create du SDK) est obsolète. Elle fonctionne toujours pour les intégrations existantes, mais les nouvelles intégrations doivent créer des abonnements via une Checkout Session.

# 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 associer un client existant, soit {"email": ..., "name": ...} pour en créer un nouveau. product_price est exprimé dans la plus petite dénomination de la devise.

Facturation à l’usage

Ingérer des événements d’utilisation

Suivez les é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"
            }
        }
    ]
)

Répertorier 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",
    page_size=20
)

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

Pagination

Pagination automatique

Parcourez automatiquement tous les éléments :

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 mieux contrôler 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 améliorer les performances asynchrones :

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 activer la journalisation au niveau debug :

export DODO_PAYMENTS_LOG=debug

Intégration aux frameworks

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

Consultez le code source et contribuez

API Reference

Documentation complète de l’API

Discord Community

Obtenez de l’aide et échangez avec les développeurs

Report Issues

Signalez des bugs ou demandez des fonctionnalités

Assistance

Vous avez besoin d’aide avec le SDK Python ?

Discord : Rejoignez notre serveur communautaire pour bénéficier d’une assistance en temps réel
E-mail : Contactez-nous à l’adresse support@dodopayments.com
GitHub : Ouvrez un ticket dans le dépôt

Contribuer

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

Getting Started

Features

Integrate

Merchant of Record

Miscellaneous

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

Ingérer des événements d’utilisation

Répertorier et récupérer les événements

Configuration du client HTTP

Asynchrone avec aiohttp

Journalisation

Intégration aux frameworks

FastAPI

Django

Ressources

GitHub Repository

API Reference

Discord Community

Report Issues

Assistance

Contribuer

​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

​Ingérer des événements d’utilisation

​Répertorier et récupérer les événements

​Pagination

​Pagination automatique

​Pagination asynchrone

​Pagination manuelle

​Configuration du client HTTP

​Asynchrone avec aiohttp

​Journalisation

​Intégration aux frameworks

​FastAPI

​Django

​Ressources

GitHub Repository

API Reference

Discord Community

Report Issues

​Assistance

​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

Ingérer des événements d’utilisation

Répertorier et récupérer les événements

Pagination

Pagination automatique

Pagination asynchrone

Pagination manuelle

Configuration du client HTTP

Asynchrone avec aiohttp

Journalisation

Intégration aux frameworks

FastAPI

Django

Ressources

Assistance

Contribuer