Hoppa till huvudinnehåll

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 SDK erbjuder ett Pythoniskt gränssnitt till Dodo Payments API, som tillhandahåller både synkrona och asynkrona klienter med typdefinitioner för förfrågningar och svar. Det stöder Python 3.9+ och inkluderar omfattande testtäckning.

​
Installation

Installera SDK:n med pip: 
pip install dodopayments
För förbättrad asynkron prestanda med aiohttp: 
pip install dodopayments[aiohttp]
SDK:en kräver Python 3.9 eller högre. Vi rekommenderar att du använder den senaste stabila versionen av Python för bästa upplevelse och säkerhetsuppdateringar.

​
Snabbstart

​
Synkron Klient

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)

​
Asynkron Klient

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())
Förvara alltid dina API-nycklar säkert med hjälp av miljövariabler. Lägg aldrig till dem i versionskontroll.

​
Kärnfunktioner

Pythonic Interface

Ren, idiomatisk Python-kod som följer PEP 8-riktlinjer och Python-konventioner

Async/Await

Fullt stöd för asynkrona operationer med asyncio och valfri aiohttp-integration

Type Hints

Kompletta typanteckningar för bättre IDE-stöd och typkontroll med mypy

Auto-Pagination

Automatisk paginering för listrespons med enkel iteration

​
Konfiguration

​
Miljövariabler

Konfigurera med hjälp av miljövariabler:
.env
DODO_PAYMENTS_API_KEY=your_api_key_here

​
Tidsgränser

Konfigurera begärningstidsgränser globalt eller per begäran: 
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,
        }
    ],
)

​
Återförsök

Konfigurera automatisk återförsöksbeteende: 
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,
        }
    ],
)

​
Vanliga Operationer

​
Skapa en Checkout-session

Generera en checkout-session: 
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}")

​
Hantera Kunder

Skapa och hämta kundinformation: 
# 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})")

​
Hantera Prenumerationer

Skapa och hantera återkommande prenumerationer: 
# 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 kräver minst den tvåbokstavskod som används för ISO-landskoder. customer accepterar antingen {"customer_id": ...} för att fästa en befintlig kund eller {"email": ..., "name": ...} för att skapa en ny. product_price är i den lägsta valutans denomination.

​
Användningsbaserad Debitering

​
Registrera Användningshändelser

Spåra anpassade händelser för användningsbaserad debitering: 
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"
            }
        }
    ]
)

​
Lista och Hämta Händelser

# 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}")

​
Paginering

​
Automatisk Paginering

Iterera igenom alla objekt automatiskt: 
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)

​
Asynkron Paginering

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())

​
Manuell Paginering

För mer kontroll över pagineringen: 
# 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 Klientkonfiguration

Anpassa den underliggande httpx klienten: 
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"),
    ),
)

​
Asynk med aiohttp

Använd aiohttp för förbättrad asynkron prestanda: 
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())

​
Loggning

Aktivera loggning genom att ställa in miljövariabeln: 
export DODO_PAYMENTS_LOG=info
Eller för loggning på debug-nivå: 
export DODO_PAYMENTS_LOG=debug

​
Ramverksintegration

​
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 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.url,
            "session_id": session.session_id
        })
    except Exception as e:
        return JsonResponse({
            "status": "error",
            "message": str(e)
        }, status=400)

​
Resurser

GitHub Repository

Visa källkod och bidra

API Reference

Fullständig API-dokumentation

Discord Community

Få hjälp och anslut med utvecklare

Report Issues

Rapportera fel eller begär funktioner

​
Support

Behöver du hjälp med Python SDK?

​
Bidra

Vi välkomnar bidrag! Kolla in riktlinjer för bidragande för att komma igång.
Last modified on May 14, 2026