Il SDK Python offre un’interfaccia Pythonica per l’API Dodo Payments, fornendo sia client sincroni che asincroni con definizioni di tipo per richieste e risposte. Supporta Python 3.7+ e include una copertura di test completa.
Installazione Installa il SDK usando pip:
Per prestazioni asincrone migliorate con aiohttp:
pip install dodopayments[aiohttp]
Il SDK richiede Python 3.7 o superiore. Ti consigliamo di utilizzare l’ultima versione stabile di Python per la migliore esperienza e aggiornamenti di sicurezza.
Avvio Veloce Client Sincrono 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 Asincrono 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())
Conserva sempre le tue chiavi API in modo sicuro utilizzando variabili d’ambiente. Non commetterle mai nel controllo di versione.
Caratteristiche Principali
Interfaccia Pythonica Codice Python pulito e idiomatico che segue le linee guida PEP 8 e le convenzioni Python
Async/Await Supporto completo per operazioni asincrone con asyncio e integrazione opzionale di aiohttp
Type Hints Completamente tipizzato per un migliore supporto IDE e controllo dei tipi con mypy
Auto-Paginazione Paginazione automatica per risposte a elenco con iterazione semplice
Configurazione Variabili d’Ambiente Configura utilizzando variabili d’ambiente:
DODO_PAYMENTS_API_KEY = your_api_key_here
Timeout Configura i timeout delle richieste globalmente o per richiesta:
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 , } ], )
Riprova Configura il comportamento di riprova automatica:
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 , } ], )
Operazioni Comuni Crea una Sessione di Checkout Genera una sessione di checkout:
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 } " )
Gestisci Clienti Crea e recupera informazioni sui clienti:
# 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 } )" )
Gestisci Abbonamenti Crea e gestisci abbonamenti ricorrenti:
# 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" )
Fatturazione Basata sull’Uso Ingestione Eventi di Utilizzo Monitora eventi personalizzati per la fatturazione basata sull’uso:
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" } } ] )
Elenca e Recupera Eventi # 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 } " )
Paginazione Auto-Paginazione Itera automaticamente attraverso tutti gli elementi:
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)
Paginazione Asincrona 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())
Paginazione Manuale Per un maggiore controllo sulla paginazione:
# 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" )
Configurazione del Client HTTP Personalizza il client sottostante 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 con aiohttp Usa aiohttp per prestazioni asincrone migliorate:
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())
Logging Abilita il logging impostando la variabile d’ambiente:
export DODO_PAYMENTS_LOG = info
O per il logging a livello di debug:
export DODO_PAYMENTS_LOG = debug
Integrazione con 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 )
Risorse Supporto Hai bisogno di aiuto con il SDK Python?
Contribuire Accogliamo con favore i contributi! Controlla le linee guida per i contributi per iniziare. 
