Inline Checkout

Inline checkout bäddar in ett säkert betalningsformulär direkt i sidlayouten. Till skillnad från overlay checkout, som öppnas som en modal, blir inline checkout en del av sidan. Du styr layouten och kan visa en egen ordersammanfattning bredvid checkout-formuläret.

Inline checkout-formulär inbäddat på en produktsida med ordersammanfattning

Så fungerar det

Inline checkout renderar en säker Dodo Payments-frame i en container på din sida. Framen hanterar insamlingen av kundinformation och betalningsuppgifter. Din sida visar artiklar, summor och annan information. SDK:t gör det möjligt för din sida och checkout-framen att kommunicera med varandra. När checkout slutförs skapar Dodo Payments betalningen, eller prenumerationen för en prenumerationsprodukt, och skickar en webhook så att du kan ge kunden åtkomst.

Inline checkout-framen hanterar all känslig betalningsinformation på ett säkert sätt och säkerställer PCI-efterlevnad utan att du behöver någon ytterligare certifiering.

Vad kännetecknar en bra inline checkout

Kunderna behöver veta vem de handlar av, vad de köper och hur mycket de betalar. Din implementation måste innehålla:

Exempel på inline checkout med obligatoriska element markerade — Example inline checkout layout showing required elements

Återkommande information: Om betalningen återkommer ska du visa hur ofta den återkommer och totalsumman som ska betalas vid förnyelse. Om det finns en provperiod ska du visa dess längd.
Artikelbeskrivningar: En beskrivning av det som köps.
Transaktionssummor: Delsumma, total skatt och totalsumma, inklusive valuta.
Dodo Payments-footer: Den fullständiga inline checkout-framen, inklusive footern med information om Dodo Payments, försäljningsvillkor och integritetspolicy.
Återbetalningspolicy: En länk till din återbetalningspolicy om den skiljer sig från Dodo Payments standardpolicy för återbetalning.

Visa alltid hela inline checkout-framen, inklusive footern. Att ta bort eller dölja juridisk information strider mot efterlevnadskraven.

Kundresan

Checkout-flödet beror på konfigurationen av din checkout-session. Beroende på hur du konfigurerar sessionen kan kunderna se all information på en enda sida eller över flera steg.

Customer opens checkout

Du öppnar inline checkout genom att skicka med en checkout-URL. Använd SDK-händelser, till exempel checkout.breakdown, för att visa och uppdatera information på sidan.

Inledande checkout-sida med artikellista och betalningsformulär

Customer enters their details

Inline checkout ber först kunderna att ange sin e-postadress, välja land och, där det krävs, ange sitt ZIP- eller postnummer. Det här steget samlar in all information som behövs för att fastställa skatter och tillgängliga betalningsalternativ.Du kan förifylla kunduppgifter och visa sparade adresser för att förenkla upplevelsen.

Customer selects payment method

När kunderna har angett sina uppgifter visas tillgängliga betalningsmetoder och betalningsformuläret. Alternativen kan omfatta kredit- eller betalkort, PayPal, Apple Pay, Google Pay och andra lokala betalningsmetoder baserat på kundens plats.Visa sparade betalningsmetoder om de finns tillgängliga för att påskynda checkout.

Tillgängliga betalningsmetoder och formulär för kortuppgifter

Checkout completed

Dodo Payments dirigerar varje betalning till den bästa inlösaren för försäljningen för att maximera chansen att betalningen godkänns. Kunderna går vidare till ett framgångsflöde som du kan bygga.

Dodo Payments creates the payment or subscription

Dodo Payments skapar betalningen, eller prenumerationen för en prenumerationsprodukt, och skickar en webhook så att du kan ge kunden åtkomst. Betalningsmetoden som kunden använde sparas för förnyelser eller ändringar av prenumerationen.

Prenumeration skapad med webhook-notifiering

Kom igång snabbt

Installera SDK:t, initiera det för inline-läge och öppna checkout i ett container-element:

import { DodoPayments } from "dodopayments-checkout";

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

