# Gutscheine und Promo-Codes Nutzen Sie Gutscheine und Promo-Codes, um Rabatte zu Abonnements und Abonnementposten hinzuzufügen. Mit Gutscheinen können Sie Preisnachlässe auf Abonnements anbieten. Außerdem eignen sie sich auch sehr gut für Promo-Codes. Wer sie einlöst, erhält einen Rabatt auf ein laufendes Abonnement. - [Gutscheine](https://docs.stripe.com/billing/subscriptions/coupons.md#coupons): Sie erstellen und verwalten Gutscheine, um Rabatte zu definieren, z. B. einen Prozentsatz oder einen Betrag, der vom Abonnementpreis abgezogen wird. - [Promo-Codes](https://docs.stripe.com/billing/subscriptions/coupons.md#promotion-codes): Sie erstellen Codes für Ihre Kundinnen/Kunden, die Ihren Gutscheinen zugeordnet sind. Beispielsweise kann sowohl FALLPROMO als auch SPRINGPROMO einem einzelnen 25 %-Gutschein zugeordnet sein. Sie können Promo-Codes direkt an Ihre Kundinnen/Kunden weitergeben, die die Codes beim Bezahlvorgang eingeben und einlösen können. Dafür eignen sich Gutscheine und Promo-Codes: - Einen oder mehrere Rabatte auf eine Rechnung, ein Abonnement oder einen Abonnementposten anwenden - Einen oder mehrere Rabatte für einen bestimmten Zeitraum anwenden - Rechnungsbeträge anteilig oder pauschal verringern Ihre Gutscheine können Sie auch zeitlich oder mit Blick auf ihre Gesamtzahl begrenzen. Wie Sie Rabatte auf Einzelzahlungen anwenden, erfahren Sie unter [Rabatte für Einmalzahlungen einrichten](https://docs.stripe.com/payments/checkout/discounts.md). ## Gutscheine Wenn Sie Kundenrabatte auf fällige Zahlungen anwenden wollen, können Sie Gutscheine in Rabatte umwandeln. Hier erfahren Sie, wie Sie Gutscheine erstellen und verwalten. ### Gutschein erstellen Gutscheine können im Dashboard oder mit der [API](https://docs.stripe.com/api/coupons/create.md) erstellt werden: #### Dashboard 1. Navigieren Sie im Dashboard zum Abschnitt [Produkte](https://dashboard.stripe.com/test/products?active=true). 1. Klicken Sie auf **Gutscheine**. 1. Klicken Sie auf **+ Neu**. 1. Im Dialogfenster **Gutschein erstellen** legen Sie die Eckdaten des Gutscheins fest. 1. Nun klicken Sie auf **Gutschein erstellen**. Die folgenden Einstellungen gelten für Gutscheine. Der Name ist die einzige Einstellung, die Sie nach der Erstellung des Gutscheins bearbeiten können. | Einstellung | Beschreibung | | ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Name** | Die Gutscheinbezeichnung, die auf Quittungen und Abrechnungen erscheint. | | **ID** (optional) | Eindeutige Gutscheinkennung in der API. Wenn Sie dieses Feld unausgefüllt lassen, generiert Stripe die ID. | | **Typ** | Gibt an, ob es sich um einen pauschalen oder anteiligen Preisnachlass handelt. | | **Prozentualer Rabatt** oder **Rabattbetrag** | Gibt an, für welchen Rabattbetrag der Gutschein tatsächlich gilt. Wenn Sie Verkäufe in mehreren Währungen tätigen, können mit einem einzelnen Gutschein verschiedene Rabattbeträge für unterschiedliche Währungen definiert werden. Für Gutscheine mit mehreren Währungen gelten die gleichen Regeln wie für [Preise in mehreren Währungen](https://docs.stripe.com/products-prices/how-products-and-prices-work.md#multiple-currencies). | | **Auf bestimmte Produkte anwenden** (optional) | Begrenzt den Artikeltyp, für den der Gutschein eingelöst werden kann. | | **Dauer** | Gibt die Gültigkeitsdauer des Gutscheins an. | | **Ablaufdatum** (optional) | Ermöglicht die Eingrenzung des Einlösezeitraums und die Festlegung der Einlösehäufigkeit. | | **Codes** (optional) | Ermöglicht die Erstellung von [Promo-Codes](https://docs.stripe.com/billing/subscriptions/coupons.md#promotion-codes--promotion-codes) für den Gutschein. | #### API ```curl curl https://api.stripe.com/v1/coupons \ -u "<>:" \ -d duration=once \ -d id=free-period \ -d percent_off=100 ``` ```cli stripe coupons create \ --duration=once \ --id=free-period \ --percent-off=100 ``` ```ruby # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = Stripe::StripeClient.new("<>") coupon = client.v1.coupons.create({ duration: 'once', id: 'free-period', percent_off: 100, }) ``` ```python # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = StripeClient("<>") # For SDK versions 12.4.0 or lower, remove '.v1' from the following line. coupon = client.v1.coupons.create({ "duration": "once", "id": "free-period", "percent_off": 100, }) ``` ```php // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys $stripe = new \Stripe\StripeClient('<>'); $coupon = $stripe->coupons->create([ 'duration' => 'once', 'id' => 'free-period', 'percent_off' => 100, ]); ``` ```java // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys StripeClient client = new StripeClient("<>"); CouponCreateParams params = CouponCreateParams.builder() .setDuration(CouponCreateParams.Duration.ONCE) .setId("free-period") .setPercentOff(new BigDecimal(100)) .build(); // For SDK versions 29.4.0 or lower, remove '.v1()' from the following line. Coupon coupon = client.v1().coupons().create(params); ``` ```node // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys const stripe = require('stripe')('<>'); const coupon = await stripe.coupons.create({ duration: 'once', id: 'free-period', percent_off: 100, }); ``` ```go // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys sc := stripe.NewClient("<>") params := &stripe.CouponCreateParams{ Duration: stripe.String(stripe.CouponDurationOnce), ID: stripe.String("free-period"), PercentOff: stripe.Float64(100), } result, err := sc.V1Coupons.Create(context.TODO(), params) ``` ```dotnet // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys var options = new CouponCreateOptions { Duration = "once", Id = "free-period", PercentOff = 100M, }; var client = new StripeClient("<>"); var service = client.V1.Coupons; Coupon coupon = service.Create(options); ``` Die Tabelle zeigt die verschiedenen Gutscheinparameter. | Einstellung | Beschreibung | | ----------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `id` | Eine eindeutige Gutscheinkennung. | | `percent_off` oder `amount_off` | Rabattbetrag der Zwischensumme vorbehaltlich Gültigkeit. | | `currency` (sofern `amount_off` konfiguriert ist) | Der ISO-Code mit drei Buchstaben für die Währung des abzuziehenden Betrags. | | `currency_options` (wenn `amount_off` eingestellt ist) (optional) | Wenn Sie Verkäufe in mehreren Währungen tätigen, werden die Beträge von der Zwischensumme für verschiedene Währungen abgezogen. Für Gutscheine mit mehreren Währungen gelten die gleichen Regeln wie für [Preise in mehreren Währungen](https://docs.stripe.com/products-prices/how-products-and-prices-work.md#multiple-currencies). | | `duration` | Gibt die Gültigkeitsdauer des Gutscheins an. Mögliche Werte sind **einmalig**, **unbegrenzt** und **wiederholt**. | | `max_redemptions` (optional) | Summe aller möglichen Gutscheineinlösungen durch die gesamte Kundschaft. | | `redeem_by` (optional) | Datum der letzten Einlösemöglichkeit. | | `applies_to` (optional) | Begrenzt die Artikelanzahl, für die der Gutschein innerhalb einer Rechnung eingelöst werden kann. | ### Berechtigte Produkte festlegen #### Dashboard Um die rabattberechtigten Produkte festzulegen, tragen Sie diese in das Feld **Auf bestimmtes Produkt anwenden** ein. Die Liste zugelassener Produkte gilt auch für die mit dem Gutschein verknüpften Gutschein-Codes. Ist ein Gutschein auf bestimmte Produkte beschränkt, die in einem Abonnement nicht enthalten sind, wird kein Rabatt angewendet, wenn der Gutschein für dieses Abonnement eingelöst wird. #### API Um die rabattberechtigten Produkte festzulegen, tragen Sie die entsprechenden Produkt-IDs in den `applies_to`-Hash des Gutscheins ein. Die Liste zugelassener Produkte gilt auch für die mit dem Gutschein verknüpften Gutschein-Codes. Ist ein Gutschein auf bestimmte Produkte beschränkt, die in einem Abonnement nicht enthalten sind, wird kein Rabatt angewendet, wenn der Gutschein für dieses Abonnement eingelöst wird. Wenn Sie [Änderungen](https://docs.stripe.com/billing/subscriptions/change.md) an einem Abo vornehmen, berechnet Stripe die anteilmäßige Verrechnung und wendet vorhandene Rabatte an. Sie können die anteiligen Posten auf der erzeugten Rechnung nicht weiter rabattieren. ### Gutscheine auf Abonnements anwenden Nachdem Sie Gutscheine erstellt haben, erstellen Sie einen Rabatt, indem Sie sie auf ein Abonnement anwenden. Sie können den Gutschein anwenden, wenn Sie das Abonnement erstellen oder indem Sie [das bestehende Abonnement eines Kunden/einer Kundin aktualisieren](https://docs.stripe.com/api.md#update_subscription). #### Dashboard 1. Öffnen Sie im Dashboard die Seite [Abos](https://dashboard.stripe.com/test/subscriptions?status=active). 1. Klicken Sie das jeweilige Abonnement an. 1. Klicken Sie auf **Aktionen**. 1. Klicken Sie auf **Abonnement aktualisieren**. 1. Klicken Sie auf **Gutschein hinzufügen**. 1. Wählen Sie einen oder mehrere Gutscheine aus den Dropdown-Menüs aus und klicken Sie auf **Absenden**. #### API ```curl curl https://api.stripe.com/v1/subscriptions \ -u "<>:" \ -d customer="{{CUSTOMER_ID}}" \ -d "items[0][price]"="{{PRICE_ID}}" \ -d "discounts[0][coupon]"=free-period ``` ```cli stripe subscriptions create \ --customer="{{CUSTOMER_ID}}" \ -d "items[0][price]"="{{PRICE_ID}}" \ -d "discounts[0][coupon]"=free-period ``` ```ruby # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = Stripe::StripeClient.new("<>") subscription = client.v1.subscriptions.create({ customer: '{{CUSTOMER_ID}}', items: [{price: '{{PRICE_ID}}'}], discounts: [{coupon: 'free-period'}], }) ``` ```python # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = StripeClient("<>") # For SDK versions 12.4.0 or lower, remove '.v1' from the following line. subscription = client.v1.subscriptions.create({ "customer": "{{CUSTOMER_ID}}", "items": [{"price": "{{PRICE_ID}}"}], "discounts": [{"coupon": "free-period"}], }) ``` ```php // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys $stripe = new \Stripe\StripeClient('<>'); $subscription = $stripe->subscriptions->create([ 'customer' => '{{CUSTOMER_ID}}', 'items' => [['price' => '{{PRICE_ID}}']], 'discounts' => [['coupon' => 'free-period']], ]); ``` ```java // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys StripeClient client = new StripeClient("<>"); SubscriptionCreateParams params = SubscriptionCreateParams.builder() .setCustomer("{{CUSTOMER_ID}}") .addItem( SubscriptionCreateParams.Item.builder().setPrice("{{PRICE_ID}}").build() ) .addDiscount( SubscriptionCreateParams.Discount.builder().setCoupon("free-period").build() ) .build(); // For SDK versions 29.4.0 or lower, remove '.v1()' from the following line. Subscription subscription = client.v1().subscriptions().create(params); ``` ```node // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys const stripe = require('stripe')('<>'); const subscription = await stripe.subscriptions.create({ customer: '{{CUSTOMER_ID}}', items: [ { price: '{{PRICE_ID}}', }, ], discounts: [ { coupon: 'free-period', }, ], }); ``` ```go // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys sc := stripe.NewClient("<>") params := &stripe.SubscriptionCreateParams{ Customer: stripe.String("{{CUSTOMER_ID}}"), Items: []*stripe.SubscriptionCreateItemParams{ &stripe.SubscriptionCreateItemParams{Price: stripe.String("{{PRICE_ID}}")}, }, Discounts: []*stripe.SubscriptionCreateDiscountParams{ &stripe.SubscriptionCreateDiscountParams{Coupon: stripe.String("free-period")}, }, } result, err := sc.V1Subscriptions.Create(context.TODO(), params) ``` ```dotnet // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys var options = new SubscriptionCreateOptions { Customer = "{{CUSTOMER_ID}}", Items = new List { new SubscriptionItemOptions { Price = "{{PRICE_ID}}" }, }, Discounts = new List { new SubscriptionDiscountOptions { Coupon = "free-period" }, }, }; var client = new StripeClient("<>"); var service = client.V1.Subscriptions; Subscription subscription = service.Create(options); ``` Auch wenn für Kundinnen/Kunden keine gespeicherte Zahlungsmethode vorhanden ist, können Sie ein Abo erstellen, sofern nach Anwendung von Gutscheinen [keine sofortige Zahlung](https://docs.stripe.com/billing/subscriptions/deferred-payment.md) erforderlich ist. ### Checkout-Gutscheine anwenden Sie können Gutscheine auf Checkout-Sitzungen anwenden, indem Sie den `discounts`-Parameter in der [API](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-discounts) einrichten. Um Sitzungen mit angewendeten Rabatt zu erstellen, übergeben Sie die Gutschein-ID in dem Parameter `coupon` an das Array `discounts`. #### curl ```bash curl https://api.stripe.com/v1/checkout/sessions \ -u <>: \ -d "payment_method_types[]"=card \ -d "line_items[][price]"="{{PRICE_ID}}" \ -d "line_items[][quantity]"=1 \ -d mode=subscription \-d "discounts[][coupon]"="{{COUPON_ID}}" \ -d success_url="https://example.com/success" \ ``` #### Ruby ```ruby # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys Stripe.api_key = '<>' session = Stripe::Checkout::Session.create({ payment_method_types: ['card'], line_items: [{ price: '{{PRICE_ID}}', quantity: 1 }], mode: 'subscription', discounts: [{coupon: '{{COUPON_ID}}', }], success_url: 'https://example.com/success' }) ``` #### Python ```python # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys stripe.api_key = '<>' session = stripe.checkout.Session.create( payment_method_types=['card'], line_items=[{ 'price': '{{PRICE_ID}}', 'quantity': 1 }], mode='subscription', discounts=[{'coupon': '{{COUPON_ID}}', }], success_url='https://example.com/success', ) ``` #### PHP ```php // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys \Stripe\Stripe::setApiKey('<>'); $session = \Stripe\Checkout\Session::create([ 'payment_method_types' => ['card'], 'line_items' => [[ 'price' => '{{PRICE_ID}}', 'quantity' => 1 ]], 'mode' => 'subscription', 'discounts' => [['coupon' => '{{COUPON_ID}}', ]], 'success_url' => 'https://example.com/success' ]); ``` #### Java ```java // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys Stripe.apiKey = "<>"; SessionCreateParams params = SessionCreateParams.builder() .addPaymentMethodType(SessionCreateParams.PaymentMethodType.CARD) .addLineItem( SessionCreateParams.LineItem.builder() .setPrice(""{{PRICE_ID}}"") .setQuantity(1L) .build()) .setMode(SessionCreateParams.Mode.SUBSCRIPTION) .addDiscount( SessionCreateParams.Discount.builder().setCoupon("{{COUPON_ID}}") .build()) .setSuccessUrl("https://example.com/success") .build(); Session session = Session.create(params); ``` #### Node.js ```javascript // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys const stripe = require('stripe')('<>'); const session = await stripe.checkout.sessions.create({ payment_method_types: ['card'], line_items: [{ price: '{{PRICE_ID}}', quantity: 1 }], mode: 'subscription', discounts: [{coupon: '{{COUPON_ID}}', }], success_url: 'https://example.com/success' }); ``` #### Go ```go // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys stripe.Key = "<>" params := &stripe.CheckoutSessionParams{ PaymentMethodTypes: stripe.StringSlice([]string{ "card" }), LineItems: []*stripe.CheckoutSessionLineItemParams{ &stripe.CheckoutSessionLineItemParams{ Price: stripe.String(""{{PRICE_ID}}""), Quantity: stripe.Int64(1) } }, Mode: stripe.String("subscription"), Discounts: []*stripe.CheckoutSessionDiscountParams{ &stripe.CheckoutSessionDiscountParams{Coupon: stripe.String("{{COUPON_ID}}"), } }, SuccessURL: stripe.String("https://example.com/success"), } session, _ := session.New(params) ``` #### .NET ```dotnet // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys StripeConfiguration.ApiKey = "<>"; var options = new SessionCreateOptions { PaymentMethodTypes = new List { "card" }, LineItems = new List { new SessionLineItemOptions { Price = ""{{PRICE_ID}}"", Quantity = 1 } }, Mode = "subscription", Discounts = new List { new SessionDiscountOptions {Coupon = "{{COUPON_ID}}", } }, SuccessUrl = "https://example.com/success", }; var service = new SessionService(); var session = service.Create(options); ``` ### Gutscheine entfernen Gutscheine können im Dashboard oder mit der [API](https://docs.stripe.com/api/coupons/delete.md) entfernt werden. Wird ein Gutschein gelöscht, kann er für künftige Abonnements und Rechnungen nicht mehr eingelöst werden. Bei bereits vorhandenen Abonnements und Rechnungen bleibt der Rabatt jedoch bestehen. #### Dashboard 1. Navigieren Sie im Dashboard zum Abschnitt [Produkte](https://dashboard.stripe.com/test/products?active=true). 1. Klicken Sie auf **Gutscheine**. 1. Klicken Sie den gewünschten Gutschein an. 1. Klicken Sie auf das Überlaufmenü (⋯). 1. Nun klicken Sie auf **Gutschein löschen**. #### API ```curl curl -X DELETE https://api.stripe.com/v1/coupons/free-period \ -u "<>:" ``` ```cli stripe coupons delete free-period ``` ```ruby # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = Stripe::StripeClient.new("<>") deleted = client.v1.coupons.delete('free-period') ``` ```python # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = StripeClient("<>") # For SDK versions 12.4.0 or lower, remove '.v1' from the following line. deleted = client.v1.coupons.delete("free-period") ``` ```php // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys $stripe = new \Stripe\StripeClient('<>'); $deleted = $stripe->coupons->delete('free-period', []); ``` ```java // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys StripeClient client = new StripeClient("<>"); // For SDK versions 29.4.0 or lower, remove '.v1()' from the following line. Coupon coupon = client.v1().coupons().delete("free-period"); ``` ```node // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys const stripe = require('stripe')('<>'); const deleted = await stripe.coupons.del('free-period'); ``` ```go // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys sc := stripe.NewClient("<>") params := &stripe.CouponDeleteParams{} result, err := sc.V1Coupons.Delete(context.TODO(), "free-period", params) ``` ```dotnet // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys var client = new StripeClient("<>"); var service = client.V1.Coupons; Coupon deleted = service.Delete("free-period"); ``` ### Gültigkeitsdauer Die Gültigkeitsdauer gibt an, wie lange der eingelöste [Rabatt](https://docs.stripe.com/api/.md#discounts) gültig ist. So ist ein Gutschein über 50 % Rabatt mit 4 Monaten Gültigkeitsdauer ab dem Einlösedatum auf alle Rechnungen anwendbar, die in diesen Viermonatszeitraum fallen. Wird dieser Gutschein innerhalb dieses Zeitraums für ein Jahresabonnement eingelöst, wird der 50-prozentige Preisnachlass auf das gesamte Jahresabonnement angewendet. Bei monatlichen Abonnements gilt der Gutschein dagegen nur für die ersten 4 Monate. Im Falle von Abonnements mit wöchentlichem Zyklus wird ein Gutschein mit 4 Monaten Gültigkeitsdauer auf alle Rechnungen in diesen ersten 4 Monaten angerechnet. Wird die Gültigkeitsdauer in der API konfiguriert, muss bei dem Wert `repeating` unter `duration_in_months` die Anzahl der Monate eingegeben werden, die der Gutschein gültig ist. Wird als Gültigkeitsdauer dagegen `once` eingerichtet, ist der Gutschein nur für die erste Rechnung gültig. Wenn Sie die Laufzeit auf `forever` einstellen, gilt der Gutschein auf unbestimmte Zeit für alle Rechnungen. ### Einlöseobergrenzen Einlöseobergrenzen legen fest, wie oft ein Gutschein angewendet werden kann. Wird hier beispielsweise der Wert 50 festgelegt, kann der Gutschein bis zu 50 Mal angewendet werden. Dabei kann es sich um je einen einzelnen für 50 verschiedene Kund/innen, eine/n einzelne/n Kund/in oder mehrere Kund/innen handeln, die den Gutschein zusammen maximal 50 Mal einlösen können. Unbegrenzt gültige Gutscheine mit Ablaufdatum sind für ihre jeweiligen Besitzer/innen unbegrenzt gültig, können nach dem Ablaufdatum aber nicht mehr von anderen Personen angewendet werden. ## Promo-Codes Promo-Codes sind Rabatte für Kundinnen und Kunden, die Sie in Form eines Gutscheins erstellen. So können die Codes HERBSTPROMO und FRÜHJAHRSPROMO beide auf einen Gutschein über 25 % verweisen. Promo-Codes werden beim Bezahlvorgang angewendet und Sie können diese direkt mit Ihren Kundinnen und Kunden teilen. Wenn Sie das *Kundenportal* (The customer portal is a secure, Stripe-hosted page that lets your customers manage their subscriptions and billing details) implementiert und Promo-Codes aktiviert haben, können Kund/innen beim Up- oder Downgrade ihrer bestehenden Abonnements im Portal einen Rabatt anwenden. > Bei Abonnements werden Promo-Code- und Preisaktualisierungen getrennt voneinander angewendet, was zu unerwarteten Aktualisierungen führen kann. Beispielsweise kann eine fehlgeschlagene Zahlung dazu führen, dass eine Preiserhöhung fehlschlägt, der mit der Preiserhöhung enthaltene Promo-Code jedoch erfolgreich ist. > Im Kundenportal werden Aktionscodes angezeigt, die auf ein Abonnement angewendet wurden. Wenn Sie nicht möchten, dass Kund/innen den Aktionscode selbst anwenden oder möglicherweise mit anderen teilen, sollten Sie entweder [Beschränkungen für den Aktionscode festlegen](https://docs.stripe.com/billing/subscriptions/coupons.md#promo-code-config) oder direkt [einen Gutschein anwenden](https://docs.stripe.com/billing/subscriptions/coupons.md#discount-subscriptions). Konfigurieren Sie Ihre Promo-Codes, indem Sie Empfangsberechtigte, Erstbestellungen, Mindestbestellwerte, Ablaufdaten und Einlöseobergrenzen festlegen. ### Einschränkungen Für Promo-Codes gelten einige Einschränkungen. - Sie können Promo-Codes mit Höchstbeträgen nicht auf Folgendes anwenden: - [Abonnementposten-Objekte](https://docs.stripe.com/api/subscription_items/object.md) - [Rechnungsposten-Objekte](https://docs.stripe.com/api/invoiceitems/object.md) - [Abonnement-Objekte](https://docs.stripe.com/api/subscriptions/object.md), wenn Sie eine Aktualisierung vornehmen - Zukünftige Phasen von [Abonnementzeitplan-Objekten](https://docs.stripe.com/api/subscription_schedules/object.md) ### Promo-Codes erstellen #### Dashboard Promo-Codes können im Dashboard unter [Gutschein erstellen](https://docs.stripe.com/billing/subscriptions/coupons.md#create-coupons--create-coupons) erstellt werden. Bei diesem **Code** muss die Groß-/Kleinschreibung beachtet werden. Er ist unter allen offenen Promo-Codes einzigartig. Hier ein Beispiel: - Mehrere kundenspezifische Promo-Codes können mit demselben **Code** erstellt werden. Dies gilt jedoch nicht für Promo-Codes ohne Kundenbeschränkung. - Wurde bereits ein Promo-Code ohne Kundenbeschränkung erstellt, kann mit demselben **Code** also kein weiterer Promo-Code erstellt werden. - Man kann jedoch einen Promo-Code mit einem **Code** erstellen, diesen dann [deaktivieren](https://docs.stripe.com/billing/subscriptions/coupons.md#inactive-promotions--inactivate) und anschließend einen neuen Promo-Code mit demselben **Code** erstellen. 1. Im Dashboard klickt man unter [Gutschein erstellen](https://dashboard.stripe.com/test/coupons/create) auf die Schaltfläche **Kunden-Promo-Codes verwenden** 1. Geben Sie einen Code ein. Dieser wird dann im Bezahlvorgang eingegeben, um den Gutschein einzulösen. Wird kein Code eingerichtet, übernimmt Stripe diese Aufgabe für Sie. 1. Stellen Sie Einlösebedingungen auf. So können Sie den Gutschein beispielsweise auf Erstbestellungen beschränken. #### API Bei dem `code` muss die Groß-/Kleinschreibung beachtet werden. Er ist unter allen Promo-Codes einzigartig. Hier ein Beispiel: - Mehrere kundenspezifische Promo-Codes können mit demselben `code` erstellt werden. Dies gilt jedoch nicht für Promo-Codes ohne Kundenbeschränkung. - Wurde bereits ein Promo-Code ohne Kundenbeschränkung erstellt, kann mit demselben `code` also kein weiterer Promo-Code erstellt werden. - Sie können einen Promo-Code mit `code: NEWUSER` erstellen, ihn durch die Weitergabe von `active: false` deaktivieren und anschließend einen neuen Promo-Code mit `code: NEWUSER` anlegen. Um einen [Promo-Code](https://docs.stripe.com/api/promotion_codes.md) einzurichten, legen Sie einen bestehenden `coupon` sowie etwaige Beschränkungen (z. B. Beschränkung auf einen bestimmten `customer`) fest. Soll nun ein bestimmter Code (z. B. `FALL25OFF`) übermittelt werden, richten Sie dazu den `code` ein. Wenn Sie das Feld leer lassen, erstellt Stripe einen zufälligen `code` für Sie. ```curl curl https://api.stripe.com/v1/promotion_codes \ -u "<>:" \ -d coupon=ZQO00CcH \ -d code=ALICE20 \ -d customer="{{CUSTOMER_ID}}" ``` Promo-Codes übernehmen die Eckdaten des zugrunde liegenden Gutscheins. ### Promo-Codes konfigurieren In den Promo-Code-Einstellungen können Sie die folgenden Variablen verändern: - Teilnahmeberechtigte - Einlöseobergrenze - Ablaufdatum - Mindestbetrag ### Kundenbeschränkung #### Dashboard Führen Sie die folgenden Schritte aus, um einen Aktionscode auf eine bestimmte Kundin/einen bestimmten Kunden zu beschränken: 1. Wählen Sie auf der Seite [Gutschein erstellen](https://dashboard.stripe.com/test/coupons/create) die Option **Auf eine bestimmte Kundin/einen bestimmten Kunden beschränken** aus. 1. Wählen Sie den entsprechenden Kunden/die entsprechende Kundin aus. Wenn Sie keine bestimmte Kundin/keine bestimmten Kunden angeben, kann jede/r Kund/in den Promo-Code einlösen. #### API Um einen Promo-Code auf eine/n bestimmte/n Kund/in zu beschränken, geben Sie beim Erstellen des Promo-Codes einen `customer` an. Wenn Sie keine bestimmte Kundin/keinen bestimmten Kunden angeben, kann jede/r Kund/in den Promo-Code einlösen. ### Erstbestellungen Beschränkt den Gutschein auf Kunden, die noch keine Transaktionshistorie auf Ihrer Plattform haben. Diese Einstellung verhindert, dass Kunden den Gutschein verwenden, wenn Folgendes auf sie zutrifft: - Sie haben einen PaymentIntent initiiert, auch wenn die Zahlung nie abgeschlossen wurde. - Sie haben ein Abonnement für einen Testzeitraum, auch wenn es später gekündigt wurde. #### Dashboard Um einen Aktionscode auf Erstkunden zu beschränken, wählen Sie auf der Seite [Erstellen eines Gutschein](https://dashboard.stripe.com/test/coupons/create) die Option **Nur für erstmalige Bestellung**. #### API Beschränken Sie den Aktionscode auf Erstkunden, indem Sie den Parameter `first_time_transaction` des Attributs `restrictions` festlegen. ### Mindestbestellwert #### Dashboard Um einen Mindestbetrag für einen Promo-Code festzulegen, gehen Sie unter [Gutschein erstellen](https://dashboard.stripe.com/test/coupons/create) auf **Mindestbestellwert erforderlich** und geben Sie einen Mindestbetrag ein. Da die Erfüllung der Code-Bedingungen beim Einlösen überprüft wird, gilt der Mindestbestellwert bei Abonnements nur für die erste Zahlung. Wenn der Coupon mehrere Währungen unterstützt, kann der Mindestbetrag pro Währung unterschiedlich ausfallen. #### API Bei Promo-Codes können Sie einen Mindesttransaktionsbetrag für einen berechtigten Rabatt festlegen, indem Sie die Eigenschaften `minimum_amount` und `minimum_amount_currency` konfigurieren. Da die Einschränkungen des Promo-Codes zum Zeitpunkt der Einlösung geprüft werden, gilt der Mindesttransaktionsbetrag nur für die Erstzahlung eines Abonnements. Wenn Sie Verkäufe in mehreren Währungen tätigen, legen Sie den Mindesttransaktionsbetrag für verschiedene Währungen fest, indem Sie die Eigenschaft `currency_options` konfigurieren. ### Ablaufdatum #### Dashboard Um ein Ablaufdatum für einen Promo-Code festzulegen, gehen Sie unter [Gutschein erstellen](https://dashboard.stripe.com/test/coupons/create) auf **Ablaufdatum hinzufügen** und geben ein Datum ein, an dem der Gutschein abläuft. Liegt für den betreffenden Gutschein bereits ein Ablaufdatum vor, kann das Ablaufdatum des Promo-Codes nicht später als das des Gutscheins liegen. Beispiel: Ein Gutschein soll ein Jahr lang angeboten werden, jedoch nur eine Woche ab dem Empfang einlösbar sein. In diesem Fall würden Sie das Ablaufdatum des Gutscheins ein Jahr in die Zukunft verlegen, das des Promo-Codes dagegen auf eine Woche nach seiner Erstellung. #### API Mit `expires_at` kann man ein Ablaufdatum für den Promo-Code festlegen. Wurde für den zugrunde liegenden Gutschein bereits ein `redeem_by` eingerichtet, kann das Ablaufdatum des Promo-Codes nicht später sein als Ablaufdatum des Gutscheins. Wird `promotion_code[expires_at]` nicht festgelegt, wird `expires_at` automatisch mit dem `redeem_by`-Wert des Gutscheins ausgefüllt. - Beispiel: Ein Gutschein soll ein Jahr lang angeboten werden, jedoch nur eine Woche ab dem Empfang einlösbar sein. In diesem Fall würden Sie `coupon[redeem_by]` ein Jahr in die Zukunft verlegen, `promotion_code[expires_at]` dagegen auf eine Woche nach seiner Erstellung. ### Einlöseobergrenzen #### Dashboard Um festzulegen, wie oft der Aktionscode von Ihren Kundinnen und Kunden insgesamt eingelöst werden kann, wählen Sie auf der Seite [Gutschein erstellen](https://dashboard.stripe.com/test/coupons/create) die Option **Anzahl der Einlösungen dieses Codes begrenzen** und geben Sie die Anzahl ein. Weitere Informationen finden Sie unter [Einlösungslimits](https://docs.stripe.com/billing/subscriptions/coupons.md#redemption-limits). Weist der zugrunde liegende Gutschein bereits eine Einlöseobergrenze auf, kann die des Promo-Codes nicht darüber liegen. #### API Begrenzen Sie die Gesamtzahl der Male, die ein Aktionscode von Ihren Kundinnen und Kunden eingelöst werden kann, indem Sie `max_redemptions` verwenden, was ähnlich wie bei Gutscheinen funktioniert. Wenn für den zugrundeliegenden Gutschein bereits die Anzahl der `max_redemptions` festgelegt wurde, darf bei dem Aktionscode die Anzahl der `max_redemptions` nicht größer sein als bei dem Gutschein. Siehe [Einlösungslimits](https://docs.stripe.com/billing/subscriptions/coupons.md#redemption-limits) für weitere Informationen. ### Promo-Codes deaktivieren #### Dashboard So können Sie Promo-Codes wieder deaktivieren: 1. Navigieren Sie im Dashboard zum Abschnitt [Produkte](https://dashboard.stripe.com/test/products?active=true). 1. Klicken Sie auf **Gutscheine**. 1. Klicken Sie den Gutschein an, dessen Promo-Code ausgesetzt werden soll. 1. Klicken Sie in der entsprechenden Zeile mit dem Promo-Code auf das Überlaufmenü (⋯). 1. Anschließend klicken Sie auf **Promo-Code archivieren**. Wenn allerdings der zugrunde liegende Gutschein für einen Promo-Code ungültig wird, werden auch alle verknüpften Promo-Codes dauerhaft inaktiv. Ein Promo-Code wird auch dann dauerhaft inaktiv, wenn Einlöseobergrenze oder Ablaufdatum erreicht sind. Diese Promo-Codes können nicht wieder aktiviert werden. #### API Mit dem Parameter `active` können Sie festlegen, ob ein Promo-Code aktuell einlösbar sein soll. Wenn allerdings der zugrunde liegende Gutschein für einen Promo-Code ungültig wird, werden auch alle verknüpften Promo-Codes dauerhaft inaktiv. Ein Promo-Code wird auch dann dauerhaft inaktiv, wenn `max_redemptions` oder `expires_at` erreicht sind. Diese Promo-Codes können nicht reaktiviert werden. ### Promo-Codes auf Abonnements anwenden Nachdem Sie einen Promo-Code erstellt haben, können Sie einen Rabatt einlösen, indem Sie den Promo-Code auf ein Abonnement anwenden. Für die Anwendung von Promo-Codes gibt es zwei Möglichkeiten: - [Neuerstellung eines Abonnements](https://docs.stripe.com/api.md#create_subscription) - [Aktualisierung eines bestehenden Kundenabonnements](https://docs.stripe.com/api.md#update_subscription) #### Dashboard 1. Navigieren Sie im Dashboard zu **Billing** > **Abonnements**. 1. Klicken Sie das jeweilige Abonnement an. 1. Klicken Sie auf **Aktionen** > **Abonnement aktualisieren** > **Gutschein hinzufügen**. 1. Wählen Sie einen Aktionscode im Dropdown-Menü aus und klicken Sie auf **Absenden**. #### API 1. [Listen Sie](https://docs.stripe.com/api/promotion_codes/list.md) die Aktionscodes auf und verwenden Sie den [Code](https://docs.stripe.com/api/promotion_codes/list.md#list_promotion_code-code) Ihres Kunden/Ihrer Kundin als Filter, um die [Aktionscode-ID](https://docs.stripe.com/api/promotion_codes/object.md#promotion_code_object-id) [abzurufen](https://docs.stripe.com/api/promotion_codes/retrieve.md). 1. Um den Aktionscode einzulösen, verwenden Sie die Aktionscode-ID im folgenden API-Aufruf: ```curl curl https://api.stripe.com/v1/subscriptions \ -u "<>:" \ -d customer="{{CUSTOMER_ID}}" \ -d "items[0][price]"="{{PRICE_ID}}" \ -d "discounts[0][promotion_code]"="{{PROMOTIONCODE_ID}}" ``` ```cli stripe subscriptions create \ --customer="{{CUSTOMER_ID}}" \ -d "items[0][price]"="{{PRICE_ID}}" \ -d "discounts[0][promotion_code]"="{{PROMOTIONCODE_ID}}" ``` ```ruby # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = Stripe::StripeClient.new("<>") subscription = client.v1.subscriptions.create({ customer: '{{CUSTOMER_ID}}', items: [{price: '{{PRICE_ID}}'}], discounts: [{promotion_code: '{{PROMOTIONCODE_ID}}'}], }) ``` ```python # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = StripeClient("<>") # For SDK versions 12.4.0 or lower, remove '.v1' from the following line. subscription = client.v1.subscriptions.create({ "customer": "{{CUSTOMER_ID}}", "items": [{"price": "{{PRICE_ID}}"}], "discounts": [{"promotion_code": "{{PROMOTIONCODE_ID}}"}], }) ``` ```php // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys $stripe = new \Stripe\StripeClient('<>'); $subscription = $stripe->subscriptions->create([ 'customer' => '{{CUSTOMER_ID}}', 'items' => [['price' => '{{PRICE_ID}}']], 'discounts' => [['promotion_code' => '{{PROMOTIONCODE_ID}}']], ]); ``` ```java // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys StripeClient client = new StripeClient("<>"); SubscriptionCreateParams params = SubscriptionCreateParams.builder() .setCustomer("{{CUSTOMER_ID}}") .addItem( SubscriptionCreateParams.Item.builder().setPrice("{{PRICE_ID}}").build() ) .addDiscount( SubscriptionCreateParams.Discount.builder() .setPromotionCode("{{PROMOTIONCODE_ID}}") .build() ) .build(); // For SDK versions 29.4.0 or lower, remove '.v1()' from the following line. Subscription subscription = client.v1().subscriptions().create(params); ``` ```node // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys const stripe = require('stripe')('<>'); const subscription = await stripe.subscriptions.create({ customer: '{{CUSTOMER_ID}}', items: [ { price: '{{PRICE_ID}}', }, ], discounts: [ { promotion_code: '{{PROMOTIONCODE_ID}}', }, ], }); ``` ```go // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys sc := stripe.NewClient("<>") params := &stripe.SubscriptionCreateParams{ Customer: stripe.String("{{CUSTOMER_ID}}"), Items: []*stripe.SubscriptionCreateItemParams{ &stripe.SubscriptionCreateItemParams{Price: stripe.String("{{PRICE_ID}}")}, }, Discounts: []*stripe.SubscriptionCreateDiscountParams{ &stripe.SubscriptionCreateDiscountParams{ PromotionCode: stripe.String("{{PROMOTIONCODE_ID}}"), }, }, } result, err := sc.V1Subscriptions.Create(context.TODO(), params) ``` ```dotnet // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys var options = new SubscriptionCreateOptions { Customer = "{{CUSTOMER_ID}}", Items = new List { new SubscriptionItemOptions { Price = "{{PRICE_ID}}" }, }, Discounts = new List { new SubscriptionDiscountOptions { PromotionCode = "{{PROMOTIONCODE_ID}}" }, }, }; var client = new StripeClient("<>"); var service = client.V1.Subscriptions; Subscription subscription = service.Create(options); ``` ### Promo-Codes zu Checkout hinzufügen Aktivieren Sie Promo-Codes mit der API, indem Sie den Parameter [allow_promotion_codes](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-allow_promotion_codes) in Checkout. Wenn `allow_promotion_codes` in einer Checkout-Sitzung aktiviert ist, enthält Checkout ein Feld zum Einlösen von Promo-Codes, das Ihre Kund: innen nutzen können. ![Eingabefeld im Bezahlvorgang](https://b.stripecdn.com/docs-statics-srv/assets/promo_code_checkout.c07ef6d4f0b1b3f9a8a7e4bbba83d56f.png) Eingabefeld im Bezahlvorgang ## Kombinierbare Gutscheine und Promo-Codes Sie können der Zahlungsliste einer Kundin/eines Kunden mehrere Gutscheine, Promo-Codes oder eingelöste [Rabatte](https://docs.stripe.com/api/.md#discounts) hinzufügen. Dies können Sie tun, [während Sie ein Abonnement erstellen](https://docs.stripe.com/api.md#create_subscription) oder indem Sie ein [bestehendes Kundenabonnement aktualisieren](https://docs.stripe.com/api.md#update_subscription). Wir unterstützen mehrere Rabatte für Abonnements und einzelne Abonnementposten. Wenn Sie ein Abonnement mit kombinierbaren Rabatten erstellen, gilt jeder Rabatt für alle Artikel im Abonnement. Die Reihenfolge der Rabatte ist wichtig, wenn Sie sowohl `amount_off` als auch `percent_off` verwenden. Beispielsweise werden die folgenden kombinierbaren Rabatte unterschiedlich angewendet: - 20 % Rabatt *, dann* 5 USD Rabatt - 5 USD Rabatt *, dann* 20 % Rabatt #### Dashboard 1. Navigieren Sie im Dashboard zu **Billing** > **Abonnements**. 1. Klicken Sie das jeweilige Abonnement an. 1. Klicken Sie auf **Aktionen** > **Abonnement aktualisieren** > **Gutschein hinzufügen**. 1. Wählen Sie die gewünschten Gutscheine in den Dropdown-Menüs aus und klicken Sie auf **Absenden**. 1. Klicken Sie das gewünschte Produkt an. 1. Klicken Sie auf **Gutscheine hinzufügen**. 1. Wählen Sie die gewünschten Gutscheine in den Dropdown-Menüs aus und klicken Sie auf **Absenden**. #### API ```curl curl https://api.stripe.com/v1/subscriptions \ -u "<>:" \ -d customer="{{CUSTOMER_ID}}" \ -d "items[0][price]"="{{PRICE_ID}}" \ -d "items[0][discounts][0][coupon]"=item-coupon \ -d "items[0][discounts][1][promotion_code]"=item-promo \ -d "discounts[0][coupon]"=sub-coupon \ -d "discounts[1][promotion_code]"=sub-promo ``` ```cli stripe subscriptions create \ --customer="{{CUSTOMER_ID}}" \ -d "items[0][price]"="{{PRICE_ID}}" \ -d "items[0][discounts][0][coupon]"=item-coupon \ -d "items[0][discounts][1][promotion_code]"=item-promo \ -d "discounts[0][coupon]"=sub-coupon \ -d "discounts[1][promotion_code]"=sub-promo ``` ```ruby # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = Stripe::StripeClient.new("<>") subscription = client.v1.subscriptions.create({ customer: '{{CUSTOMER_ID}}', items: [ { price: '{{PRICE_ID}}', discounts: [{coupon: 'item-coupon'}, {promotion_code: 'item-promo'}], }, ], discounts: [{coupon: 'sub-coupon'}, {promotion_code: 'sub-promo'}], }) ``` ```python # Set your secret key. Remember to switch to your live secret key in production. # See your keys here: https://dashboard.stripe.com/apikeys client = StripeClient("<>") # For SDK versions 12.4.0 or lower, remove '.v1' from the following line. subscription = client.v1.subscriptions.create({ "customer": "{{CUSTOMER_ID}}", "items": [ { "price": "{{PRICE_ID}}", "discounts": [{"coupon": "item-coupon"}, {"promotion_code": "item-promo"}], }, ], "discounts": [{"coupon": "sub-coupon"}, {"promotion_code": "sub-promo"}], }) ``` ```php // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys $stripe = new \Stripe\StripeClient('<>'); $subscription = $stripe->subscriptions->create([ 'customer' => '{{CUSTOMER_ID}}', 'items' => [ [ 'price' => '{{PRICE_ID}}', 'discounts' => [['coupon' => 'item-coupon'], ['promotion_code' => 'item-promo']], ], ], 'discounts' => [['coupon' => 'sub-coupon'], ['promotion_code' => 'sub-promo']], ]); ``` ```java // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys StripeClient client = new StripeClient("<>"); SubscriptionCreateParams params = SubscriptionCreateParams.builder() .setCustomer("{{CUSTOMER_ID}}") .addItem( SubscriptionCreateParams.Item.builder() .setPrice("{{PRICE_ID}}") .addDiscount( SubscriptionCreateParams.Item.Discount.builder() .setCoupon("item-coupon") .build() ) .addDiscount( SubscriptionCreateParams.Item.Discount.builder() .setPromotionCode("item-promo") .build() ) .build() ) .addDiscount( SubscriptionCreateParams.Discount.builder().setCoupon("sub-coupon").build() ) .addDiscount( SubscriptionCreateParams.Discount.builder().setPromotionCode("sub-promo").build() ) .build(); // For SDK versions 29.4.0 or lower, remove '.v1()' from the following line. Subscription subscription = client.v1().subscriptions().create(params); ``` ```node // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys const stripe = require('stripe')('<>'); const subscription = await stripe.subscriptions.create({ customer: '{{CUSTOMER_ID}}', items: [ { price: '{{PRICE_ID}}', discounts: [ { coupon: 'item-coupon', }, { promotion_code: 'item-promo', }, ], }, ], discounts: [ { coupon: 'sub-coupon', }, { promotion_code: 'sub-promo', }, ], }); ``` ```go // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys sc := stripe.NewClient("<>") params := &stripe.SubscriptionCreateParams{ Customer: stripe.String("{{CUSTOMER_ID}}"), Items: []*stripe.SubscriptionCreateItemParams{ &stripe.SubscriptionCreateItemParams{ Price: stripe.String("{{PRICE_ID}}"), Discounts: []*stripe.SubscriptionCreateItemDiscountParams{ &stripe.SubscriptionCreateItemDiscountParams{ Coupon: stripe.String("item-coupon"), }, &stripe.SubscriptionCreateItemDiscountParams{ PromotionCode: stripe.String("item-promo"), }, }, }, }, Discounts: []*stripe.SubscriptionCreateDiscountParams{ &stripe.SubscriptionCreateDiscountParams{Coupon: stripe.String("sub-coupon")}, &stripe.SubscriptionCreateDiscountParams{PromotionCode: stripe.String("sub-promo")}, }, } result, err := sc.V1Subscriptions.Create(context.TODO(), params) ``` ```dotnet // Set your secret key. Remember to switch to your live secret key in production. // See your keys here: https://dashboard.stripe.com/apikeys var options = new SubscriptionCreateOptions { Customer = "{{CUSTOMER_ID}}", Items = new List { new SubscriptionItemOptions { Price = "{{PRICE_ID}}", Discounts = new List { new SubscriptionItemDiscountOptions { Coupon = "item-coupon" }, new SubscriptionItemDiscountOptions { PromotionCode = "item-promo" }, }, }, }, Discounts = new List { new SubscriptionDiscountOptions { Coupon = "sub-coupon" }, new SubscriptionDiscountOptions { PromotionCode = "sub-promo" }, }, }; var client = new StripeClient("<>"); var service = client.V1.Subscriptions; Subscription subscription = service.Create(options); ``` ### Einschränkungen Es gelten einige Einschränkungen für die Verwendung mit mehreren Rabatten. - Sie können bis zu 20 Einträge im Parameter `discounts` festlegen. - Jeder Eintrag unter `discounts` muss einzigartig sein. - Sie können einen Gutschein und einen Promo-Code nicht übergeben, wenn diese aus demselben Gutschein stammen. - Sie können einen Gutschein und einen Rabatt nicht übergeben, wenn diese aus demselben Gutschein stammen. - Eingelöste Rabatte müssen bereits mit der Kundin/dem Kunden oder dem Abonnement verknüpft sein, das Sie aktualisieren. ### Abonnement aktualisieren Sie müssen keine `discounts` festlegen, wenn Sie keine Änderungen an bestehenden Rabatten vornehmen möchten. Bei der Aktualisierung von `discounts` müssen Sie alle zuvor festgelegten Optionen für `coupon`, `promotion_code` oder `discount` übergeben, die in das Abonnement übernommen werden sollen. Übergeben Sie `discounts = ""`, um alle Rabatte aus dem Abonnement zu löschen. Wenn für ein Abonnement keine Rabatte angegeben sind, wird auf den Rechnungen der Rabatt auf Kundenebene angegeben, falls einer vorhanden ist. Wenn Sie bereits mehr als einen Rabatt für ein Abonnement mit dem neuen Parameter `discounts` festgelegt haben, können Sie das Abonnement nicht mit den veralteten Parametern `coupon` oder `promotion_code` aktualisieren. Ebenso können Sie die Phasen eines Zeitplans nicht mit den veralteten Parametern `coupon` oder `promotion_code` aktualisieren, wenn Sie mehr als einen Rabatt für eine frühere Phase festgelegt haben. Durch die Aktualisierung von `discounts` fallen keine anteilmäßigen Gebühren an und es wird auch keine gesonderte Rechnung erstellt. Die neuen Rabatte werden angewendet, wenn die nächste Abo-Rechnung planmäßig erstellt wird. ## Alternative Rabattverfahren Gutscheine sind das gängigste Verfahren für Rabatte auf Abonnements. Es gibt aber auch noch die folgenden Möglichkeiten: - Negatives [Kundensaldo](https://docs.stripe.com/api.md#customer_object-balance). - Negative [Rechnungsposten](https://docs.stripe.com/billing/invoices/subscription.md#adding-draft-invoice-items). - [Alternativpreise](https://docs.stripe.com/products-prices/manage-prices.md#create-price) unterhalb des üblichen Produktpreises. Dabei bieten negative Rechnungsposten die Möglichkeit, genau aufzuschlüsseln, welcher Rabatt zu welchem Zeitpunkt aus welchem Grund angewendet wurde. ## See also - [Abonnements ändern](https://docs.stripe.com/billing/subscriptions/change.md) - [Mit Rechnungen arbeiten](https://docs.stripe.com/billing/invoices/subscription.md) - [Coupons API](https://docs.stripe.com/api.md#coupons) - [Promotion Codes API](https://docs.stripe.com/api.md#promotion_codes)