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

# Dynamische Preisgestaltung Checkout mit Zahle, was du willst

> Erstelle flexible Checkout-Links mit variablen Preisen für ein einzelnes Produkt. Aktiviere Zahle, was du willst, damit Kunden ihren Preis wählen oder dynamische Beträge programmgesteuert festlegen können.

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

<Warning>
  „Zahle, was du willst“ ist nur für Produkte mit **Einmalzahlung** verfügbar. Es kann nicht für Abonnement-Produkte verwendet werden.
</Warning>

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

<Info>
  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).
</Info>

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

<Steps>
  <Step title="Create a new product">
    Navigiere in deinem Dodo Payments-Dashboard zu **Produkte** und klicke auf **Produkt hinzufügen**.
  </Step>

  <Step title="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
  </Step>

  <Step title="Set pricing type">
    Wähle **Preisart** als **Einmalzahlung** (einmalige Zahlung).
  </Step>

  <Step title="Enable Pay What You Want">
    Aktiviere im Abschnitt **Preisgestaltung** den Schalter **Zahle, was du willst**.
  </Step>

  <Step title="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.
  </Step>

  <Step title="Set maximum price (optional)">
    Optional: Lege einen **Höchstpreis** fest, um den Betrag zu begrenzen, den Kunden zahlen können.
  </Step>

  <Step title="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.
  </Step>

  <Step title="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.
  </Step>
</Steps>

<Tip>
  Du findest deine Produkt-ID im Dashboard unter **Produkte** → **Details anzeigen** oder über die [List Products API](/api-reference/products/get-products).
</Tip>

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

<Warning>
  Das `amount`-Feld gilt nur für „Zahle, was du willst“-Produkte. Bei regulären Produkten wird dieses Feld ignoriert.
</Warning>

### Codebeispiele

<CodeGroup>
  ```typescript TypeScript theme={null}
  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'
  );
  ```

  ```python Python theme={null}
  import os
  from dodopayments import DodoPayments

  # Initialize the Dodo Payments client
  client = DodoPayments(
      bearer_token=os.environ.get("DODO_PAYMENTS_API_KEY"),
  )

  def create_dynamic_pricing_checkout(
      product_id: str,
      amount_in_cents: int,
      return_url: str
  ):
      """
      Create a checkout session with dynamic pricing.
      
      Args:
          product_id: The product ID with Pay What You Want enabled
          amount_in_cents: The amount in cents (e.g., 2500 for $25.00)
          return_url: URL to redirect after payment completion
      
      Returns:
          Session object with checkout_url and session_id
      """
      try:
          session = client.checkout_sessions.create(
              product_cart=[
                  {
                      "product_id": product_id,
                      "quantity": 1,
                      # Dynamic amount in cents (e.g., 1500 = $15.00)
                      "amount": amount_in_cents
                  }
              ],
              return_url=return_url,
              # 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"
              }
          )
          
          print(f"Checkout URL: {session.checkout_url}")
          print(f"Session ID: {session.session_id}")
          
          return session
      except Exception as error:
          print(f"Failed to create checkout session: {error}")
          raise error

  # Example: Create checkout with $25.00 (2500 cents)
  session = create_dynamic_pricing_checkout(
      "prod_123abc456def",
      2500,  # $25.00 in cents
      "https://yoursite.com/checkout/success"
  )

  # Example: Create checkout with $10.00 (1000 cents)
  session2 = create_dynamic_pricing_checkout(
      "prod_123abc456def",
      1000,  # $10.00 in cents
      "https://yoursite.com/checkout/success"
  )
  ```
</CodeGroup>

<Note>
  **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).
</Note>

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

<CodeGroup>
  ```typescript TypeScript theme={null}
  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;
    }
  }
  ```

  ```python Python theme={null}
  def create_customer_choice_checkout(
      product_id: str,
      return_url: str
  ):
      """
      Create a checkout session where customers choose their own price.
      """
      try:
          session = client.checkout_sessions.create(
              product_cart=[
                  {
                      "product_id": product_id,
                      "quantity": 1
                      # No amount field - customer will choose their price
                  }
              ],
              return_url=return_url,
              customer={
                  "email": "customer@example.com",
                  "name": "John Doe"
              }
          )
          
          return session
      except Exception as error:
          print(f"Failed to create checkout session: {error}")
          raise error
  ```
</CodeGroup>

## Häufige Anwendungsfälle

### Anwendungsfall 1: Staffelpreise basierend auf Benutzertyp

Biete unterschiedlichen Preisen für verschiedene Kundensegmente mit demselben Produkt an:

```typescript theme={null}
// 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:

```typescript theme={null}
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:

```typescript theme={null}
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

<CardGroup cols={2}>
  <Card title="Set Reasonable Bounds" icon="sliders">
    Wähle einen Mindestpreis, der deine Kosten deckt und gleichzeitig zugänglich bleibt. Verwende einen Vorschlagswert, um die Kundenerwartungen zu lenken.
  </Card>

  <Card title="Validate Amounts" icon="shield-check">
    Stelle immer sicher, dass dynamische Beträge innerhalb der Mindest- und Höchstgrenzen deines Produkts liegen, bevor du Checkout-Sessions erstellst.
  </Card>

  <Card title="Track Pricing Decisions" icon="chart-line">
    Verwende Metadaten, um nachzuvollziehen, warum bestimmte Beträge gewählt wurden (z. B. `pricing_tier`, `discount_code`, `user_segment`).
  </Card>

  <Card title="Handle Edge Cases" icon="exclamation-triangle">
    Stelle sicher, dass deine Anwendung Fälle abfängt, in denen Beträge die Höchstgrenzen überschreiten oder unter den Mindestwerten liegen.
  </Card>
</CardGroup>

## Validierung und Fehlerbehandlung

Validiere immer Beträge gegen die Mindest- und Höchstgrenzen deines Produkts:

<CodeGroup>
  ```typescript TypeScript theme={null}
  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'
    });
  }
  ```

  ```python Python theme={null}
  def create_validated_checkout(
      product_id: str,
      amount_in_cents: int,
      min_amount: int,
      max_amount: int | None
  ):
      """
      Create a checkout session with amount validation.
      """
      # Validate minimum
      if amount_in_cents < min_amount:
          raise ValueError(
              f"Amount {amount_in_cents} is below minimum {min_amount}"
          )
      
      # Validate maximum (if set)
      if max_amount is not None and amount_in_cents > max_amount:
          raise ValueError(
              f"Amount {amount_in_cents} exceeds maximum {max_amount}"
          )
      
      # Create checkout session
      return client.checkout_sessions.create(
          product_cart=[
              {
                  "product_id": product_id,
                  "quantity": 1,
                  "amount": amount_in_cents
              }
          ],
          return_url="https://yoursite.com/success"
      )
  ```
</CodeGroup>

## API-Referenz

<CardGroup cols={2}>
  <Card title="Pay What You Want Feature" icon="dollar-sign" href="/features/pay-what-you-want">
    Erfahre mehr über das Preisgestaltungsmodell „Zahle, was du willst“ und seine Möglichkeiten.
  </Card>

  <Card title="Checkout Sessions Guide" icon="cart-shopping" href="/developer-resources/checkout-session">
    Entdecke erweiterte Funktionen für Checkout-Sessions und Anpassungsoptionen.
  </Card>
</CardGroup>

## Fehlersuche

<AccordionGroup>
  <Accordion title="Amount is being ignored">
    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)
  </Accordion>

  <Accordion title="Amount exceeds maximum or is below minimum">
    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.
  </Accordion>

  <Accordion title="Customer can't enter their own price">
    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.
  </Accordion>
</AccordionGroup>