DodoPayments.Checkout.open({
  checkoutUrl: "https://test.checkout.dodopayments.com/session/cks_123",
  elementId: "dodo-inline-checkout"
});

Kontrollera att du har ett container-element med motsvarande id på sidan: <div id="dodo-inline-checkout"></div>.

Integration steg för steg

Install the SDK

Installera via npm, yarn eller pnpm:

npm install dodopayments-checkout

yarn add dodopayments-checkout

pnpm add dodopayments-checkout

Initialize the SDK for Inline Display

Initiera SDK:t och ange displayType: 'inline'. Lyssna på händelsen checkout.breakdown för att uppdatera gränssnittet med skatte- och totalsummor i realtid:

import { DodoPayments } from "dodopayments-checkout";

DodoPayments.Initialize({
  mode: "test",
  displayType: "inline",
  onEvent: (event) => {
    if (event.event_type === "checkout.breakdown") {
      const breakdown = event.data?.message;
      // Update your UI with breakdown.subTotal, breakdown.tax, breakdown.total, etc.
    }
  },
});

Create a Container Element

Lägg till ett element i HTML-koden där checkout-framen ska injiceras:

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

Open the Checkout

Anropa DodoPayments.Checkout.open() med checkoutUrl och elementId för din container:

DodoPayments.Checkout.open({
  checkoutUrl: "https://test.checkout.dodopayments.com/session/cks_123",
  elementId: "dodo-inline-checkout"
});

Test Your Integration

Starta din utvecklingsserver:

npm run dev

Testa checkout-flödet:
- Ange din e-postadress och adressuppgifter i inline-framen
- Kontrollera att din anpassade ordersammanfattning uppdateras i realtid
- Testa betalningsflödet med testuppgifter
- Bekräfta att omdirigeringar fungerar korrekt

Du bör se checkout.breakdown-händelser loggas i webbläsarens konsol om du lade till en konsollogg i callbacken onEvent.

Go Live

När du är redo för produktion:

Ändra läget till 'live':

DodoPayments.Initialize({
  mode: "live",
  displayType: "inline",
  onEvent: (event) => {
    // Handle events
  }
});

Uppdatera dina checkout-URL:er så att de använder aktiva checkout-sessioner från din backend
Testa hela flödet i produktion

Komplett React-exempel

Det här exemplet visar hur du implementerar en anpassad ordersammanfattning bredvid inline checkout och håller dem synkroniserade med hjälp av händelsen checkout.breakdown:

"use client";

import { useEffect, useState } from 'react';
import { DodoPayments, CheckoutBreakdownData } from 'dodopayments-checkout';

export default function CheckoutPage() {
  const [breakdown, setBreakdown] = useState<Partial<CheckoutBreakdownData>>({});

  useEffect(() => {
    // 1. Initialize the SDK
    DodoPayments.Initialize({
      mode: 'test',
      displayType: 'inline',
      onEvent: (event) => {
        // 2. Listen for the 'checkout.breakdown' event
        if (event.event_type === "checkout.breakdown") {
          const message = event.data?.message as CheckoutBreakdownData;
          if (message) setBreakdown(message);
        }
      }
    });

    // 3. Open the checkout in the specified container
    DodoPayments.Checkout.open({
      checkoutUrl: 'https://test.checkout.dodopayments.com/session/cks_123',
      elementId: 'dodo-inline-checkout'
    });

    return () => DodoPayments.Checkout.close();
  }, []);

  const format = (amt: number | null | undefined, curr: string | null | undefined) => 
    amt != null && curr ? `${curr} ${(amt/100).toFixed(2)}` : '0.00';

  const currency = breakdown.currency ?? breakdown.finalTotalCurrency ?? '';

  return (
    <div className="flex flex-col md:flex-row min-h-screen">
      {/* Left Side - Checkout Form */}
      <div className="w-full md:w-1/2 flex items-center">
        <div id="dodo-inline-checkout" className='w-full' />
      </div>

      {/* Right Side - Custom Order Summary */}
      <div className="w-full md:w-1/2 p-8 bg-gray-50">
        <h2 className="text-2xl font-bold mb-4">Order Summary</h2>
        <div className="space-y-2">
          {breakdown.subTotal != null && (
            <div className="flex justify-between">
              <span>Subtotal</span>
              <span>{format(breakdown.subTotal, currency)}</span>
            </div>
          )}
          {breakdown.discount != null && breakdown.discount > 0 && (
            <div className="flex justify-between">
              <span>Discount</span>
              <span>{format(breakdown.discount, currency)}</span>
            </div>
          )}
          {breakdown.tax != null && (
            <div className="flex justify-between">
              <span>Tax</span>
              <span>{format(breakdown.tax, currency)}</span>
            </div>
          )}
          <hr />
          {(breakdown.finalTotal ?? breakdown.total) != null && (
            <div className="flex justify-between font-bold text-xl">
              <span>Total</span>
              <span>{format(breakdown.finalTotal ?? breakdown.total, breakdown.finalTotalCurrency ?? currency)}</span>
            </div>
          )}
        </div>
      </div>
    </div>
  );
}

