Passer au contenu principal
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.7+ 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.7 ou supérieur. Nous recommandons d’utiliser la dernière version stable de Python pour la meilleure expérience et les 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 API en toute sécurité en utilisant des variables d’environnement. Ne les engagez jamais dans le contrôle de version.

​
Fonctionnalités principales

Interface Pythonique

Code Python propre et idiomatique qui suit les directives PEP 8 et les conventions Python

Async/Await

Support complet pour les opérations asynchrones avec asyncio et intégration optionnelle d’aiohttp

Hints de type

Hints de type complets pour un meilleur support IDE et vérification de type avec mypy

Auto-Pagination

Pagination automatique pour les réponses de liste avec une simple itération

​
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": 0,
        }
    ],
)

​
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": 0,
        }
    ],
)

​
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.url}")

​
Gérer les clients

Créez et récupérez des informations sur les clients : 
# Create a customer
customer = client.customers.create(
    email="[email protected]",
    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(
    customer_id="cus_123",
    product_id="prod_456",
    price_id="price_789"
)

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

​
Facturation basée sur l’utilisation

​
Ingest Events d’utilisation

Suivez les événements personnalisés pour la facturation basée sur l’utilisation : 
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

​
Auto-Pagination

Itérez à travers 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 sous-jacent httpx : 
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"),
    ),
)

​
Async 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": 0,
                }
            ],
        )
        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 au niveau de débogage : 
export DODO_PAYMENTS_LOG=debug

​
Intégration de 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.url}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

​
Django

from django.http import JsonResponse
from dodopayments import DodoPayments
import os

dodo = DodoPayments(bearer_token=os.getenv("DODO_API_KEY"))

def create_payment(request):
    try:
        payment = dodo.payments.create(
            amount=5000,
            currency="USD",
            customer_id=request.user.customer_id
        )
        return JsonResponse({
            "status": "success",
            "payment_id": payment.id
        })
    except Exception as e:
        return JsonResponse({
            "status": "error",
            "message": str(e)
        }, status=400)

​
Ressources

Dépôt GitHub

Voir le code source et contribuer

Référence API

Documentation API complète

Communauté Discord

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

Signaler des problèmes

Signalez des bugs ou demandez des fonctionnalités

​
Support

Besoin d’aide avec le SDK Python ?

​
Contribuer

Nous accueillons les contributions ! Consultez les directives de contribution pour commencer.