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

# Go Boilerplate

> Starten Sie schnell mit unserem minimalen Go-Boilerplate zur Integration von Dodo Payments in Ihre Go-Backend-Anwendungen

<Card title="GitHub Repository" icon="github" href="https://github.com/dodopayments/go-boilerplate">
  Minimaler Go- + Dodo Payments-Boilerplate
</Card>

## Übersicht

Das Go-Boilerplate bietet einen produktionsbereiten Ausgangspunkt für die Integration von Dodo Payments in Ihr Go-Backend. Diese Vorlage umfasst die Handhabung von Checkout-Sitzungen, die Überprüfung von Webhooks, die Integration des Kundenportals und folgt den besten Praktiken von Go, um Ihnen zu helfen, schnell Zahlungen zu akzeptieren.

<Info>
  Dieses Boilerplate verwendet Go 1.21+ mit Clean-Architecture-Mustern (`cmd`, `internal`, `templates`), HTML-Vorlagen und das `dodopayments-go` SDK für eine nahtlose API-Integration.
</Info>

### Funktionen

* **Quick Setup** – Schnellstart in unter 5 Minuten
* **Payment Integration** – Vorgefertigter Checkout-Flow mit dem `dodopayments-go` SDK
* **Modern UI** – Saubere, dunkel gestaltete Preisübersichtsseite mit HTML-Vorlagen
* **Webhook Handling** – Zahlungsereignisse sicher prüfen und verarbeiten
* **Customer Portal** – Selbstständige Abo-Verwaltung
* **Go Best Practices** – Saubere Architektur mit `cmd`, `internal` und `templates`
* **Pre-filled Checkout** – Zeigt, wie Kundendaten zur Verbesserung der UX übergeben werden

## Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

* **Go 1.21+**
* **Dodo Payments-Konto** (um API- und Webhook-Keys vom Dashboard abzurufen)