API-referens

Initiera

Anropa Initialize en gång för att konfigurera SDK:t:

interface InitializeOptions {
  mode: "test" | "live";
  displayType?: "overlay" | "inline";
  onEvent: (event: CheckoutEvent) => void;
}

DodoPayments.Initialize(options);

Alternativ	Typ	Obligatoriskt	Beskrivning
`mode`	`"test" \| "live"`	Ja	Miljöläge.
`displayType`	`"inline" \| "overlay"`	Ja	Måste anges till `"inline"` för att bädda in checkout.
`onEvent`	`function`	Ja	Callback-funktion för hantering av checkout-händelser.

Öppna checkout

Öppna checkout-framen i en container:

export type FontSize = "xs" | "sm" | "md" | "lg" | "xl" | "2xl";
export type FontWeight = "normal" | "medium" | "bold" | "extraBold";

interface CheckoutOptions {
  checkoutUrl: string;
  elementId: string;
  options?: {
    showTimer?: boolean;
    showSecurityBadge?: boolean;
    manualRedirect?: boolean;
    payButtonText?: string;
    fontSize?: FontSize;
    fontWeight?: FontWeight;
  };
}

DodoPayments.Checkout.open(options);

Alternativ	Typ	Obligatoriskt	Beskrivning
`checkoutUrl`	`string`	Ja	URL till checkout-sessionen från API:t för att skapa en checkout-session
`elementId`	`string`	Ja	`id` för DOM-elementet där checkout ska renderas
`options.showTimer`	`boolean`	Nej	Visa eller dölj sessionstimern. Standardvärdet är `true`. När värdet är `false` får du händelsen `checkout.link_expired` när sessionen löper ut.
`options.showSecurityBadge`	`boolean`	Nej	Visa eller dölj säkerhetsmärket. Standardvärdet är `true`
`options.manualRedirect`	`boolean`	Nej	När `true` förhindras automatiska omdirigeringar. Checkout skickar `checkout.status` med betalningsresultatet och `checkout.redirect_requested` med URL:en som ska öppnas, och du hanterar navigeringen
`options.payButtonText`	`string`	Nej	Anpassad text för betalningsknappen
`options.fontSize`	`"xs" \| "sm" \| "md" \| "lg" \| "xl" \| "2xl"`	Nej	Global teckenstorlek för checkout
`options.fontWeight`	`"normal" \| "medium" \| "bold" \| "extraBold"`	Nej	Global teckenvikt för checkout

Stäng checkout

Ta bort checkout-framen programmatiskt och rensa händelselyssnare:

DodoPayments.Checkout.close();

Kontrollera status

Kontrollera om checkout-framen för närvarande är injicerad:

const isOpen = DodoPayments.Checkout.isOpen();
// Returns: boolean

Händelser

SDK:t tillhandahåller händelser i realtid via callbacken onEvent. För inline checkout är checkout.breakdown särskilt användbar för att synkronisera gränssnittet:

