> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Python
> Integrieren Sie Dodo Payments in Ihre Python-Anwendungen mit einer pythonischen Schnittstelle und modernem async/await-Support
Das Python SDK bietet eine pythonische Schnittstelle zur Dodo Payments API und stellt sowohl synchrone als auch asynchrone Clients mit Typdefinitionen für Anfragen und Antworten bereit. Es unterstützt Python 3.9+ und umfasst umfassende Testabdeckung.
## Installation
Installieren Sie das SDK mit pip:
```bash theme={null}
pip install dodopayments
```
Für verbesserte asynchrone Leistung mit aiohttp:
```bash theme={null}
pip install dodopayments[aiohttp]
```
Das SDK erfordert Python 3.9 oder höher. Wir empfehlen die Verwendung der aktuellsten stabilen Python-Version für das beste Erlebnis und Sicherheitsupdates.
## Schnellstart
### Synchroner Client
```python theme={null}
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)
```
### Asynchroner Client
```python theme={null}
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())
```
Speichere deine API-Schlüssel stets sicher über Umgebungsvariablen. Committe sie niemals in ein Versionskontrollsystem.
## Kernfunktionen
Sauberer, idiomatischer Python-Code, der den PEP-8-Richtlinien und Python-Konventionen folgt
Volle Unterstützung für asynchrone Operationen mit asyncio und optionaler aiohttp-Integration
Umfassende Type-Hints für bessere IDE-Unterstützung und Typüberprüfung mit mypy
Automatische Paginierung für Listenantworten mit einfacher Iteration
## Konfiguration
### Umgebungsvariablen
Konfigurieren Sie mit Umgebungsvariablen:
```bash .env theme={null}
DODO_PAYMENTS_API_KEY=your_api_key_here
```
### Zeitüberschreitungen
Konfigurieren Sie die Zeitüberschreitungen für Anfragen global oder pro Anfrage:
```python theme={null}
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,
}
],
)
```
### Wiederholungen
Konfigurieren Sie das automatische Wiederholungsverhalten:
```python theme={null}
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,
}
],
)
```
## Häufige Operationen
### Erstellen einer Checkout-Sitzung
Generieren Sie eine Checkout-Sitzung:
```python theme={null}
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}")
```
### Kunden verwalten
Erstellen und Abrufen von Kundeninformationen:
```python theme={null}
# 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})")
```
### Abonnements verwalten
Erstellen und Verwalten von wiederkehrenden Abonnements:
```python theme={null}
# 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` erfordert mindestens den zweistelligen ISO-Ländercode. `customer` akzeptiert entweder `{"customer_id": ...}`, um einen vorhandenen Kunden anzuhängen oder `{"email": ..., "name": ...}`, um einen neuen zu erstellen. `product_price` ist in der niedrigsten Währungsdenomination.
## Nutzungsbasierte Abrechnung
### Verarbeitungsereignisse einlesen
Benutzerdefinierte Ereignisse für die nutzungsbasierte Abrechnung verfolgen:
```python theme={null}
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"
}
}
]
)
```
### Ereignisse auflisten und abrufen
```python theme={null}
# 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}")
```
## Paginierung
### Auto-Paginierung
Automatisch durch alle Elemente iterieren:
```python theme={null}
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)
```
### Asynchrone Paginierung
```python theme={null}
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())
```
### Manuelle Paginierung
Für mehr Kontrolle über die Paginierung:
```python theme={null}
# 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")
```
## HTTP-Client-Konfiguration
Den zugrunde liegenden `httpx`-Client anpassen:
```python theme={null}
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 mit aiohttp
aiohttp für verbesserte asynchrone Leistung verwenden:
```python theme={null}
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())
```
## Protokollierung
Protokollierung aktivieren, indem die Umgebungsvariable festgelegt wird:
```bash theme={null}
export DODO_PAYMENTS_LOG=info
```
Oder für Debug-Level-Protokollierung:
```bash theme={null}
export DODO_PAYMENTS_LOG=debug
```
## Framework-Integration
### FastAPI
```python theme={null}
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
```python theme={null}
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)
```
## Ressourcen
Quellcode ansehen und beitragen
Vollständige API-Dokumentation
Hilfe erhalten und mit Entwicklern verbinden
Fehler melden oder Funktionen anfordern
## Unterstützung
Brauchen Sie Hilfe mit dem Python SDK?
* **Discord**: Treten Sie unserem [Community-Server](https://discord.gg/bYqAp4ayYh) für Unterstützung in Echtzeit bei
* **Email**: Kontaktieren Sie uns unter [support@dodopayments.com](mailto:support@dodopayments.com)
* **GitHub**: Öffnen Sie ein Issue auf dem [Repository](https://github.com/dodopayments/dodopayments-python)
## Mitarbeit
Wir freuen uns über Beiträge! Lesen Sie die [Richtlinien für Beiträge](https://github.com/dodopayments/dodopayments-python/blob/main/CONTRIBUTING.md), um loszulegen.