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 Produkte mit Einmalzahlung verfügbar. Es kann nicht für Abonnement-Produkte 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 beim Erstellen von Checkout-Sessions ein amount-Feld in den Produktkorb ein
  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 Produktkorb ü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 festlegen (innerhalb deiner Mindest-/Höchstwerte).

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

Create a new product

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

Configure product details

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

Set pricing type

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

Enable Pay What You Want

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

Set minimum price

Gib den Mindestpreis ein, den Kunden zahlen müssen. Dieser ist erforderlich und sorgt dafür, dass du einen Umsatzboden sicherstellst.Beispiel: Wenn dein Mindestpreis 5,00 $ beträgt, gib 5.00 (oder 500 Cents) ein.
6

Set maximum price (optional)

Optional: Lege einen Höchstpreis fest, um den Betrag zu begrenzen, den Kunden zahlen können.
7

Set suggested price (optional)

Optional: Gib einen Vorschlagswert ein, der angezeigt wird, um Kunden zu orientieren. Das hilft, Erwartungen zu verankern, und kann den durchschnittlichen Bestellwert verbessern.
8

Save the product

Klicke auf Produkt hinzufügen, um zu speichern. Notiere dir deine Produkt-ID (z. B. pdt_123abc456def) für die Verwendung in Checkout-Sessions.
Du findest deine Produkt-ID im Dashboard unter ProdukteDetails anzeigen oder über die List Products API.

Schritt 2: Erstelle Checkout-Sitzungen mit dynamischer Preisgestaltung

Sobald dein Produkt mit „Zahle, was du willst“ konfiguriert ist, kannst du Checkout-Sessions mit dynamischen Beträgen erstellen. Das amount-Feld im Produktkorb ermöglicht es dir, den Preis für jede Checkout-Session programmatisch festzulegen.

Verständnis des Betragsfeldes

Wenn du eine Checkout-Session erstellst, kannst du in jedem Produktkorb-Item ein amount-Feld einschließen:
  • Wenn amount angegeben ist: Der Checkout verwendet genau diesen Betrag (muss innerhalb deiner Mindest-/Höchstgrenzen liegen)
  • Wenn amount weggelassen wird: Kunden können während des Checkouts ihren eigenen Preis festlegen (innerhalb deiner Grenzen)
Das amount-Feld gilt nur für „Zahle, was du willst“-Produkte. Bei regulären Produkten 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: 'customer@example.com',
        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 Währungseinheit angegeben sein. Bei USD bedeutet dies Cents (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 wählen, lasse das amount-Feld im Produktkorb einfach weg. Auf der Checkout-Seite wird ein Eingabefeld angezeigt, in dem 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: 'customer@example.com',
        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

Set Reasonable Bounds

Wähle einen Mindestpreis, der deine Kosten deckt und gleichzeitig zugänglich bleibt. Verwende einen Vorschlagswert, um die Kundenerwartungen zu lenken.

Validate Amounts

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

Track Pricing Decisions

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

Handle Edge Cases

Stelle sicher, dass deine Anwendung Fälle abfängt, in denen Beträge die Höchstgrenzen überschreiten oder unter den Mindestwerten liegen.

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:
  • Dass das Produkt im Dashboard die Option Zahle, was du willst aktiviert hat
  • Dass das Produkt ein Einmalzahlungsprodukt ist, kein Abonnement
  • Dass der Betrag im korrekten Format vorliegt (niedrigste Währungseinheit, z. B. Cents für USD)
Die API lehnt Checkout-Sessions ab, wenn der Betrag die Preisgrenzen deines Produkts verletzt. Validere Beträge stets vor dem Erstellen von Checkout-Sessions 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 im Produktkorb weggelassen hast. Wenn amount angegeben ist, verwendet der Checkout genau diesen Betrag.