DodoPayments.Initialize({
  mode: "test",
  displayType: "inline",
  onEvent: (event: CheckoutEvent) => {
    switch (event.event_type) {
      case "checkout.opened":
        // Frame has loaded
        break;
      case "checkout.form_ready":
        // Form is ready for user input
        break;
      case "checkout.breakdown":
        // Prices, taxes, or discounts updated
        break;
      case "checkout.customer_details_submitted":
        // Customer details submitted
        break;
      case "checkout.pay_button_clicked":
        // Customer clicked pay button
        break;
      case "checkout.redirect":
        // Checkout will redirect
        break;
      case "checkout.error":
        console.error("Error:", event.data?.message);
        break;
      case "checkout.link_expired":
        // Session expired (only when showTimer is false)
        break;
    }
  }
});

Händelse	Beskrivning
`checkout.opened`	Checkout-framen har lästs in
`checkout.form_ready`	Formuläret är redo för användarinmatning. Använd detta för att dölja laddningstillstånd
`checkout.breakdown`	Priser, skatter eller rabatter har uppdaterats
`checkout.customer_details_submitted`	Kunduppgifter har skickats
`checkout.pay_button_clicked`	Kunden klickade på betalningsknappen. Användbart för analys och spårning av konverteringstrattar
`checkout.redirect`	Checkout kommer att omdirigera, till exempel till en banksida
`checkout.error`	Ett fel inträffade under checkout
`checkout.link_expired`	Checkout-sessionen har löpt ut. Tas endast emot när `showTimer` är inställd på `false`

Data för checkout-uppdelning

Händelsen checkout.breakdown tillhandahåller pris- och skatteinformation:

interface CheckoutBreakdownData {
  subTotal?: number;          // Amount in cents
  discount?: number;          // Amount in cents
  tax?: number;               // Amount in cents
  total?: number;             // Amount in cents
  currency?: string;          // e.g., "USD"
  finalTotal?: number;        // Final amount including adjustments
  finalTotalCurrency?: string; // Currency for the final total
}

Händelsen utlöses när checkout-framen läses in och igen varje gång priset räknas om, till exempel när kunden väljer ett land eller anger ett postnummer som ändrar skatten. Fältinformation:

Fält	Beskrivning
`subTotal`	Summan av alla radartiklar före rabatter eller skatter
`discount`	Det totala värdet av alla tillämpade rabatter
`tax`	Beräknat skattebelopp. Uppdateras dynamiskt när användaren interagerar med adressfälten
`total`	Resultatet av `subTotal - discount + tax` i sessionens basvaluta
`currency`	ISO-valutakoden, till exempel `"USD"`, för standardvärdena för delsumman, rabatten och skatten.
`finalTotal`	Det faktiska beloppet som kunden debiteras. Det kan inkludera ytterligare valutaomräkningar eller avgifter för lokala betalningsmetoder som inte ingår i den grundläggande prisuppdelningen.
`finalTotalCurrency`	Valutan som kunden faktiskt betalar i. Den kan skilja sig från `currency` om köpkraftsparitet eller lokal valutaomräkning är aktiv.

Integrationstips:

Valutaformatering: Priser är heltal i den minsta valutaenheten, till exempel cent för USD. För valutor med två decimaler delar du med 100 innan formatering med Intl.NumberFormat. Valutor utan decimaler, till exempel JPY, har ingen mindre enhet, så dela inte sådana belopp.
Hantering av initiala tillstånd: När checkout läses in första gången kan tax och discount vara 0 eller null tills användaren anger sin faktureringsinformation eller tillämpar en kod. Hantera dessa tillstånd på ett smidigt sätt, till exempel genom att visa ett tankstreck — eller dölja raden.
”Slutlig summa” jämfört med ”Summa”: Medan total ger dig standardberäkningen av priset är finalTotal den tillförlitliga källan för transaktionen. Om finalTotal finns återger den exakt det belopp som debiteras kundens kort.
Feedback i realtid: Använd fältet tax för att visa användarna att skatten beräknas i realtid. Det ger checkout-sidan en ”live”-känsla och minskar friktionen när adressen anges.

