> ## 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.

# FastAPI Boilerplate

> अपने Python बैकएंड अनुप्रयोगों में Dodo Payments को एकीकृत करने के लिए हमारे FastAPI बॉयलरप्लेट के साथ जल्दी शुरू करें

<Card title="GitHub Repository" icon="github" href="https://github.com/dodopayments/fastapi-boilerplate">
  FastAPI + Dodo Payments बायलरप्लेट पूरा करें
</Card>

## अवलोकन

FastAPI बॉयलरप्लेट Dodo Payments को आपके Python बैकएंड के साथ एकीकृत करने के लिए एक उत्पादन-तैयार प्रारंभिक बिंदु प्रदान करता है। इस टेम्पलेट में चेकआउट सत्र प्रबंधन, वेबहुक सत्यापन, ग्राहक पोर्टल एकीकरण, और भुगतान स्वीकार करने में तेजी लाने के लिए असिंक्रोनस API पैटर्न शामिल हैं।

<Info>
  यह बायलरप्लेट FastAPI को async/await पैटर्न के साथ, वैलिडेशन के लिए Pydantic, और सहज API इंटीग्रेशन के लिए `dodopayments` Python SDK का उपयोग करता है।
</Info>

### विशेषताएँ

* **त्वरित सेटअप** - 5 मिनट से कम समय में शुरू करें
* **असिंक्रोनस समर्थन** - FastAPI के मूल async/await पैटर्न के साथ बनाया गया
* **चेकआउट सत्र** - Python SDK का उपयोग करके पूर्व-निर्धारित चेकआउट प्रवाह
* **वेबहुक प्रबंधन** - हस्ताक्षर सत्यापन के साथ सुरक्षित वेबहुक एंडपॉइंट
* **ग्राहक पोर्टल** - आसान ग्राहक पोर्टल सत्र निर्माण
* **प्रकार सुरक्षा** - पूर्ण Pydantic मान्यता और प्रकार संकेत
* **पर्यावरण कॉन्फ़िगरेशन** - उपयोग के लिए तैयार पर्यावरण चर सेटअप

## पूर्वापेक्षाएँ

शुरू करने से पहले, सुनिश्चित करें कि आपके पास है:

* **Python 3.9+** (अनुशंसित: Python 3.11+)
* **pip** या **uv** पैकेज प्रबंधन के लिए
* **Dodo Payments खाता** (API और वेबहुक कुंजी तक पहुँचने के लिए डैशबोर्ड से)

## त्वरित प्रारंभ

