Python - Dodo Payments Documentation

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.checkout_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.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)

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?

Discord: Gå med i vår community-server för support i realtid
E-post: Kontakta oss på support@dodopayments.com
GitHub: Öppna ett ärende i repositoryn

Bidra

Vi välkomnar bidrag! Kolla in riktlinjer för bidragande för att komma igång.

​Installation

​Snabbstart

​Synkron Klient

​Asynkron Klient

​Kärnfunktioner

Pythonic Interface

Async/Await

Type Hints

Auto-Pagination

​Konfiguration

​Miljövariabler

​Tidsgränser

​Återförsök

​Vanliga Operationer

​Skapa en Checkout-session

​Hantera Kunder

​Hantera Prenumerationer

​Användningsbaserad Debitering

​Registrera Användningshändelser

​Lista och Hämta Händelser

​Paginering

​Automatisk Paginering

​Asynkron Paginering

​Manuell Paginering

​HTTP Klientkonfiguration

​Asynk med aiohttp

​Loggning

​Ramverksintegration

​FastAPI

​Django

​Resurser

GitHub Repository

API Reference

Discord Community

Report Issues

​Support

​Bidra

Installation

Snabbstart

Synkron Klient

Asynkron Klient

Kärnfunktioner

Konfiguration

Miljövariabler

Tidsgränser

Återförsök

Vanliga Operationer

Skapa en Checkout-session

Hantera Kunder

Hantera Prenumerationer

Användningsbaserad Debitering

Registrera Användningshändelser

Lista och Hämta Händelser

Paginering

Automatisk Paginering

Asynkron Paginering

Manuell Paginering

HTTP Klientkonfiguration

Asynk med aiohttp

Loggning

Ramverksintegration

FastAPI

Django

Resurser

Support

Bidra