CDN-implementation

För en snabb integration utan ett build-steg laddar du SDK:t från CDN:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Dodo Payments Inline Checkout</title>
  
  <script src="https://cdn.jsdelivr.net/npm/dodopayments-checkout@latest/dist/index.js"></script>
  <script>
    DodoPaymentsCheckout.DodoPayments.Initialize({
      mode: "test",
      displayType: "inline",
      onEvent: (event) => {
        console.log('Checkout event:', event);
      }
    });
  </script>
</head>
<body>
  <div id="dodo-inline-checkout"></div>

  <script>
    DodoPaymentsCheckout.DodoPayments.Checkout.open({
      checkoutUrl: "https://test.checkout.dodopayments.com/session/cks_123",
      elementId: "dodo-inline-checkout"
    });
  </script>
</body>
</html>

Uppdatera betalningsmetod

Inline checkout stöder uppdateringar av betalningsmetoder för prenumerationer. När en kund behöver uppdatera sin betalningsmetod för en aktiv prenumeration eller återaktivera en pausad prenumeration kan du rendera uppdateringsflödet direkt i sidlayouten.

Så fungerar det

Anropa API:t för uppdatering av betalningsmetod för att hämta en payment_link:

// On your server. `client` is the Dodo Payments server SDK (`new DodoPayments()` from the `dodopayments` package).
const response = await client.subscriptions.updatePaymentMethod('sub_123', {
  payment_method: { type: 'new', return_url: 'https://example.com/return' }
});

Skicka den returnerade payment_link som checkoutUrl för att öppna inline checkout:

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

Inline-framen renderar endast formuläret för insamling av betalningsmetod. Kunderna kan ange nya kortuppgifter eller välja en sparad betalningsmetod utan att lämna sidan.

För pausade prenumerationer

När betalningsmetoden uppdateras för en prenumeration med statusen on_hold skapar Dodo Payments automatiskt en debitering för eventuella återstående skulder. Övervaka webhooks för payment.succeeded och subscription.active för att bekräfta återaktiveringen.

const response = await client.subscriptions.updatePaymentMethod('sub_123', {
  payment_method: { type: 'new', return_url: 'https://example.com/return' }
});

if (response.payment_id) {
  // Charge created for remaining dues
  DodoPayments.Checkout.open({
    checkoutUrl: response.payment_link,
    elementId: "dodo-inline-checkout"
  });
}

Du kan också använda en befintlig sparad betalningsmetod i stället för att samla in nya uppgifter genom att skicka type: 'existing' med en payment_method_id till API:t för uppdatering av betalningsmetod.

Felhantering

Implementera alltid felhantering i din callback onEvent:

DodoPayments.Initialize({
  mode: "test",
  displayType: "inline",
  onEvent: (event: CheckoutEvent) => {
    if (event.event_type === "checkout.error") {
      console.error("Checkout error:", event.data?.message);
      // Show user-friendly error message
    }
  }
});

Hantera alltid händelsen checkout.error för att ge en bra användarupplevelse när fel inträffar.

Bästa praxis

Responsiv design: Se till att container-elementet har tillräcklig bredd och höjd. iframe-elementet expanderar vanligtvis så att det fyller sin container.
Synkronisering: Använd händelsen checkout.breakdown för att hålla din anpassade ordersammanfattning eller dina pristabeller synkroniserade med det användaren ser i checkout-framen.
Skeleton-tillstånd: Visa en laddningsindikator i containern tills händelsen checkout.opened utlöses.
Rensning: Anropa DodoPayments.Checkout.close() när komponenten avmonteras för att rensa iframe-elementet och händelselyssnarna.

För implementationer med mörkt läge använder du #0d0d0d som bakgrundsfärg för bästa visuella integration med inline checkout-framen.

Validering av betalningsstatus