## Schnellstart

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

  <Step title="Install Dependencies">
    ```bash theme={null}
    make install
    ```

    Oder manuell:

    ```bash theme={null}
    go mod download
    ```
  </Step>

  <Step title="Get API Credentials">
    Melden Sie sich bei [Dodo Payments](https://dodopayments.com/) an und holen Sie sich Ihre Zugangsdaten aus dem Dashboard:

    * **API-Schlüssel:** [Dashboard → Entwickler → API-Schlüssel](https://app.dodopayments.com/developer/api-keys)
    * **Webhook-Schlüssel:** [Dashboard → Entwickler → Webhooks](https://app.dodopayments.com/developer/webhooks)

    <Tip>
      Stellen Sie sicher, dass Sie sich während der Entwicklung im **Testmodus** befinden!
    </Tip>
  </Step>

  <Step title="Configure Environment Variables">
    Erstellen Sie eine `.env`-Datei im Stammverzeichnis:

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

    Aktualisieren Sie die Werte mit Ihren Dodo Payments-Anmeldeinformationen:

    ```bash .env theme={null}
    DODO_PAYMENTS_API_KEY=your_api_key_here
    DODO_PAYMENTS_WEBHOOK_KEY=your_webhook_signing_key_here
    DODO_PAYMENTS_RETURN_URL=http://localhost:8000
    DODO_PAYMENTS_ENVIRONMENT=test_mode
    ```

    <Warning>
      Committen Sie Ihre `.env`-Datei niemals in die Versionskontrolle. Sie ist bereits in `.gitignore` enthalten.
    </Warning>
  </Step>

  <Step title="Add Your Products">
    Aktualisieren Sie `internal/lib/products.go` mit Ihren tatsächlichen Produkt-IDs von Dodo Payments:

    ```go theme={null}
    var Products = []Product{
        {
            ProductID:   "pdt_001", // Replace with your product ID
            Name:        "Basic Plan",
            Description: "Get access to basic features and support",
            Price:       9999, // in cents
            Features: []string{
                "Access to basic features",
                "Email support",
                "1 Team member",
                "Basic analytics",
            },
        },
        // ... add more products
    }
    ```
  </Step>

  <Step title="Run the Development Server">
    ```bash theme={null}
    make run
    ```

    Oder manuell:

    ```bash theme={null}
    go run cmd/server/main.go
    ```

    Öffnen Sie [http://localhost:8000](http://localhost:8000), um Ihre Preisgestaltungseite zu sehen!

    <Check>
      Sie sollten eine dunkel gestaltete Preisübersichtsseite sehen, auf der Ihre Produkte zum Kauf bereitstehen.
    </Check>
  </Step>
</Steps>

## Projektstruktur

```text theme={null}
go-boilerplate/
├── cmd/
│   └── server/             # Application entry point
├── internal/
│   ├── api/                # API handlers (Checkout, Portal, Webhook)
│   ├── core/               # Configuration and system core
│   └── lib/                # Shared logic (Products, Customer utils)
├── templates/              # HTML templates
├── Makefile                # Build and run commands
├── go.mod                  # Go module definition
├── go.sum                  # Dependency checksums
├── .env.example            # Environment template
└── README.md
```

## API-Endpunkte

Das Boilerplate umfasst die folgenden vorkonfigurierten Endpunkte:

| Endpunkt               | Methode | Beschreibung                               |
| ---------------------- | ------- | ------------------------------------------ |
| `/`                    | GET     | Preisübersichtsseite mit Produktauflistung |
| `/api/checkout`        | POST    | Erstellen Sie eine neue Checkout-Sitzung   |
| `/api/webhook`         | POST    | Verarbeiten Sie Dodo Payments Webhooks     |
| `/api/customer-portal` | POST    | Generieren Sie eine Kundenportal-URL       |

## Anpassung

### Produktinformationen aktualisieren

Bearbeiten Sie `internal/lib/products.go`, um folgende Punkte anzupassen:

* Produkt-IDs (aus Ihrem Dodo-Dashboard)
* Preise
* Funktionen
* Beschreibungen

```go theme={null}
var Products = []Product{
    {
        ProductID:   "pdt_001", // Replace with your product ID
        Name:        "Basic Plan",
        Description: "Get access to basic features and support",
        Price:       9999,
        Features: []string{
            "Access to basic features",
            "Email support",
            "1 Team member",
            "Basic analytics",
        },
    },
}
```

### Kundendaten vorab ausfüllen

In `templates/index.html` ersetzen Sie die fest kodierten Kundendaten durch Ihre tatsächlichen Benutzerdaten:

```javascript theme={null}
const customerData = {
    name: "John Doe",       // Replace with actual logged-in user's name
    email: "john@example.com"  // Replace with actual logged-in user's email
};
```

In einer Produktionsanwendung würden Sie diese Werte dynamisch aus Ihrem Authentifizierungssystem einfügen.

## Webhook-Ereignisse

Das Boilerplate zeigt die Verarbeitung von Webhook-Ereignissen in `internal/api/webhook.go`. Unterstützte Ereignisse sind:

| Ereignis              | Beschreibung                                      |
| --------------------- | ------------------------------------------------- |
| `subscription.active` | Wird ausgelöst, wenn ein Abonnement aktiv wird    |
| `payment.succeeded`   | Wird ausgelöst, wenn eine Zahlung erfolgreich ist |

Fügen Sie Ihre Geschäftslogik innerhalb des Webhook-Handlers hinzu, um:

* Benutzerberechtigungen in Ihrer Datenbank zu aktualisieren
* Bestätigungs-E-Mails zu senden
* Zugriff auf digitale Produkte bereitzustellen
* Analysen und Metriken zu verfolgen

## Webhooks lokal testen

Für die lokale Entwicklung verwenden Sie Tools wie [ngrok](https://ngrok.com/), um Ihren lokalen Server freizugeben:

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

Aktualisieren Sie die Webhook-URL in Ihrem [Dodo Payments Dashboard](https://app.dodopayments.com/developer/webhooks):

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

## Bereitstellung

### Für die Produktion bauen

```bash theme={null}
make build
```

Oder manuell:

```bash theme={null}
go build -o bin/server cmd/server/main.go
./bin/server
```

### Auf Vercel bereitstellen

\[

![Mit Vercel bereitstellen](https://vercel.com/button)

]\([https://vercel.com/new/clone?repository-url=https://github.com/dodopayments/go-boilerplate](https://vercel.com/new/clone?repository-url=https://github.com/dodopayments/go-boilerplate))

### Docker

Erstellen Sie eine `Dockerfile`:

```dockerfile theme={null}
FROM golang:1.21-alpine AS builder

WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN go build -o bin/server cmd/server/main.go

FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/bin/server .
COPY --from=builder /app/templates ./templates

EXPOSE 8000
CMD ["./server"]
```

Bauen und ausführen:

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

### Produktionsüberlegungen

<Warning>
  Vor dem Einsatz in der Produktion:

  * Wechseln Sie `DODO_PAYMENTS_ENVIRONMENT` zu `live_mode`
  * Verwenden Sie Produktions-API-Schlüssel aus dem Dashboard
  * Aktualisieren Sie die Webhook-URL auf Ihre Produktionsdomain
  * Aktivieren Sie HTTPS für alle Endpunkte
</Warning>

## Fehlersuche

<AccordionGroup>
  <Accordion title="Build errors or missing dependencies">
    Stellen Sie sicher, dass die Go-Module ordnungsgemäß heruntergeladen sind:

    ```bash theme={null}
    go mod tidy
    go mod download
    ```
  </Accordion>

  <Accordion title="Checkout session creation fails">
    **Häufige Ursachen:**

    * Ungültige Produkt-ID – prüfen Sie, ob sie in Ihrem Dodo-Dashboard vorhanden ist
    * Falscher API-Schlüssel oder Umgebungswert in `.env`
    * Überprüfen Sie die Serverprotokolle auf detaillierte Fehlermeldungen
  </Accordion>

  <Accordion title="Webhooks not receiving events">
    Für lokale Tests verwenden Sie [ngrok](https://ngrok.com), um Ihren Server erreichbar zu machen:

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

    Aktualisieren Sie die Webhook-URL in Ihrem [Dodo-Dashboard](https://app.dodopayments.com/developer/webhooks) auf die ngrok-URL. Stellen Sie sicher, dass Sie Ihre `.env`-Datei mit dem richtigen Webhook-Verifizierungsschlüssel aktualisieren.
  </Accordion>

  <Accordion title="Templates not loading">
    Stellen Sie sicher, dass Sie den Server vom Projektstammverzeichnis aus starten oder dass der Vorlagenpfad in Ihrem Code korrekt konfiguriert ist.
  </Accordion>
</AccordionGroup>

## Erfahren Sie mehr

<CardGroup cols={2}>
  <Card title="Go SDK" icon="golang" href="/developer-resources/sdks/go">
    Komplette Go SDK-Dokumentation
  </Card>

  <Card title="Webhooks Documentation" icon="webhook" href="/developer-resources/webhooks">
    Erfahren Sie alles über Webhook-Ereignisse und bewährte Verfahren
  </Card>

  <Card title="Checkout Sessions" icon="credit-card" href="/developer-resources/checkout-session">
    Ein tiefer Einblick in die Konfiguration der Checkout-Sitzung
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Komplette Dodo Payments API-Dokumentation
  </Card>
</CardGroup>

## Unterstützung

Brauchen Sie Hilfe mit dem Boilerplate?

* Treten Sie unserer [Discord-Community](https://discord.gg/bYqAp4ayYh) für Fragen und Diskussionen bei
* Überprüfen Sie das [GitHub-Repository](https://github.com/dodopayments/go-boilerplate) auf Probleme und Updates
* Kontaktieren Sie unser [Support-Team](mailto:support@dodopayments.com) für Unterstützung