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

# GoHighLevel

> Integriere Dodo Payments mit GoHighLevel (GHL) über No-Code-Zahlungslinks, Overlay-Checkout oder Inline-Checkout und automatisiere die Fulfillment-Prozesse mit Webhooks.

## Einführung

[GoHighLevel](https://www.gohighlevel.com/) (GHL) ist eine All-in-One-CRM- und Marketingplattform für Funnels, Websites, E-Mail/SMS und Automatisierung („Workflows“). GHL führt Dodo Payments nicht als integrierten Zahlungsdienstleister auf. Daher verbindest du beide Systeme je nach gewünschtem Integrationsgrad und deinen Programmierkenntnissen auf eine von drei Arten.

Bei jedem Ansatz wird das Fulfillment auf dieselbe Weise abgewickelt. Dodo sendet [Webhook-Ereignisse](/developer-resources/webhooks) an einen **Inbound Webhook Workflow** in GHL, der den Kontakt mit einem Tag versieht, Zugriff gewährt und Bestätigungen versendet.

## Wähle deinen Ansatz

| Ansatz                  | Erforderlicher Code                   | Checkout-Erlebnis                                              | Am besten geeignet für                                                        |
| ----------------------- | ------------------------------------- | -------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| **A. Payment Links**    | Keiner (No-Code)                      | Der Kunde wird zum gehosteten Checkout von Dodo weitergeleitet | Die meisten GHL-Nutzer, schnellster Start                                     |
| **B. Overlay Checkout** | Benutzerdefinierter Code plus Backend | Ein Modal wird über deiner GHL-Seite geöffnet                  | Teams, die einen Checkout auf der Seite möchten, ohne den Funnel zu verlassen |
| **C. Inline Checkout**  | Benutzerdefinierter Code plus Backend | Das Checkout-Formular ist in die Seite eingebettet             | Vollständig eingebettete, markengerechte UX                                   |

<Info>
  Neu dabei? Beginne mit **Ansatz A (Payment Links)**. Er erfordert keinen Code, funktioniert für jeden GHL-Nutzer und ist in wenigen Minuten eingerichtet. Für die Ansätze B und C wird ein Backend zum Erstellen von [Checkout-Sitzungen](/api-reference/checkout-sessions/create) benötigt. Sie richten sich an Teams, die mit Code vertraut sind.
</Info>

## Voraussetzungen

* Ein Dodo Payments-Konto mit mindestens einem erstellten **Produkt**.
* Ein GoHighLevel-Konto mit einem Funnel, einer Website oder einem Workflow.
* Zugriff auf **Settings → Webhooks** (und **Settings → Developer** für einen API-Schlüssel) in deinem Dodo-Dashboard.
* Für die Ansätze B und C: ein kleines **Backend oder serverloser Endpoint** zum Erstellen von Checkout-Sitzungen.

<Note>
  GHL benötigt eine **verbundene Domain**, um einen Funnel zu *veröffentlichen*. Verwende während der Erstellung die **Preview** des Funnels zum Testen. Beachte, dass benutzerdefiniertes JavaScript (Ansätze B und C) normalerweise nur auf der **veröffentlichten Seite unter einer echten Domain** ausgeführt wird, nicht in der Preview.
</Note>

## Fulfillment mit Webhooks (alle Ansätze)

Dies ist die Automatisierungsebene. Richte sie einmal ein, dann funktioniert sie unabhängig davon, welchen Checkout-Ansatz du wählst.

<Steps>
  <Step title="Create the workflow">
    Öffne in deinem GHL-**Sub-Account** im linken Menü **Automation** (dadurch wird der Tab **Workflows** geöffnet). Klicke auf **Create workflow** und wähle anschließend **Start from Scratch**.
  </Step>

  <Step title="Add the Inbound Webhook trigger">
    Klicke im Builder auf **Add new trigger**. Suche im Bereich **Add trigger** nach **webhook** und wähle **Inbound webhook** (unter **Triggers → Events**) aus. Kopiere die dabei generierte **Webhook URL**.
  </Step>

  <Step title="Register the webhook in Dodo">
    Gehe im Dodo-Dashboard zu **Settings → Webhooks**, füge einen neuen Endpoint hinzu und füge die GHL-Inbound-Webhook-URL ein. Führe einen Testkauf durch, damit GHL eine Beispiel-Payload erfasst und du Felder (Kunden-E-Mail, Produkt, Betrag, Status) zuordnen kannst.
  </Step>

  <Step title="Add fulfillment actions">
    Füge im GHL-Workflow abhängig vom Ereignis Aktionen hinzu, z. B. **find/create contact by email**, **add a tag**, **grant course/membership access** und **send a confirmation email**. **Veröffentliche** anschließend den Workflow.
  </Step>
</Steps>

<Warning>
  Zahlungen werden über Dodo verarbeitet und erscheinen daher **nicht** im Payments-Tab von GHL. Gleiche sie mithilfe des oben beschriebenen Webhook-Workflows mit GHL ab und behandle den **Webhook als maßgebliche Quelle** für die Zugriffsgewährung, nicht die Browser-Weiterleitung, da ein Kunde den Tab schließen kann, bevor er zurückkehrt.
</Warning>

## Ansatz A: Payment Links (No-Code)

Füge einen Dodo-Zahlungslink zu jedem GHL-Button, Funnel-CTA, Button auf einer Bestellseite, E-Mail oder SMS hinzu.

<Steps>
  <Step title="Create a product and copy its payment link">
    Gehe im Dodo-Dashboard zu **Products → Add Product**, lege **name** und **price** fest, wähle **one-time** oder **subscription** aus und klicke auf **Save**. Öffne das Produkt und kopiere den **Payment Link** (Format: `https://checkout.dodopayments.com/buy/{product_id}`).
  </Step>

  <Step title="Add the link to your GHL button">
    Bearbeite deine Funnel- oder Website-Seite, wähle den **Buy / Checkout button** aus, lege die Aktion **Open URL / Website** fest und füge deinen Dodo-Zahlungslink ein.
  </Step>

  <Step title="Set a success page (optional)">
    Lege in Dodo die **return URL** des Produkts auf eine GHL-Dankeseite fest, damit Kunden nach der Zahlung wieder in deinen Funnel gelangen.
  </Step>
</Steps>

<Tip>
  Du kannst Kundendaten vorausfüllen und sperren oder mithilfe von [Query-Parametern für Payment Links](/features/checkout) Tracking hinzufügen. Das ist nützlich, um eine Funnel- oder Angebots-ID als Metadaten zu übergeben, die du später aus dem Webhook auslesen kannst.
</Tip>

## Ansatz B: Overlay Checkout (benutzerdefinierter Code)

Öffnet den Dodo-Checkout mithilfe des [Checkout SDK](/developer-resources/overlay-checkout) über CDN als **Modal-Overlay** auf deiner GHL-Seite. Erfordert ein Backend zum Erstellen einer [Checkout-Sitzung](/api-reference/checkout-sessions/create) und zur Rückgabe von `checkoutUrl`.

<Steps>
  <Step title="Create a backend endpoint that calls the Checkout Sessions API">
    Dieser Schritt ist **nicht optional**. Das SDK benötigt eine gültige `checkoutUrl`, und zum Erstellen einer solchen wird dein **geheimer API-Schlüssel** benötigt. GHL hostet nur statische Seiten und kann diesen serverseitigen Aufruf nicht für dich ausführen. Außerdem darfst du die [Create Checkout Session API](/api-reference/checkout-sessions/create) niemals direkt vom Browser aus aufrufen, da dadurch dein geheimer Schlüssel im Quelltext der Seite offengelegt würde. Overlay- und Inline-Checkout **funktionieren daher nicht mit GHL allein**: Du benötigst ein Backend unter deiner Kontrolle, das die Sitzung erstellt und nur die URL zurückgibt.

    Jedes kleine Backend ist geeignet: eine serverlose Funktion (Cloudflare Workers, Vercel Functions, AWS Lambda, Supabase Edge Functions und ähnliche) oder ein Endpoint auf einem bereits von dir betriebenen Server. Die Logik ist überall gleich: Anfrage empfangen, Dodo's API mit deinem geheimen Schlüssel aufrufen und `checkout_url` zurückgeben.

    Beispiel für die Handler-Logik (an deine bevorzugte Plattform anpassen):

    ```js theme={null}
    async function createCheckout(env) {
      const res = await fetch("https://test.dodopayments.com/checkouts", {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${env.DODO_API_KEY}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          product_cart: [{ product_id: "pdt_your_product_id", quantity: 1 }],
        }),
      });

      const data = await res.json();
      return { checkoutUrl: data.checkout_url };
    }
    ```

    Speichere deinen Dodo-API-Schlüssel als Secret auf der Plattform, auf der du deployest (niemals in den Code übernehmen), erlaube Anfragen von deiner GHL-Domain (CORS) und route den Endpoint unter einer von dir kontrollierten Domain, z. B. `https://api.example.com/create-checkout`. Wechsle zu `https://live.dodopayments.com/checkouts`, sobald du in den Live-Modus wechselst.
  </Step>

  <Step title="Add a Custom Code element in the GHL page builder">
    Öffne deinen Funnel-Schritt oder deine Website-Seite im GHL Page Builder und gehe dann wie folgt vor:

    1. Klicke oben links im Builder auf das **+**-Symbol, um **Quick Add** zu öffnen.
    2. Wähle **Elements** aus der linken Kategorienliste aus.
    3. Suche **Custom Code** (wird auch als HTML angezeigt) und ziehe es auf die Seite.
    4. Füge den folgenden Code in den Code-Editor des Elements ein und speichere ihn.

    ```html theme={null}
    <!-- Load the Dodo Checkout SDK -->
    <script src="https://cdn.jsdelivr.net/npm/dodopayments-checkout@latest/dist/index.js"></script>
    <script>
      DodoPaymentsCheckout.DodoPayments.Initialize({
        mode: "test", // change to "live" in production
        displayType: "overlay",
        onEvent: (event) => console.log("Checkout event:", event),
      });

      async function openDodoCheckout() {
        // calls the backend endpoint from the previous step, creating a fresh session per click
        const res = await fetch("https://api.example.com/create-checkout", { method: "POST" });
        const { checkoutUrl } = await res.json();

        DodoPaymentsCheckout.DodoPayments.Checkout.open({ checkoutUrl });
      }
    </script>

    <button onclick="openDodoCheckout()">Pay Now</button>
    ```
  </Step>

  <Step title="Publish and test on your domain">
    Benutzerdefiniertes JS wird normalerweise nur auf der **veröffentlichten** Seite (verbundene Domain) ausgeführt, nicht immer in der Preview. Veröffentliche die Seite und klicke anschließend auf **Pay Now**, um zu bestätigen, dass sich das Overlay öffnet.
  </Step>
</Steps>

## Ansatz C: Inline-Checkout (eingebettet)

Bettet das Checkout-Formular mithilfe desselben SDK und eines Mount-Containers **in deine GHL-Seite** ein (keine Weiterleitung, kein Popup). Wie bei Ansatz B wird ein Backend zum Erstellen der Sitzung benötigt.

<Steps>
  <Step title="Create a backend endpoint that calls the Checkout Sessions API">
    Es gelten dieselben Anforderungen wie beim Overlay, und auch diese sind **nicht optional**: Zum Erstellen einer Sitzung wird dein geheimer API-Schlüssel benötigt, daher muss dies serverseitig erfolgen. GHL kann dies nicht eigenständig erledigen. Verwende denselben Backend-Endpoint wie im oben beschriebenen Abschnitt **Overlay Checkout** (jede kleine serverlose Funktion oder jeder Server unter deiner Kontrolle), der die [Create Checkout Session API](/api-reference/checkout-sessions/create) aufruft und `{ checkoutUrl }` zurückgibt.
  </Step>

  <Step title="Add a container and SDK via Custom Code">
    Im GHL Page Builder:

    1. Klicke oben links im Builder auf das **+**-Symbol, um **Quick Add** zu öffnen.
    2. Wähle **Elements** aus der linken Kategorienliste aus.
    3. Suche **Custom Code** (wird auch als HTML angezeigt) und ziehe es an die Stelle auf der Seite, an der das Checkout-Formular erscheinen soll.
    4. Füge den folgenden Code in den Code-Editor des Elements ein und speichere ihn.

    ```html theme={null}
    <script src="https://cdn.jsdelivr.net/npm/dodopayments-checkout@latest/dist/index.js"></script>

    <div id="dodo-inline-checkout"></div>

    <script>
      DodoPaymentsCheckout.DodoPayments.Initialize({
        mode: "test",
        displayType: "inline",
        onEvent: (event) => console.log("Checkout event:", event),
      });

      async function mountDodoCheckout() {
        // calls the backend endpoint from the previous step
        const res = await fetch("https://api.example.com/create-checkout", { method: "POST" });
        const { checkoutUrl } = await res.json();

        DodoPaymentsCheckout.DodoPayments.Checkout.open({
          checkoutUrl,
          elementId: "dodo-inline-checkout",
        });
      }

      mountDodoCheckout();
    </script>
    ```
  </Step>

  <Step title="Verify your domain for wallets (Apple Pay)">
    Für Apple Pay beim Inline-Checkout musst du [deine Domain verifizieren](/features/payment-methods/digital-wallets#apple-pay). Hoste die Zuordnungsdatei und registriere die Domain im Dashboard.
  </Step>
</Steps>

<Warning>
  Inline ist die aufwendigste Option in GHL. Sie benötigt benutzerdefinierten Code, ein Backend, eine veröffentlichte Seite unter einer echten Domain und (für Apple Pay) eine Domain-Verifizierung. Wenn du kein vollständig eingebettetes Formular benötigst, solltest du Ansatz A oder B bevorzugen.
</Warning>

## Zu behandelnde Ereignisse

| Dodo-Ereignis                                     | Auslöser                                  | Empfohlene GHL-Aktion                                               |
| ------------------------------------------------- | ----------------------------------------- | ------------------------------------------------------------------- |
| `payment.succeeded`                               | Eine Zahlung wird erfasst                 | Kontakt als bezahlt markieren, Zugriff gewähren, Bestätigung senden |
| `subscription.active`                             | Ein Abonnement wird aktiviert             | Mitgliedschaft gewähren, Onboarding-Workflow starten                |
| `subscription.renewed`                            | Eine Verlängerungszahlung wird eingezogen | Zugriff für den nächsten Zyklus verlängern                          |
| `subscription.on_hold`                            | Eine Verlängerung ist fehlgeschlagen      | Dunning- oder Erinnerungs-Workflow auslösen                         |
| `subscription.cancelled` / `subscription.expired` | Abonnement endet                          | Zugriff entfernen, als abgewandert markieren                        |

Jeder Webhook enthält die **Kunden-E-Mail**. Verwende die GHL-Aktion **find/create contact by email**, um die Zahlung dem richtigen Kontakt zuzuordnen. Eine vollständige Liste findest du im [Webhook Event Guide](/developer-resources/webhooks/intents/webhook-events-guide).

## Testen und Live-Schaltung

<Steps>
  <Step title="Test in test mode">
    Lass Dodo im **Test Mode**, verwende die Testkarte `4242 4242 4242 4242` (beliebiges zukünftiges Ablaufdatum und beliebiger CVC), schließe einen Kauf ab und bestätige, dass der GHL-Workflow ausgelöst wird und das Tag oder der Zugriff angewendet wird.
  </Step>

  <Step title="Go live">
    Wechsle Dodo in den **Live Mode** und aktualisiere den Webhook-Endpoint für den Live-Modus. Was sich sonst ändert, hängt von deinem Ansatz ab:

    * **Payment Links (A):** Ersetze den Link durch den **Live**-Zahlungslink des Produkts.
    * **Overlay Checkout (B):** Richte dein Backend auf `https://live.dodopayments.com/checkouts` mit deinem **Live**-API-Schlüssel aus und setze `mode` des SDK im Aufruf INLINE\_CODE\_PLACEHOLDER\_f5db7a37f0e5ebbcf\_END auf `"live"`.
    * **Inline Checkout (C):** Wie beim Overlay, da derselbe Backend-Endpoint und dieselbe SDK-Initialisierung verwendet werden.

    Führe anschließend einen echten End-to-End-Kauf durch, um dies zu bestätigen.
  </Step>
</Steps>

## Tipps

<Tip>
  Behandle den **Webhook als maßgebliche Quelle** für die Zugriffsgewährung. Reagiere auf `payment.succeeded` / `subscription.active`, nicht auf die Browser-Weiterleitung.
</Tip>

<Tip>
  Überprüfe die Authentizität des Webhooks mithilfe des Headers `webhook-signature` ([Standard Webhooks](/developer-resources/webhooks)), damit nur echte Dodo-Ereignisse das Fulfillment in GHL auslösen.
</Tip>

## Fehlerbehebung

<AccordionGroup>
  <Accordion title="Payment succeeded but nothing happened in GHL">
    Prüfe, ob der Dodo-Webhook-Endpoint auf die richtige GHL-Inbound-Webhook-URL verweist, der Workflow **veröffentlicht** ist und der Trigger eine Beispiel-Payload erfasst hat, sodass das Feld-Mapping vorhanden ist.
  </Accordion>

  <Accordion title="Overlay or inline button does nothing">
    Benutzerdefiniertes JS wird normalerweise nur auf der **veröffentlichten Seite (echte Domain)** ausgeführt, nicht in der Preview. Bestätige, dass die Seite veröffentlicht ist, das SDK `<script>` geladen wurde und `checkoutUrl` eine gültige Sitzungs-URL von deinem Backend ist.
  </Accordion>

  <Accordion title="Contact not created or not matched">
    Stelle sicher, dass dein Workflow **find/create contact by email** verwendet und das E-Mail-Feld aus der Webhook-Payload zugeordnet wird.
  </Accordion>

  <Accordion title="Payment isn't showing in GHL's Payments tab">
    Das ist erwartungsgemäß. Zahlungen werden über Dodo verarbeitet. Gleiche sie daher mithilfe des Webhook-Workflows mit GHL ab.
  </Accordion>
</AccordionGroup>