Förlita dig inte enbart på inline checkout-händelser för att avgöra om en betalning lyckades eller misslyckades. Implementera alltid validering på serversidan med webhooks och/eller polling.

Varför validering på serversidan är avgörande

Inline checkout-händelser ger feedback i realtid, men de bör inte vara din enda källa till sanning för betalningsstatus. Nätverksproblem, webbläsarkrascher eller användare som stänger sidan kan göra att händelser missas. Säkerställ tillförlitlig betalningsvalidering genom att:

Lyssna på webhook-händelser – Dodo Payments skickar webhooks när betalningsstatus ändras
Implementera en polling-mekanism – Frontend ska fråga din server efter statusuppdateringar
Kombinera båda metoderna – Använd webhooks som primär källa och polling som reservlösning

Rekommenderad arkitektur

Implementeringssteg

1. Lyssna efter checkout-händelser – När användaren klickar på Betala börjar du förbereda verifieringen av statusen:

onEvent: (event) => {
  if (event.event_type === 'checkout.pay_button_clicked') {
    // Start polling your server for confirmed status
    startPolling();
  }
}

2. Fråga din server – Skapa en endpoint som kontrollerar betalningsstatusen i databasen, uppdaterad av webhooks:

// Poll every 2 seconds until status is confirmed
const interval = setInterval(async () => {
  const { status } = await fetch(`/api/payments/${paymentId}/status`).then(r => r.json());
  if (status === 'succeeded' || status === 'failed') {
    clearInterval(interval);
    handlePaymentResult(status);
  }
}, 2000);

3. Hantera webhooks på serversidan – Uppdatera databasen när Dodo skickar webhooks för payment.succeeded eller payment.failed. Mer information finns i vår dokumentation om Webhooks.

Felsökning

Checkout frame is not appearing

Kontrollera att elementId matchar id för ett div som faktiskt finns i DOM
Kontrollera att displayType: 'inline' skickades till Initialize
Kontrollera att checkoutUrl är giltig

Taxes are not updating in my UI

Kontrollera att du lyssnar efter händelsen checkout.breakdown
Skatter beräknas först när användaren anger ett giltigt land och postnummer i checkout-framen

Digitala plånböcker

Detaljerad information om hur du konfigurerar Apple Pay, Google Pay och andra digitala plånböcker finns på sidan Digitala plånböcker.

Snabb konfiguration av Apple Pay

Domänverifiering krävs endast för inline (inbäddad) checkout. Det krävs inte för hosted checkout.

Apple Pay är inte tillgängligt för overlay checkout.

Apple Pay verifieras per domän från dashboarden.

Open Wallet domains

Gå till Settings → Payment Methods och klicka på Manage domains på raden Apple Pay.

Knappen Manage domains på raden Apple Pay i inställningarna för Payment Methods — Open Wallet domains from the Apple Pay row

Download the domain association file

I panelen Wallet domains laddar du ner associationsfilen.

Panelen Wallet domains med knappen Download file — Download the Apple Pay domain association file

Klicka på Register domain och ange domänen där du bäddar in inline checkout, till exempel shop.example.com, och klicka sedan på Continue.

Formulär för registrering av en domän med en angiven domän — Register the domain where you embed inline checkout

Host the file on your domain

Publicera den på:

https://shop.example.com/.well-known/apple-developer-merchantid-domain-association

Den måste levereras via HTTPS, vara åtkomlig utan omdirigeringar och levereras med Content-Type: application/octet-stream eller text/plain.

Verify the domain

Klicka på Verify domain. Dodo Payments bekräftar att filen är aktiv och skickar din domän till Apple.

Skärmen Verify your domain med sökvägen till associationsfilen och knappen Verify domain — Verify the hosted association file

Confirm it's active

När statusen visar Active är Apple Pay aktiverat för domänen. Använd växlingsknappen Enabled för att aktivera eller inaktivera funktionen per domän.

Lista över Wallet-domäner som visar domäner med Apple Pay-statusen Active och växlingsknapparna Enabled — Verified domains show an Active status

Test the integration