<Steps>
  <Step title="Clone the Repository">
    ```bash theme={null}
    git clone https://github.com/dodopayments/fastapi-boilerplate.git
    cd fastapi-boilerplate
    ```
  </Step>

  <Step title="Create Virtual Environment">
    एक अलग Python वातावरण सेट अप करें:

    ```bash theme={null}
    python -m venv venv
    source venv/bin/activate  # On Windows: venv\Scripts\activate
    ```

    या तेज़ निर्भरता प्रबंधन के लिए uv का उपयोग करें:

    ```bash theme={null}
    uv venv
    source .venv/bin/activate
    ```
  </Step>

  <Step title="Install Dependencies">
    ```bash theme={null}
    pip install -r requirements.txt
    ```

    या uv के साथ:

    ```bash theme={null}
    uv pip install -r requirements.txt
    ```
  </Step>

  <Step title="Get API Credentials">
    [Dodo Payments](https://dodopayments.com/) पर साइन अप करें और डैशबोर्ड से अपने प्रमाणपत्र प्राप्त करें:

    * **API कुंजी:** [डैशबोर्ड → डेवलपर → API कुंजी](https://app.dodopayments.com/developer/api-keys)
    * **वेबहुक कुंजी:** [डैशबोर्ड → डेवलपर → वेबहुक](https://app.dodopayments.com/developer/webhooks)

    <Tip>
      डेवलप करते समय सुनिश्चित करें कि आप **टेस्ट मोड** में हैं!
    </Tip>
  </Step>

  <Step title="Configure Environment Variables">
    रूट डायरेक्टरी में `.env` फ़ाइल बनाएँ:

    ```bash theme={null}
    cp .env.example .env
    ```

    अपने Dodo Payments क्रेडेंशियल के साथ मान अपडेट करें:

    ```bash .env theme={null}
    DODO_PAYMENTS_API_KEY=your_api_key_here
    DODO_PAYMENTS_WEBHOOK_KEY=your_webhook_signing_key_here
    DODO_PAYMENTS_ENVIRONMENT=test_mode
    ```

    <Warning>
      अपनी `.env` फ़ाइल को संस्करण नियंत्रण में कभी कमिट न करें। यह पहले से ही `.gitignore` में शामिल है।
    </Warning>
  </Step>

  <Step title="Run the Development Server">
    ```bash theme={null}
    uvicorn main:app --reload
    ```

    इंटरैक्टिव API दस्तावेज़ देखने के लिए [http://localhost:8000/docs](http://localhost:8000/docs) खोलें!

    <Check>
      आपको FastAPI का Swagger UI दिखाई देना चाहिए जिसमें सभी उपलब्ध एंडपॉइंट्स परीक्षण के लिए तैयार हों।
    </Check>
  </Step>
</Steps>

## परियोजना संरचना

```text theme={null}
fastapi-boilerplate/
├── main.py                 # FastAPI application entry point
├── routers/
│   ├── checkout.py         # Checkout session endpoints
│   ├── webhook.py          # Webhook handler endpoint
│   └── customer_portal.py  # Customer portal endpoints
├── config.py               # Environment configuration
├── requirements.txt        # Python dependencies
├── .env.example            # Environment template
└── README.md
```

## API एंडपॉइंट्स

बॉयलरप्लेट में निम्नलिखित पूर्व-निर्धारित एंडपॉइंट शामिल हैं:

| एंडपॉइंट           | मेथड | विवरण                             |
| ------------------ | ---- | --------------------------------- |
| `/checkout`        | POST | एक नया चेकआउट सेशन बनाएं          |
| `/webhook`         | POST | Dodo Payments वेबहुक्स को संभालें |
| `/customer-portal` | POST | ग्राहक पोर्टल यूआरएल उत्पन्न करें |

## कोड उदाहरण

### चेकआउट सत्र बनाना

```python theme={null}
from fastapi import APIRouter, HTTPException
from dodopayments import AsyncDodoPayments
from pydantic import BaseModel
from config import settings

router = APIRouter()
dodo = AsyncDodoPayments(
    bearer_token=settings.DODO_PAYMENTS_API_KEY,
    environment=settings.DODO_PAYMENTS_ENVIRONMENT
)

class CheckoutRequest(BaseModel):
    product_id: str
    quantity: int = 1
    customer_email: str | None = None
    customer_name: str | None = None

@router.post("/checkout")
async def create_checkout(request: CheckoutRequest):
    try:
        session = await dodo.checkout_sessions.create(
            product_cart=[{
                "product_id": request.product_id,
                "quantity": request.quantity
            }],
            customer={
                "email": request.customer_email,
                "name": request.customer_name
            } if request.customer_email else None,
            return_url="http://localhost:8000/success"
        )
        return {"checkout_url": session.checkout_url, "session_id": session.session_id}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))
```

### वेबहुक को संभालना

```python theme={null}
from fastapi import APIRouter, Request, HTTPException
import hmac
import hashlib
from config import settings

router = APIRouter()

def verify_webhook_signature(payload: bytes, signature: str) -> bool:
    expected = hmac.new(
        settings.DODO_PAYMENTS_WEBHOOK_KEY.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

@router.post("/webhook")
async def handle_webhook(request: Request):
    payload = await request.body()
    signature = request.headers.get("webhook-signature", "")
    
    if not verify_webhook_signature(payload, signature):
        raise HTTPException(status_code=401, detail="Invalid signature")
    
    event = await request.json()
    event_type = event.get("type")
    
    match event_type:
        case "payment.succeeded":
            # Handle successful payment
            payment_id = event["data"]["payment_id"]
            print(f"Payment succeeded: {payment_id}")
            
        case "subscription.active":
            # Handle subscription activation
            subscription_id = event["data"]["subscription_id"]
            print(f"Subscription activated: {subscription_id}")
            
        case "refund.succeeded":
            # Handle refund
            refund_id = event["data"]["refund_id"]
            print(f"Refund processed: {refund_id}")
    
    return {"status": "received"}
```

### ग्राहक पोर्टल एकीकरण

```python theme={null}
from fastapi import APIRouter, HTTPException
from dodopayments import AsyncDodoPayments
from pydantic import BaseModel
from config import settings

router = APIRouter()
dodo = AsyncDodoPayments(
    bearer_token=settings.DODO_PAYMENTS_API_KEY,
    environment=settings.DODO_PAYMENTS_ENVIRONMENT
)

class PortalRequest(BaseModel):
    customer_id: str

@router.post("/customer-portal")
async def create_portal_session(request: PortalRequest):
    try:
        session = await dodo.customers.customer_portal.create(
            customer_id=request.customer_id,
        )
        return {"portal_url": session.link}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))
```

## वेबहुक घटनाएँ

बॉयलरप्लेट सामान्य वेबहुक घटनाओं को संभालने का प्रदर्शन करता है:

| ईवेंट                    | विवरण                              |
| ------------------------ | ---------------------------------- |
| `payment.succeeded`      | भुगतान सफलतापूर्वक पूरा हुआ        |
| `payment.failed`         | भुगतान प्रयास असफल रहा             |
| `subscription.active`    | सदस्यता अब सक्रिय है               |
| `subscription.cancelled` | सदस्यता रद्द कर दी गई थी           |
| `refund.succeeded`       | रिफंड सफलतापूर्वक संसाधित किया गया |

अपने व्यवसाय की लॉजिक को वेबहुक हैंडलर के अंदर जोड़ें:

* अपने डेटाबेस में उपयोगकर्ता अनुमतियों को अपडेट करें
* पुष्टि ईमेल भेजें
* डिजिटल उत्पादों तक पहुँच प्रदान करें
* विश्लेषण और मैट्रिक्स को ट्रैक करें

## स्थानीय रूप से वेबहुक का परीक्षण करना

स्थानीय विकास के लिए, अपने स्थानीय सर्वर को उजागर करने के लिए [ngrok](https://ngrok.com/) जैसे उपकरणों का उपयोग करें:

```bash theme={null}
ngrok http 8000
```

अपने [Dodo Payments डैशबोर्ड](https://app.dodopayments.com/developer/webhooks) में वेबहुक URL अपडेट करें:

```
https://your-ngrok-url.ngrok.io/webhook
```

## तैनाती

### डॉकर

```dockerfile theme={null}
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
```

बनाएँ और चलाएँ:

```bash theme={null}
docker build -t fastapi-dodo .
docker run -p 8000:8000 --env-file .env fastapi-dodo
```

### उत्पादन विचार

<Warning>
  प्रोडक्शन में डिप्लॉय करने से पहले:

  * `DODO_PAYMENTS_ENVIRONMENT` को `live_mode` में बदलें
  * डैशबोर्ड से प्रोडक्शन API कुंजियाँ उपयोग करें
  * वेबहुक URL को अपने प्रोडक्शन डोमेन में अपडेट करें
  * सभी एंडपॉइंट्स के लिए HTTPS सक्षम करें
</Warning>

## समस्या निवारण

<AccordionGroup>
  <Accordion title="Import errors or missing modules">
    सुनिश्चित करें कि आपका वर्चुअल वातावरण सक्रिय है और निर्भरताएँ इंस्टॉल की गई हैं:

    ```bash theme={null}
    source venv/bin/activate
    pip install -r requirements.txt
    ```
  </Accordion>

  <Accordion title="Checkout session creation fails">
    **सामान्य कारण:**

    * अवैध उत्पाद आईडी - जांचें कि यह आपके Dodo डैशबोर्ड में मौजूद है
    * `.env` में गलत API कुंजी या परिवेश सेटिंग
    * विस्तृत त्रुटि संदेशों के लिए FastAPI लॉग्स जांचें
  </Accordion>

  <Accordion title="Webhooks not receiving events">
    लोकल परीक्षण के लिए, अपने सर्वर को एक्सपोज़ करने के लिए [ngrok](https://ngrok.com) का उपयोग करें:

    ```bash theme={null}
    ngrok http 8000
    ```

    अपने [Dodo डैशबोर्ड](https://app.dodopayments.com/developer/webhooks) में वेबहुक URL को ngrok URL में अपडेट करें। सुनिश्चित करें कि आपने `.env` फ़ाइल को सही वेबहुक वेरिफिकेशन कुंजी के साथ अपडेट किया है।
  </Accordion>

  <Accordion title="Webhook signature verification fails">
    * सुनिश्चित करें कि `DODO_PAYMENTS_WEBHOOK_KEY` आपके `.env` में ठीक से सेट है
    * सत्यापित करें कि आप हस्ताक्षर सत्यापन के लिए रॉ रिक्वेस्ट बॉडी का उपयोग कर रहे हैं
    * जांचें कि आप `webhook-signature` हेडर को सही तरीके से पढ़ रहे हैं
  </Accordion>
</AccordionGroup>

## अधिक जानें

<CardGroup cols={2}>
  <Card title="Python SDK" icon="python" href="/developer-resources/sdks/python">
    Async सपोर्ट के साथ पूर्ण Python SDK दस्तावेज़ीकरण
  </Card>

  <Card title="Webhooks Documentation" icon="webhook" href="/developer-resources/webhooks">
    सभी वेबहुक ईवेंट्स और सर्वोत्तम प्रथाओं के बारे में जानें
  </Card>

  <Card title="Checkout Sessions" icon="credit-card" href="/developer-resources/checkout-session">
    चेकआउट सेशन कॉन्फ़िगरेशन में गहराई से जाएं
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Dodo Payments API दस्तावेज़ीकरण पूरा करें
  </Card>
</CardGroup>

## समर्थन

बॉयलरप्लेट के साथ मदद चाहिए?

* प्रश्नों और चर्चाओं के लिए हमारे [Discord समुदाय](https://discord.gg/bYqAp4ayYh) में शामिल हों
* मुद्दों और अपडेट के लिए [GitHub रिपॉजिटरी](https://github.com/dodopayments/fastapi-boilerplate) की जाँच करें
* सहायता के लिए हमारी [समर्थन टीम](mailto:support@dodopayments.com) से संपर्क करें