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

> GoHighLevel के साथ Dodo Payments को no-code payment links, overlay checkout या inline checkout का उपयोग करके integrate करें और webhooks के साथ fulfillment को automate करें।

## परिचय

[GoHighLevel](https://www.gohighlevel.com/) (GHL) एक all-in-one CRM और marketing platform है, जिसमें funnels, websites, email/SMS और automation ("Workflows") शामिल हैं। GHL, Dodo Payments को built-in processor के रूप में सूचीबद्ध नहीं करता, इसलिए checkout को कितना embedded रखना है और आप कितना code लिख सकते हैं, इसके आधार पर दोनों को तीन तरीकों में से किसी एक से connect करें।

हर approach में fulfillment एक ही तरह से handle किया जाता है। Dodo [webhook events](/developer-resources/webhooks) को GHL के **Inbound Webhook Workflow** में भेजता है, जो contact को tag करता है, access देता है और confirmations भेजता है।

## अपना approach चुनें

| Approach                | Code needed                | Checkout experience                                          | Best for                                                 |
| ----------------------- | -------------------------- | ------------------------------------------------------------ | -------------------------------------------------------- |
| **A. Payment Links**    | None (no-code)             | Customer को Dodo के hosted checkout पर redirect किया जाता है | अधिकांश GHL users, जल्दी launch करने के लिए              |
| **B. Overlay Checkout** | Custom code plus a backend | आपके GHL page के ऊपर एक modal खुलता है                       | वे teams जो funnel छोड़े बिना on-page checkout चाहती हैं |
| **C. Inline Checkout**  | Custom code plus a backend | Checkout form page के अंदर embedded होता है                  | पूरी तरह embedded, branded UX                            |

<Info>
  क्या यह आपके लिए नया है? **Approach A (Payment Links)** से शुरू करें। इसमें no-code की आवश्यकता है, यह हर GHL user के लिए काम करता है और इसमें कुछ ही मिनट लगते हैं। Approaches B और C को [checkout sessions](/api-reference/checkout-sessions/create) बनाने के लिए backend की आवश्यकता होती है और ये उन teams के लिए हैं जो code के साथ सहज हैं।
</Info>

## आवश्यकताएँ

* कम-से-कम एक **product** बनाए हुए Dodo Payments account।
* Funnel, website या workflow वाला GoHighLevel account।
* अपने Dodo dashboard में **Settings → Webhooks** (और API key के लिए **Settings → Developer**) का access।
* Approaches B और C के लिए: checkout sessions बनाने वाला एक छोटा **backend या serverless endpoint**।

<Note>
  GHL को funnel *publish* करने के लिए **connected domain** की आवश्यकता होती है। निर्माण के दौरान test करने के लिए funnel का **Preview** उपयोग करें। ध्यान दें कि custom JavaScript (Approaches B और C) आमतौर पर **published page on a real domain** पर ही चलता है, Preview में नहीं।
</Note>

## webhooks के साथ Fulfillment (सभी approaches)

यह automation layer है। इसे एक बार set up करें और आप चाहे कोई भी checkout approach चुनें, यह काम करेगा।

<Steps>
  <Step title="Create the workflow">
    अपने GHL **sub-account** में बाएँ menu से **Automation** खोलें (यह **Workflows** tab पर ले जाता है)। **Create workflow** पर click करें, फिर **Start from Scratch** चुनें।
  </Step>

  <Step title="Add the Inbound Webhook trigger">
    Builder में **Add new trigger** पर click करें। **Add trigger** panel में **webhook** खोजें और **Inbound webhook** चुनें (यह **Triggers → Events** के अंतर्गत सूचीबद्ध है)। इससे बनने वाला **Webhook URL** copy करें।
  </Step>

  <Step title="Register the webhook in Dodo">
    Dodo dashboard में **Settings → Webhooks** पर जाएँ, एक नया endpoint जोड़ें और GHL Inbound Webhook URL paste करें। एक test purchase करें ताकि GHL sample payload capture कर सके और आप fields (customer email, product, amount, status) map कर सकें।
  </Step>

  <Step title="Add fulfillment actions">
    GHL workflow में वापस जाकर event के आधार पर actions जोड़ें, जैसे **find/create contact by email**, **add a tag**, **grant course/membership access** और **send a confirmation email**। फिर workflow को **Publish** करें।
  </Step>
</Steps>

<Warning>
  Payments Dodo पर process किए जाते हैं, इसलिए वे GHL के Payments tab में **दिखाई नहीं देंगे**। ऊपर दिए गए webhook workflow का उपयोग करके उन्हें GHL में reconcile करें और access देने के लिए **webhook को source of truth** मानें, browser redirect को नहीं, क्योंकि customer वापस आने से पहले tab बंद कर सकता है।
</Warning>

## Approach A: Payment Links (no-code)

किसी भी GHL button, funnel CTA, order-page button, email या SMS में Dodo payment link जोड़ें।

<Steps>
  <Step title="Create a product and copy its payment link">
    Dodo dashboard में **Products → Add Product** पर जाएँ, **name** और **price** set करें, **one-time** या **subscription** चुनें और **Save** करें। Product खोलकर उसका **Payment Link** copy करें (format: `https://checkout.dodopayments.com/buy/{product_id}`)।
  </Step>

  <Step title="Add the link to your GHL button">
    अपने funnel या website page को edit करें, **Buy / Checkout button** चुनें, उसका action **Open URL / Website** set करें और अपना Dodo payment link paste करें।
  </Step>

  <Step title="Set a success page (optional)">
    Dodo में product का **return URL** GHL thank-you page पर set करें, ताकि payment के बाद customers आपके funnel में वापस पहुँचें।
  </Step>
</Steps>

<Tip>
  [Payment-link query parameters](/features/checkout) का उपयोग करके आप customer details को prefill और lock कर सकते हैं या tracking जोड़ सकते हैं। यह funnel या offer ID को metadata के रूप में pass करने के लिए उपयोगी है, जिसे आप webhook से वापस पढ़ सकते हैं।
</Tip>

## Approach B: Overlay Checkout (custom code)

[Checkout SDK](/developer-resources/overlay-checkout) को CDN के माध्यम से उपयोग करके आपके GHL page पर Dodo checkout को **modal overlay** के रूप में खोलता है। इसके लिए [checkout session](/api-reference/checkout-sessions/create) बनाने और उसका `checkoutUrl` लौटाने वाले backend की आवश्यकता होती है।

<Steps>
  <Step title="Create a backend endpoint that calls the Checkout Sessions API">
    यह step **optional नहीं है**। SDK को live `checkoutUrl` की आवश्यकता होती है और इसे बनाने के लिए आपकी **secret API key** चाहिए। GHL केवल static pages host करता है; यह server-side call आपके लिए नहीं चला सकता। आपको [Create Checkout Session API](/api-reference/checkout-sessions/create) को सीधे browser से कभी call नहीं करना चाहिए, क्योंकि इससे page के source में आपकी secret key expose हो जाएगी। इसलिए overlay और inline checkout **केवल GHL के साथ काम नहीं कर सकते**: आपको अपने नियंत्रण वाले backend की आवश्यकता है, जो session बनाए और केवल URL वापस दे।

    कोई भी छोटा backend काम करेगा: एक serverless function (Cloudflare Workers, Vercel Functions, AWS Lambda, Supabase Edge Functions और इसी प्रकार के अन्य), या आपके द्वारा पहले से चलाए जा रहे server पर एक endpoint। Logic हर जगह समान है: request प्राप्त करें, अपनी secret key से Dodo की API call करें और `checkout_url` लौटाएँ।

    उदाहरण handler logic (अपनी पसंद के platform के अनुसार adapt करें):

    ```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 };
    }
    ```

    जिस platform पर आप deploy करते हैं, वहाँ अपनी Dodo API key को secret के रूप में store करें (इसे code में कभी commit न करें), अपने GHL domain से आने वाली requests की अनुमति दें (CORS) और endpoint को अपने नियंत्रण वाले domain के अंतर्गत route करें, जैसे `https://api.example.com/create-checkout`। Live mode पर जाने के बाद `https://live.dodopayments.com/checkouts` पर switch करें।
  </Step>

  <Step title="Add a Custom Code element in the GHL page builder">
    GHL page builder में अपना funnel step या website page खोलें, फिर:

    1. **Quick Add** खोलने के लिए builder के top-left में **+** icon पर click करें।
    2. बाएँ category list से **Elements** चुनें।
    3. **Custom Code** (जिसे HTML के रूप में भी दिखाया जाता है) खोजें और उसे page पर drag करें।
    4. नीचे दिया गया code element के code editor में paste करें, फिर save करें।

    ```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">
    Custom JS **published** page (connected domain) पर चलता है, Preview में हमेशा नहीं। Publish करें, फिर overlay खुलने की पुष्टि करने के लिए **Pay Now** पर click करें।
  </Step>
</Steps>

## Approach C: Inline (embedded) Checkout

उसी SDK और एक mount container का उपयोग करके checkout form को आपके GHL page के **अंदर** embed करता है (कोई redirect या popup नहीं)। Approach B की तरह, इसे session बनाने के लिए backend की आवश्यकता होती है।

<Steps>
  <Step title="Create a backend endpoint that calls the Checkout Sessions API">
    Overlay जैसी ही requirement है और यह भी **optional नहीं है**: session बनाने के लिए आपकी secret API key चाहिए, इसलिए यह server-side होना चाहिए। GHL इसे स्वयं नहीं कर सकता। ऊपर दिए गए **Overlay Checkout** section में बताए गए उसी backend endpoint का पुनः उपयोग करें (कोई भी छोटा serverless function या आपके नियंत्रण वाला server), जो [Create Checkout Session API](/api-reference/checkout-sessions/create) को call करता है और `{ checkoutUrl }` लौटाता है।
  </Step>

  <Step title="Add a container and SDK via Custom Code">
    GHL page builder में:

    1. **Quick Add** खोलने के लिए builder के top-left में **+** icon पर click करें।
    2. बाएँ category list से **Elements** चुनें।
    3. **Custom Code** (जिसे HTML के रूप में भी दिखाया जाता है) खोजें और उसे उस page पर drag करें जहाँ checkout form दिखाना है।
    4. नीचे दिया गया code element के code editor में paste करें, फिर save करें।

    ```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)">
    Inline checkout पर Apple Pay के लिए [अपने domain को verify करें](/features/payment-methods/digital-wallets#apple-pay)। Association file host करें और dashboard में domain register करें।
  </Step>
</Steps>

<Warning>
  GHL में Inline सबसे अधिक involved option है। इसके लिए custom code, backend, real domain पर published page और (Apple Pay के लिए) domain verification की आवश्यकता होती है। यदि आपको पूरी तरह embedded form की आवश्यकता नहीं है, तो Approach A या B को प्राथमिकता दें।
</Warning>

## Handle करने योग्य Events

| Dodo event                                        | When it fires                 | Suggested GHL action                                                  |
| ------------------------------------------------- | ----------------------------- | --------------------------------------------------------------------- |
| `payment.succeeded`                               | Payment capture होने पर       | Contact को paid के रूप में tag करें, access दें और confirmation भेजें |
| `subscription.active`                             | Subscription activate होने पर | Membership दें और onboarding workflow शुरू करें                       |
| `subscription.renewed`                            | Renewal payment लिए जाने पर   | अगले cycle के लिए access बढ़ाएँ                                       |
| `subscription.on_hold`                            | Renewal fail होने पर          | Dunning या reminder workflow trigger करें                             |
| `subscription.cancelled` / `subscription.expired` | Subscription समाप्त होने पर   | Access हटाएँ और churned के रूप में tag करें                           |

हर webhook में **customer email** शामिल होता है। Payment को सही contact से जोड़ने के लिए GHL का **find/create contact by email** action उपयोग करें। पूरी list के लिए [Webhook Event Guide](/developer-resources/webhooks/intents/webhook-events-guide) देखें।

## Testing और Going Live

<Steps>
  <Step title="Test in test mode">
    Dodo को **Test Mode** में रखें, test card `4242 4242 4242 4242` (कोई भी future expiry और कोई भी CVC) उपयोग करें, purchase पूरा करें और पुष्टि करें कि GHL workflow trigger होकर tag या access लागू करता है।
  </Step>

  <Step title="Go live">
    Dodo को **Live Mode** पर switch करें और live-mode webhook endpoint update करें। इसके अलावा क्या बदलता है, यह आपके approach पर निर्भर करता है:

    * **Payment Links (A):** product के **live** payment link का उपयोग करें।
    * **Overlay checkout (B):** अपने backend को `https://live.dodopayments.com/checkouts` पर अपनी **live** API key के साथ point करें और SDK के `mode` को `"live"` पर set करें, INLINE\_CODE\_PLACEHOLDER\_f5db7a37f0e5ebbcf\_END call में।
    * **Inline checkout (C):** overlay जैसा ही, क्योंकि यह उसी backend endpoint और SDK initialization का उपयोग करता है।

    फिर पुष्टि करने के लिए एक real end-to-end purchase करें।
  </Step>
</Steps>

## Tips

<Tip>
  Access देने के लिए **webhook को source of truth** मानें। Browser redirect पर नहीं, बल्कि `payment.succeeded` / `subscription.active` पर action लें।
</Tip>

<Tip>
  `webhook-signature` header ([Standard Webhooks](/developer-resources/webhooks)) का उपयोग करके webhook authenticity verify करें, ताकि केवल genuine Dodo events ही GHL में fulfillment trigger करें।
</Tip>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Payment succeeded but nothing happened in GHL">
    जाँचें कि Dodo webhook endpoint सही GHL Inbound Webhook URL पर point करता है, workflow **published** है और trigger ने sample payload capture किया है, ताकि field mapping मौजूद हो।
  </Accordion>

  <Accordion title="Overlay or inline button does nothing">
    Custom JS आमतौर पर केवल **published page (real domain)** पर चलता है, Preview में नहीं। पुष्टि करें कि page published है, SDK `<script>` load हुआ है और `checkoutUrl` आपके backend से प्राप्त valid session URL है।
  </Accordion>

  <Accordion title="Contact not created or not matched">
    सुनिश्चित करें कि आपका workflow **find/create contact by email** का उपयोग करता है और email field webhook payload से mapped है।
  </Accordion>

  <Accordion title="Payment isn't showing in GHL's Payments tab">
    यह अपेक्षित है। Payments Dodo पर process किए जाते हैं, इसलिए webhook workflow का उपयोग करके उन्हें GHL में reconcile करें।
  </Accordion>
</AccordionGroup>