Öppna checkout på en Apple-enhet
Kontrollera att Apple Pay-knappen visas
Slutför en testtransaktion

Webbläsarstöd

Dodo Payments Checkout SDK stöder:

Chrome (senaste versionen)
Firefox (senaste versionen)
Safari (senaste versionen)
Edge (senaste versionen)
IE11+

Inline checkout jämfört med overlay checkout

Välj rätt checkout-typ för ditt användningsfall:

Funktion	Inline	Overlay
Integrationsdjup	Helt inbäddad på sidan	Modal ovanpå sidan
Layoutkontroll	Full kontroll	Begränsad
Varumärkesprofilering	Matchar din sida	Separat från sidan
Implementeringsinsats	Högre	Lägre
Bäst för	Anpassade checkout-sidor, flöden med hög konvertering	Snabb integration, befintliga sidor

Använd inline checkout när du vill ha maximal kontroll över checkout-upplevelsen och en konsekvent varumärkesprofilering. Använd overlay checkout för snabbare integration med minimala ändringar på dina befintliga sidor.

Relaterade resurser

Overlay Checkout

Använd overlay checkout för snabb modalbaserad integration.

Checkout Sessions API

Skapa checkout-sessioner för att driva dina checkout-upplevelser.

Webhooks

Hantera betalningshändelser på serversidan med webhooks.

Integration Guide

Komplett guide till integration av Dodo Payments.

Om du behöver mer hjälp kan du besöka vår Discord-community eller kontakta vårt supportteam för utvecklare.

Getting Started

Features

Integrate

Merchant of Record

Miscellaneous

Så fungerar det

Vad kännetecknar en bra inline checkout

Kundresan

Kom igång snabbt

Integration steg för steg

Komplett React-exempel

API-referens

Initiera

Öppna checkout

Stäng checkout

Kontrollera status

Händelser

Data för checkout-uppdelning

CDN-implementation

Uppdatera betalningsmetod

Så fungerar det

För pausade prenumerationer

Felhantering

Bästa praxis

Validering av betalningsstatus

Varför validering på serversidan är avgörande

Rekommenderad arkitektur

Implementeringssteg

Felsökning

Digitala plånböcker

Snabb konfiguration av Apple Pay

Webbläsarstöd

Inline checkout jämfört med overlay checkout

Relaterade resurser

Overlay Checkout

Checkout Sessions API

Webhooks

Integration Guide

​Så fungerar det

​Vad kännetecknar en bra inline checkout

​Kundresan

​Kom igång snabbt

​Integration steg för steg

​Komplett React-exempel

​API-referens

​Initiera

​Öppna checkout

​Stäng checkout

​Kontrollera status

​Händelser

​Data för checkout-uppdelning

​CDN-implementation

​Uppdatera betalningsmetod

​Så fungerar det

​För pausade prenumerationer

​Felhantering

​Bästa praxis

​Validering av betalningsstatus

​Varför validering på serversidan är avgörande

​Rekommenderad arkitektur

​Implementeringssteg

​Felsökning

​Digitala plånböcker

​Snabb konfiguration av Apple Pay

​Webbläsarstöd

​Inline checkout jämfört med overlay checkout

​Relaterade resurser

Overlay Checkout

Checkout Sessions API

Webhooks

Integration Guide

Så fungerar det

Vad kännetecknar en bra inline checkout

Kundresan

Kom igång snabbt

Integration steg för steg

Komplett React-exempel

API-referens

Initiera

Öppna checkout

Stäng checkout

Kontrollera status

Händelser

Data för checkout-uppdelning

CDN-implementation

Uppdatera betalningsmetod

Så fungerar det

För pausade prenumerationer

Felhantering

Bästa praxis

Validering av betalningsstatus

Varför validering på serversidan är avgörande

Rekommenderad arkitektur

Implementeringssteg

Felsökning

Digitala plånböcker

Snabb konfiguration av Apple Pay

Webbläsarstöd

Inline checkout jämfört med overlay checkout

Relaterade resurser