Zum Hauptinhalt springen
Dynamische Preisgestaltung ermöglicht es dir, variable Preise für deine Produkte anzubieten, ohne mehrere Produkteinträge zu erstellen. Durch die Aktivierung von Zahle, was du willst (PWYW) für ein einzelnes Produkt kannst du Mindest- und Höchstpreisgrenzen festlegen und dann dynamische Beträge beim Erstellen von Checkout-Sitzungslinks übergeben. Dieser Ansatz ist ideal, wenn du benötigst:
  • Variable Preisgestaltung ohne Verwaltung mehrerer Produkte
  • Kundengetriebene Preisgestaltung, bei der Käufer ihren Betrag wählen
  • Programmgesteuerte Preissteuerung, bei der du den Betrag dynamisch über die API festlegst
  • Flexible Preismodelle für digitale Produkte, Spenden oder experimentelle Einführungen
Zahle, was du willst ist nur für Einmalzahlungen (einmalige Zahlungen) verfügbar. Es kann nicht mit Abonnementprodukten verwendet werden.

So funktioniert es

Mit aktivierter Zahle, was du willst-Funktion kannst du:
  1. Preisgrenzen festlegen: Definiere einen Mindestpreis (erforderlich) und optional einen Höchstpreis
  2. Dynamische Beträge übergeben: Füge ein amount Feld im Produktwarenkorb beim Erstellen von Checkout-Sitzungen hinzu
  3. Kunden wählen lassen: Wenn kein Betrag angegeben ist, können Kunden ihren eigenen Preis (innerhalb deiner Grenzen) eingeben
Wenn du ein amount im Produktwarenkorb übergibst, wird dieser Betrag für den Checkout verwendet. Wenn du das amount Feld weglässt, können Kunden während des Checkouts ihren eigenen Preis auswählen (unter Berücksichtigung deiner Mindest-/Höchstgrenzen).

Schritt 1: Erstelle ein Produkt mit Zahle, was du willst

Zuerst erstelle ein einmaliges Produkt in deinem Dodo Payments-Dashboard und aktiviere die Preisgestaltung Zahle, was du willst.
1

Neues Produkt erstellen

Navigiere zu Produkte in deinem Dodo Payments-Dashboard und klicke auf Produkt hinzufügen.
2

Produktdetails konfigurieren

Fülle die erforderlichen Produktinformationen aus:
  • Produktname: Anzeigename für dein Produkt
  • Produktbeschreibung: Klare Beschreibung dessen, was Kunden kaufen
  • Produktbild: Lade ein Bild hoch (PNG/JPG/WebP, bis zu 3 MB)
  • Steuerkategorie: Wähle die entsprechende Steuerkategorie
3

Preistyp festlegen

Wähle Preistyp als Einmalzahlung (einmalige Zahlung).
4

Zahle, was du willst aktivieren

Aktiviere im Abschnitt Preisgestaltung den Schalter Zahle, was du willst.
5

Mindestpreis festlegen

Gib den Mindestpreis ein, den Kunden zahlen müssen. Dies ist erforderlich und stellt sicher, dass du einen Umsatzboden einhältst.Beispiel: Wenn dein Mindestpreis 5,00 $ beträgt, gib 5.00 (oder 500 Cent) ein.
6

Höchstpreis festlegen (optional)

Optional kannst du einen Höchstpreis festlegen, um den Betrag zu begrenzen, den Kunden zahlen können.
7

Vorgeschlagenen Preis festlegen (optional)

Optional kannst du einen Vorgeschlagenen Preis eingeben, der angezeigt wird, um Kunden zu leiten. Dies hilft, Erwartungen zu verankern und kann den durchschnittlichen Bestellwert erhöhen.
8

Produkt speichern

Klicke auf Produkt hinzufügen, um zu speichern. Notiere dir deine Produkt-ID (z. B. pdt_123abc456def) zur Verwendung in Checkout-Sitzungen.
Du kannst deine Produkt-ID im Dashboard unter ProdukteDetails anzeigen finden oder indem du die List Products API verwendest.

Schritt 2: Erstelle Checkout-Sitzungen mit dynamischer Preisgestaltung

Sobald dein Produkt mit Zahle, was du willst konfiguriert ist, kannst du Checkout-Sitzungen mit dynamischen Beträgen erstellen. Das amount Feld im Produktwarenkorb ermöglicht es dir, den Preis programmgesteuert für jede Checkout-Sitzung festzulegen.

Verständnis des Betragsfeldes

Beim Erstellen einer Checkout-Sitzung kannst du ein amount Feld in jedem Produktwarenkorb-Element einfügen:
  • Wenn amount angegeben ist: Der Checkout verwendet diesen genauen Betrag (muss innerhalb deiner Mindest-/Höchstgrenzen liegen)
  • Wenn amount weggelassen wird: Kunden können während des Checkouts ihren eigenen Preis eingeben (innerhalb deiner Grenzen)
Das amount Feld ist nur für Zahle, was du willst-Produkte anwendbar. Für reguläre Produkte wird dieses Feld ignoriert.

Codebeispiele

import DodoPayments from 'dodopayments';

// Initialize the Dodo Payments client
const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});

async function createDynamicPricingCheckout(
  productId: string,
  amountInCents: number,
  returnUrl: string
) {
  try {
    const session = await client.checkoutSessions.create({
      product_cart: [
        {
          product_id: productId,
          quantity: 1,
          // Dynamic amount in cents (e.g., 1500 = $15.00)
          amount: amountInCents
        }
      ],
      return_url: returnUrl,
      // Optional: Pre-fill customer information
      customer: {
        email: '[email protected]',
        name: 'John Doe'
      },
      // Optional: Add metadata for tracking
      metadata: {
        order_id: 'order_123',
        pricing_tier: 'custom'
      }
    });

    console.log('Checkout URL:', session.checkout_url);
    console.log('Session ID:', session.session_id);
    
    return session;
  } catch (error) {
    console.error('Failed to create checkout session:', error);
    throw error;
  }
}

// Example: Create checkout with $25.00 (2500 cents)
const session = await createDynamicPricingCheckout(
  'prod_123abc456def',
  2500, // $25.00 in cents
  'https://yoursite.com/checkout/success'
);

// Example: Create checkout with $10.00 (1000 cents)
const session2 = await createDynamicPricingCheckout(
  'prod_123abc456def',
  1000, // $10.00 in cents
  'https://yoursite.com/checkout/success'
);
Betragsformat: Das amount Feld muss in der niedrigsten Einheit der Währung vorliegen. Für USD bedeutet dies Cent (z. B. 25,00 $ = 2500). Für andere Währungen verwende die kleinste Einheit (z. B. Paise für INR).

Schritt 3: Lass Kunden ihren Preis wählen

Wenn du möchtest, dass Kunden während des Checkouts ihren eigenen Preis auswählen, lasse einfach das amount Feld aus dem Produktwarenkorb weg. Die Checkout-Seite zeigt ein Eingabefeld an, in das Kunden jeden Betrag innerhalb deiner Mindest- und Höchstgrenzen eingeben können.
async function createCustomerChoiceCheckout(
  productId: string,
  returnUrl: string
) {
  try {
    const session = await client.checkoutSessions.create({
      product_cart: [
        {
          product_id: productId,
          quantity: 1
          // No amount field - customer will choose their price
        }
      ],
      return_url: returnUrl,
      customer: {
        email: '[email protected]',
        name: 'John Doe'
      }
    });

    return session;
  } catch (error) {
    console.error('Failed to create checkout session:', error);
    throw error;
  }
}

Häufige Anwendungsfälle

Anwendungsfall 1: Staffelpreise basierend auf Benutzertyp

Biete unterschiedlichen Preisen für verschiedene Kundensegmente mit demselben Produkt an:
// Student discount: $10.00
const studentSession = await createDynamicPricingCheckout(
  'prod_123abc456def',
  1000, // $10.00
  'https://yoursite.com/success'
);

// Regular price: $25.00
const regularSession = await createDynamicPricingCheckout(
  'prod_123abc456def',
  2500, // $25.00
  'https://yoursite.com/success'
);

// Premium price: $50.00
const premiumSession = await createDynamicPricingCheckout(
  'prod_123abc456def',
  5000, // $50.00
  'https://yoursite.com/success'
);

Anwendungsfall 2: Dynamische Preisgestaltung basierend auf Menge

Passe den Preis basierend auf der gekauften Menge an:
async function createQuantityBasedCheckout(
  productId: string,
  quantity: number
) {
  // Base price: $20.00 per unit
  // Discount: 10% for 2+ items, 20% for 5+ items
  const basePrice = 2000; // $20.00 in cents
  let discount = 0;
  
  if (quantity >= 5) {
    discount = 0.20; // 20% off
  } else if (quantity >= 2) {
    discount = 0.10; // 10% off
  }
  
  const totalAmount = Math.round(basePrice * quantity * (1 - discount));
  
  const session = await client.checkoutSessions.create({
    product_cart: [
      {
        product_id: productId,
        quantity: quantity,
        amount: totalAmount
      }
    ],
    return_url: 'https://yoursite.com/success'
  });
  
  return session;
}

Anwendungsfall 3: Zeitbasierte oder Aktionspreise

Wende Aktionspreise während bestimmter Zeiträume an:
async function createPromotionalCheckout(productId: string) {
  const isPromoActive = checkIfPromotionActive(); // Your logic
  const regularPrice = 3000; // $30.00
  const promoPrice = 2000; // $20.00
  
  const amount = isPromoActive ? promoPrice : regularPrice;
  
  const session = await client.checkoutSessions.create({
    product_cart: [
      {
        product_id: productId,
        quantity: 1,
        amount: amount
      }
    ],
    return_url: 'https://yoursite.com/success',
    metadata: {
      pricing_type: isPromoActive ? 'promotional' : 'regular'
    }
  });
  
  return session;
}

Best Practices

Vernünftige Grenzen festlegen

Wähle einen Mindestpreis, der deine Kosten deckt und gleichzeitig zugänglich bleibt. Verwende einen vorgeschlagenen Preis, um die Erwartungen der Kunden zu leiten.

Beträge validieren

Validiere immer, dass dynamische Beträge innerhalb der Mindest- und Höchstgrenzen deines Produkts liegen, bevor du Checkout-Sitzungen erstellst.

Preise Entscheidungen nachverfolgen

Verwende Metadaten, um nachzuvollziehen, warum bestimmte Beträge gewählt wurden (z. B. pricing_tier, discount_code, user_segment).

Randfälle behandeln

Stelle sicher, dass deine Anwendung Fälle behandelt, in denen Beträge die Höchstgrenzen überschreiten oder unter die Mindestgrenzen fallen, auf elegante Weise.

Validierung und Fehlerbehandlung

Validiere immer Beträge gegen die Mindest- und Höchstgrenzen deines Produkts:
async function createValidatedCheckout(
  productId: string,
  amountInCents: number,
  minAmount: number,
  maxAmount: number | null
) {
  // Validate minimum
  if (amountInCents < minAmount) {
    throw new Error(
      `Amount ${amountInCents} is below minimum ${minAmount}`
    );
  }
  
  // Validate maximum (if set)
  if (maxAmount !== null && amountInCents > maxAmount) {
    throw new Error(
      `Amount ${amountInCents} exceeds maximum ${maxAmount}`
    );
  }
  
  // Create checkout session
  return await client.checkoutSessions.create({
    product_cart: [
      {
        product_id: productId,
        quantity: 1,
        amount: amountInCents
      }
    ],
    return_url: 'https://yoursite.com/success'
  });
}

API-Referenz

Fehlersuche

Wenn dein amount Feld ignoriert wird, überprüfe, ob:
  • Das Produkt im Dashboard Zahle, was du willst aktiviert hat
  • Das Produkt ein Einmalzahlung (einmalige Zahlung) Produkt ist, kein Abonnement
  • Der Betrag im richtigen Format vorliegt (niedrigste Währungseinheit, z. B. Cent für USD)
Die API wird Checkout-Sitzungen ablehnen, bei denen der Betrag gegen die Preisgrenzen deines Produkts verstößt. Validiere immer Beträge, bevor du Checkout-Sitzungen erstellst, oder lasse Kunden ihren Preis wählen, indem du das amount Feld weglässt.
Wenn Kunden das Preis-Eingabefeld nicht sehen, stelle sicher, dass du das amount Feld aus dem Produktwarenkorb weggelassen hast. Wenn amount angegeben ist, verwendet der Checkout diesen genauen Betrag.