# Ein Abonnement per iDEAL und SEPA-Lastschriftverfahren einrichten Erfahren Sie, wie Sie ein Abonnement mit iDEAL und SEPA-Lastschriftverfahren erstellen und abrechnen können. # Vollständige gehostete Seite Bei iDEAL handelt es sich um eine Zahlungsmethode für die [einmalige Nutzung](https://docs.stripe.com/payments/payment-methods.md#usage), bei der Kundinnen/Kunden jede Zahlung [authentifizieren](https://docs.stripe.com/payments/payment-methods.md#customer-actions) müssen. Nachdem Ihre Kundinnen/Kunden die Zahlung authentifiziert haben, speichert Stripe die [IBAN](https://en.wikipedia.org/wiki/International_Bank_Account_Number) Ihrer Kundinnen/Kunden in einer [SEPA-Lastschrift](https://docs.stripe.com/payments/sepa-debit.md)-Zahlungsmethode. Sie können dann die Zahlungsmethode SEPA-Lastschrift verwenden, um [zukünftige Zahlungen anzunehmen](https://docs.stripe.com/payments/sepa-debit/accept-a-payment.md). Sehen Sie sich das [Beispiel auf GitHub](https://github.com/stripe-samples/checkout-single-subscription) an oder probieren Sie die [Demo](https://checkout.stripe.dev/checkout) aus. Verwenden Sie diesen Leitfaden, um ein *Abonnement* mit iDEAL und *Checkout* (A low-code payment integration that creates a customizable form for collecting payments. You can embed Checkout directly in your website, redirect customers to a Stripe-hosted payment page, or create a customized checkout page with Stripe Elements) einzurichten. Mit dieser Integration berechnet Stripe die erste Abonnementzahlung über iDEAL, um die Bankdaten Ihres Kunden/Ihrer Kundin zu erfassen. Wenn Sie eine kostenlose Testversion anbieten, berechnet Stripe Ihrem Kunden/Ihrer Kundin über iDEAL 0,01 EUR, um seine/ihre Bankdaten zu erfassen, und erstattet diesen Betrag umgehend zurück. Eine [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions.md) stellt die näheren Angaben zur Kaufabsicht Ihres Kunden/Ihrer Kundin dar. Sie erstellen eine Checkout-Sitzung, wenn Ihr Kunde/Ihre Kundin ein Abo starten möchte. Nachdem Sie ihn/sie zu einer Checkout-Sitzung weitergeleitet haben, zeigt Stripe ein Zahlungsformular an, von dem aus Ihre Kundin oder Ihr Kunde den Kauf abschließen kann. Sobald Ihre Kundin oder Ihr Kunde den Kauf abgeschlossen hat, wird sie oder er wieder zurück zu Ihrer Seite geleitet. ## Stripe einrichten [Serverseitig] Installieren Sie den Stripe-Client Ihrer Wahl: #### Ruby ```bash # Available as a gem sudo gem install stripe ``` ```ruby # If you use bundler, you can add this line to your Gemfile gem 'stripe' ``` Installieren Sie die Stripe-CLI (optional). Die CLI ermöglicht [Webhook-Tests](https://docs.stripe.com/webhooks.md#test-webhook) und kann zum Erstellen Ihrer Produkte und Preise ausgeführt werden. Geben Sie in der Befehlszeile ein Installationsskript an oder laden Sie eine versionierte Archivdatei für Ihr Betriebssystem herunter und extrahieren Sie diese, um die CLI zu installieren. #### Homebrew Führen Sie zur Installation der Stripe-CLI mit [Homebrew](https://brew.sh/) Folgendes aus: ```bash brew install stripe/stripe-cli/stripe ``` Dieser Befehl schlägt fehl, wenn Sie ihn auf der Linux-Version von Homebrew ausführen, aber Sie können diese Alternative verwenden oder den Anweisungen auf der Registerkarte „Linux“ folgen. ```bash brew install stripe-cli ``` #### apt > Der Debian-Build für die CLI ist auf JFrog unter https://packages.stripe.dev, verfügbar. Bei dieser Domain handelt es sich nicht um eine Stripe-Domain. Wenn Sie diese URL besuchen, werden Sie zur Jfrog Artifactory-Liste weitergeleitet. So installieren Sie die Stripe-CLI auf Debian- und Ubuntu-basierten Distributionen: 1. Fügen Sie den GPG-Schlüssel der Stripe-CLI zum Schlüsselbund der apt-Quellen hinzu: ```bash curl -s https://packages.stripe.dev/api/security/keypair/stripe-cli-gpg/public | gpg --dearmor | sudo tee /usr/share/keyrings/stripe.gpg > /dev/null ``` 1. Fügen Sie das apt-Repository der CLI zur Liste der apt-Quellen hinzu: ```bash echo "deb [signed-by=/usr/share/keyrings/stripe.gpg] https://packages.stripe.dev/stripe-cli-debian-local stable main" | sudo tee -a /etc/apt/sources.list.d/stripe.list ``` 1. Aktualisieren Sie die Paketliste: ```bash sudo apt update ``` 1. Installieren Sie die CLI: ```bash sudo apt install stripe ``` #### YUM > Der RPM-Build für die CLI ist auf JFrog unter https://packages.stripe.dev, verfügbar. Bei dieser Domain handelt es sich nicht um eine Stripe-Domain. Wenn Sie diese URL besuchen, werden Sie zur Jfrog Artifactory-Liste weitergeleitet. So installieren Sie die Stripe-CLI auf PM-basierten Distributionen: 1. Fügen Sie das yum-Repository der CLI zur Liste der yum-Quellen hinzu: ```bash echo -e "[Stripe]\nname=stripe\nbaseurl=https://packages.stripe.dev/stripe-cli-rpm-local/\nenabled=1\ngpgcheck=0" >> /etc/yum.repos.d/stripe.repo ``` 1. Installieren Sie die CLI: ```bash sudo yum install stripe ``` #### Scoop Führen Sie zur Installation der Stripe-CLI mit [Scoop](https://scoop.sh/) Folgendes aus: ```bash scoop bucket add stripe https://github.com/stripe/scoop-stripe-cli.git ``` ```bash scoop install stripe ``` #### macOS So installieren Sie die Stripe-CLI auf macOS ohne Homebrew: 1. Laden Sie die neueste tar.gz-Datei Ihres CPU-Architekturtyps für `mac-os` von [GitHub](https://github.com/stripe/stripe-cli/releases/latest) herunter. 1. Dekomprimieren Sie die Datei: `tar -xvf stripe_[XXX]_mac-os_[ARCH_TYPE].tar.gz`. Installieren Sie optional die Binärdatei in einem Verzeichnis, in dem Sie sie global ausführen können (zum Beispiel `/usr/local/bin`). #### Linux So installieren Sie die Stripe-CLI unter Linux ohne einen Paketmanager: 1. Laden Sie die neueste tar.gz-Datei für `linux` von [GitHub](https://github.com/stripe/stripe-cli/releases/latest) herunter. 1. Dekomprimieren Sie die Datei: `tar -xvf stripe_X.X.X_linux_x86_64.tar.gz`. 1. Verschieben Sie `./stripe` in Ihren Ausführungspfad. #### Windows Führen Sie zur Installation der Stripe-CLI unter Windows ohne Scoop Folgendes aus: 1. Laden Sie die neueste Zip-Datei für `windows` von [GitHub](https://github.com/stripe/stripe-cli/releases/latest) herunter. 1. Dekomprimieren Sie die Datei `stripe_X.X.X_windows_x86_64.zip`. 1. Fügen Sie den Pfad zur dekomprimierten `stripe.exe`-Datei zu Ihrer Umgebungsvariable `Path` hinzu. Informationen zum Aktualisieren von Umgebungsvariablen finden Sie in der [Microsoft PowerShell-Dokumentation](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_environment_variables?view=powershell-7.3#saving-changes-to-environment-variables). > Windows-Antivirenscanner kennzeichnen die Stripe-CLI gelegentlich als unsicher. Dies ist wahrscheinlich ein Fehlalarm. Weitere Informationen finden Sie unter [Problem #692](https://github.com/stripe/stripe-cli/issues/692) im GitHub-Repository. 1. Führen Sie die dekomprimierte `.exe`-Datei aus. #### Docker Die Stripe-CLI ist auch als [Docker Image](https://hub.docker.com/r/stripe/stripe-cli) verfügbar. Führen Sie zur Installation der neuesten Version Folgendes aus: ```bash docker run --rm -it stripe/stripe-cli:latest ``` Um die Stripe-CLI auszuführen, müssen Sie sie außerdem mit Ihrem Stripe-Konto koppeln. Führen Sie `stripe login` aus und befolgen Sie die Anweisungen. Weitere Informationen finden Sie auf der [Dokumentationsseite zur Stripe-CLI](https://docs.stripe.com/stripe-cli.md). ## Preismodell erstellen [Dashboard] [Stripe-CLI] [Wiederkehrende Preismodelle](https://docs.stripe.com/products-prices/pricing-models.md) umfassen die Produkte und Dienstleistungen, die Sie anbieten, die Preise dafür, welche Währungen Sie für Zahlungen verwenden und den Leistungszeitraum (für Abos). Verwenden Sie zum Aufbau des Preismodells [Produkte](https://docs.stripe.com/api/products.md) (was Sie anbieten) und [Preise](https://docs.stripe.com/api/prices.md) (Höhe und Abrechnungsintervall). In diesem Beispiel wird ein Pauschalpreisdienst mit zwei verschiedenen Service-Optionen verwendet: Basis und Premium. Für jede Service-Option müssen Sie ein Produkt und einen wiederkehrenden Preis erstellen. Um eine einmalige Gebühr, z. B. für die Einrichtung, hinzufügen möchten, erstellen Sie ein drittes Produkt mit einem einmaligen Preis. Jedes Produkt wird in monatlichen Intervallen abgerechnet. Der Preis für das Basisprodukt beträgt 5 EUR. Der Preis für das Premiumprodukt beträgt 15 EUR. Ein Beispiel mit drei Stufen finden Sie im Leitfaden zu [Pauschalpreismodellen](https://docs.stripe.com/subscriptions/pricing-models/flat-rate-pricing.md). #### Dashboard Gehen Sie zur Seite [Produkt hinzufügen](https://dashboard.stripe.com/test/products/create) und erstellen Sie zwei Produkte. Fügen Sie für jedes Produkt einen Preis hinzu, jeweils mit einem monatlich wiederkehrenden Abrechnungszeitraum: - Premium-Produkt: Premium-Dienstleistung mit zusätzlichen Funktionen - Preis: Pauschalpreis | 15 EUR - Basic-Produkt: Basic-Dienstleistung mit minimalem Funktionsumfang - Preis: Pauschalpreis | 5 EUR Zeichnen Sie nach Erstellung der Preise die Preis-IDs auf, sodass diese in anderen Schritten verwendet werden können. Preis-IDs sehen in etwa wie folgt aus: `price_G0FvDp6vZvdwRZ`. Wenn Sie bereit sind, verwenden Sie die Schaltfläche **In Live-Modus kopieren** oben rechts auf der Seite, um Ihr Produkt aus der [Sandbox in den Live-Modus zu kopieren](https://docs.stripe.com/keys.md#test-live-modes). #### API Sie können die API zum Erstellen der [Produkte](https://docs.stripe.com/api/products.md) und [Preise](https://docs.stripe.com/api/prices.md) verwenden. Premiumprodukt erstellen: ```curl curl https://api.stripe.com/v1/products \ -u "<>:" \ --data-urlencode "name=Billing Guide: Premium Service" \ -d "description=Premium service with extra features" ``` Basisprodukt erstellen: ```curl curl https://api.stripe.com/v1/products \ -u "<>:" \ --data-urlencode "name=Billing Guide: Basic Service" \ -d "description=Basic service with minimum features" ``` Zeichnen Sie Preis-ID für jedes Produkt auf. Die Preis-IDs sehen in etwa wie folgt aus: ```json { "id": "prod_H94k5odtwJXMtQ", "object": "product", "active": true, "attributes": [ ], "created": 1587577341, "description": "Premium service with extra features", "images": [ ], "livemode": false, "metadata": { }, "name": "Billing Guide: Premium Service", "statement_descriptor": null, "type": "service", "unit_label": null, "updated": 1587577341 } ``` Verwenden Sie die Produkt-IDs, um einen Preis für jedes Produkt zu erstellen. Die Zahl [unit_amount](https://docs.stripe.com/api/prices/object.md#price_object-unit_amount) wird in Cent angegeben, also z. B.`1500` = 15 EUR. Premiumpreis erstellen: ```curl curl https://api.stripe.com/v1/prices \ -u "<>:" \ -d product={{PREMIUM_PRODUCT_ID}} \ -d unit_amount=1500 \ -d currency=usd \ -d "recurring[interval]=month" ``` Basispreis erstellen: ```curl curl https://api.stripe.com/v1/prices \ -u "<>:" \ -d product={{BASIC_PRODUCT_ID}} \ -d unit_amount=500 \ -d currency=usd \ -d "recurring[interval]=month" ``` Zeichnen Sie Preis-ID für jeden Preis auf, sodass diese in nachfolgenden Schritten verwendet werden können. Die Preis-IDs sehen in etwa wie folgt aus: ```json { "id": "price_HGd7M3DV3IMXkC", "object": "price", "product": "prod_HGd6W1VUqqXGvr", "type": "recurring", "currency": "eur", "recurring": { "interval": "month", "interval_count": 1, "trial_period_days": null, "usage_type": "licensed" }, "active": true, "billing_scheme": "per_unit", "created": 1589319695, "livemode": false, "lookup_key": null, "metadata": {}, "nickname": null, "unit_amount": 1500, "unit_amount_decimal": "1500", "tiers": null, "tiers_mode": null, "transform_quantity": null } ``` Informationen zu anderen Preismodellen finden Sie in den [Billing-Beispielen](https://docs.stripe.com/products-prices/pricing-models.md). ## Checkout-Sitzung erstellen [Clientseitig] [Serverseitig] Fügen Sie Ihrer Website eine Checkout-Schaltfläche hinzu, die einen serverseitigen Endpoint aufruft, um eine Checkout-Sitzung zu erstellen. ```html Checkout
``` ### Checkout-Sitzungsparameter Eine vollständige Liste der Parameter, die übergeben werden können, finden Sie unter [Sitzung erstellen](https://docs.stripe.com/api/checkout/sessions/create.md). Erstellen Sie eine Sitzung mit der ID eines vorhandenen *Preises* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions). Stellen Sie sicher, dass der Modus auf `subscription` gesetzt ist und dass Sie mindestens einen wiederkehrenden Preis übergeben. Zusätzlich zu wiederkehrenden Preisen können Sie auch einmalige Preise hinzufügen. Nachdem Sie die Checkout-Sitzung erstellt haben, leiten Sie Ihre Kundinnen/Kunden an die in der Antwort zurückgegebene [URL](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-url) weiter. Beim Erstellen einer Sitzung können Sie `payment_method_types` angeben oder Stripe automatisch Zahlungsmethoden basierend auf Ihren [Dashboard](https://dashboard.stripe.com/settings/payment_methods)-Einstellungen auswählen lassen. Wenn Sie `payment_method_types` nicht angeben, müssen Sie wiederkehrende iDEAL-Zahlungen im [Dashboard](https://dashboard.stripe.com/settings/payment_methods) aktivieren. Dadurch wird die SEPA-Lastschrift nur für wiederkehrende iDEAL-Zahlungen aktiviert, aber nicht die SEPA-Lastschrift als eigenständige Zahlungsmethode. #### Zahlungsmethoden manuell auflisten #### cURL ```bash curl https://api.stripe.com/v1/checkout/sessions \ -u <>: \ -d "payment_method_types[]"="ideal" \ -d "line_items[][price]"="{{PRICE_ID}}" \ -d "line_items[][quantity]"=1 \ -d "mode"="subscription" \ -d "success_url"="https://example.com/success?session_id={CHECKOUT_SESSION_ID}" \ ``` #### Zahlungsmethoden über das Dashboard verwalten #### cURL ```bash curl https://api.stripe.com/v1/checkout/sessions \ -u <>: \ -d "line_items[][price]"="{{PRICE_ID}}" \ -d "line_items[][quantity]"=1 \ -d "mode"="subscription" \ -d "success_url"="https://example.com/success?session_id={CHECKOUT_SESSION_ID}" \ ``` Wenn Ihre Kund/innen ihre Zahlung erfolgreich abgeschlossen haben, werden Sie an die `success_url` weitergeleitet. Hierbei handelt es sich um eine Seite auf Ihrer Website, auf der Ihre Kund/innen darüber informiert werden, dass ihre Zahlung erfolgreich durchgeführt wurde. Stellen Sie die Sitzungs-ID auf Ihrer Erfolgsseite zur Verfügung, indem Sie die Vorlagenvariable `{CHECKOUT_SESSION_ID}` wie im obigen Beispiel in die `success_url` einfügen. Wenn Ihre Kundin/Ihr Kunde in einer Checkout-Sitzung auf Ihr Logo klickt, ohne eine Zahlung abzuschließen, leitet Checkout sie/ihn zurück auf die Seite Ihrer Website, die vor der Weiterleitung zu Checkout angezeigt wurde. Checkout-Sitzungen laufen standardmäßig 24 Stunden nach Erstellung ab. > Verlassen Sie sich beim Erkennen von initiierten Zahlungen nicht allein auf die Weiterleitung auf die `success_url`: > > - Böswillige Nutzer/innen könnten, ohne zu bezahlen, direkt auf die `success_url` zugreifen und sich so unberechtigt Zugang zu Waren und Dienstleistungen verschaffen. - Nach einer erfolgreichen Zahlung schließen Kundinnen und Kunden möglicherweise ihren Browser-Tab, bevor sie zur `success_url` weitergeleitet werden. ## Bestätigen, dass die Zahlung erfolgreich durchgeführt wurde Wenn Ihre Kund/innen ihre Zahlung erfolgreich abschließen, werden sie an die URL weitergeleitet, die Sie als `success_url` festgelegt haben. Hierbei handelt es sich in der Regel um eine Seite auf Ihrer Website, auf der Ihre Kund/innen darüber informiert werden, dass ihre Zahlung erfolgreich durchgeführt wurde. Verwenden Sie das Dashboard, einen nutzerdefinierten *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder ein Drittanbieter-Plugin, um Ereignisse nach Zahlung wie das Versenden einer Bestellbestätigung per E-Mail, das Erfassen des Verkaufs in einer Datenbank oder das Initiieren eines Versandworkflows zu handhaben. #### Dashboard Erfolgreiche Zahlungen werden im Dashboard in der [Zahlungsliste](https://dashboard.stripe.com/payments) angezeigt. Wenn Sie auf eine Zahlung klicken, werden Sie zur Seite mit den Zahlungsdetails weitergeleitet. Der Abschnitt **Checkout-Übersicht** umfasst Rechnungsinformationen und die Liste der gekauften Artikel, die Sie zur manuellen Abwicklung der Bestellung verwenden können. ![Checkout-Übersicht](https://b.stripecdn.com/docs-statics-srv/assets/source.16d3029596357c80a8efdbbfe106108a.png) Wenn die Zahlung einer Kundin/eines Kunden für eine wiederkehrende Dienstleistung erfolgreich ist, erhält sie/er automatisch das Abonnement. Das Abonnement wird in Form eines neuen Eintrags in der [Liste von Abonnements](https://dashboard.stripe.com/subscriptions) aufgezeichnet. > Durch Senden von E-Mail-Benachrichtigungen über erfolgreich abgeschlossene Kundenzahlungen kann Stripe Ihnen helfen, den Überblick über eingehende Zahlungen zu behalten. Verwenden Sie das Dashboard, um [E-Mail-Benachrichtigungen zu konfigurieren](https://dashboard.stripe.com/settings/user). #### Webhooks [Richten Sie Webhooks ein](https://docs.stripe.com/webhooks.md), um Ereignisse nach der Zahlung programmgesteuert zu handhaben. Lokal lassen sich Webhooks am schnellsten mit der [Stripe-CLI](https://docs.stripe.com/stripe-cli.md) entwickeln und testen. Sobald Sie die Stripe-CLI installiert haben, können Sie Ereignisse an Ihren Server weiterleiten: ```bash stripe listen --forward-to localhost:4242/webhook Ready! Your webhook signing secret is '{{WEBHOOK_SIGNING_SECRET}}' (^C to quit) ``` Mit einem Webhook-Endpoint werden Ihre Kundinnen und Kunden an die `success_url` weitergeleitet, wenn Sie [bestätigen, dass Sie das Ereignis empfangen haben](https://docs.stripe.com/webhooks.md#acknowledge-events-immediately). In Szenarien, in denen Ihr Endpoint nicht funktionsfähig ist oder das Ereignis nicht ordnungsgemäß anerkannt wurde, leitet Ihr Handler den Kunden/die Kundin 10 Sekunden nach erfolgreicher Zahlung an die `success_url` weiter. Der folgende Beispiel-Endpoint zeigt, wie Ereignisse anerkannt und gehandhabt werden. #### Ruby ```ruby # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. # Find your keys at https://dashboard.stripe.com/apikeys. client = Stripe::StripeClient.new('<>') # You can find your endpoint's secret in your webhook settings endpoint_secret = 'whsec_...' # Using Sinatra post '/webhook' do payload = request.body.read event = nil # Verify webhook signature and extract the event # See https://stripe.com/docs/webhooks#verify-events for more information. sig_header = request.env['HTTP_STRIPE_SIGNATURE'] begin event = Stripe::Webhook.construct_event( payload, sig_header, endpoint_secret ) rescue JSON::ParserError => e # Invalid payload status 400 return rescue Stripe::SignatureVerificationError => e # Invalid signature status 400 return end # Handle the checkout.session.completed event if event['type'] == 'checkout.session.completed' session = event['data']['object'] # Fulfill the purchase... handle_checkout_session(session) end status 200 end ``` Sie können Plugins wie [Zapier](https://stripe.com/works-with/zapier) verwenden, um das Aktualisieren Ihrer Kaufabwicklungssysteme mit Informationen aus Stripe-Zahlungen zu automatisieren. Nachfolgend finden Sie einige Beispiele für unterstützte Automatisierungen mithilfe von Plugins: - Aktualisieren der zur Bestellungsverfolgung verwendeten Tabellen als Reaktion auf erfolgreiche Zahlungen - Aktualisieren der Bestandsverwaltungssysteme als Reaktion auf erfolgreiche Zahlungen - Auslösen von Benachrichtigungen an interne Kundenservice-Teams unter Verwendung von E-Mail- oder Chat-Anwendungen ## Integration testen Wählen Sie mit Ihren [Test-API-Schlüsseln](https://docs.stripe.com/keys.md#test-live-modes) eine beliebige Bank in der Liste aus. Nach der Bestätigung werden Sie an eine Testseite mit Optionen zur Autorisierung oder Ablehnung die Zahlung weitergeleitet. - Klicken Sie auf **Authorize test payment** (Testzahlung autorisieren), um das Szenario zu testen, bei dem die Einrichtung erfolgreich ist. - Klicken Sie auf **Fail test payment** (Testzahlung ablehnen), um das Szenario zu testen, bei dem der/die Kund/in nicht authentifiziert werden kann. ## Optional: Erstellen Sie eine Testversion für Ihr Abonnement Kostenlose Testversionen ermöglichen Ihren Kundinnen und Kunden den Zugang zu Ihrem Produkt für einen bestimmten Zeitraum, ohne dass sie dafür bezahlen müssen. Fügen Sie Ihrem Abonnement eine Testversion hinzu, indem Sie den Parameter `subscription_data.trial_period_days` oder `subscription_data.trial_end` beim [Erstellen der Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-subscription_data) festlegen. Die erste Zahlung Ihres Kunden/Ihrer Kundin findet nach dem Ende des Testzeitraums statt. Um beispielsweise einen kostenlosen Testzeitraum von 7 Tagen zu Beginn Ihres Abonnements hinzuzufügen, setzen Sie `subscription_data.trial_period_days` auf `7`. #### Zahlungsmethoden manuell auflisten #### cURL ```bash curl https://api.stripe.com/v1/checkout/sessions \ -u <>: \ -d "payment_method_types[]"="ideal" \ -d "line_items[][price]"="{{PRICE_ID}}" \ -d "line_items[][quantity]"=1 \ -d "mode"="subscription" \ -d "success_url"="https://example.com/success?session_id={CHECKOUT_SESSION_ID}" \-d "subscription_data[trial_period_days]"=7 ``` #### Zahlungsmethoden über das Dashboard verwalten #### cURL ```bash curl https://api.stripe.com/v1/checkout/sessions \ -u <>: \ -d "line_items[][price]"="{{PRICE_ID}}" \ -d "line_items[][quantity]"=1 \ -d "mode"="subscription" \ -d "success_url"="https://example.com/success?session_id={CHECKOUT_SESSION_ID}" \-d "subscription_data[trial_period_days]"=7 ``` ## See also - [Ihre Integration anpassen](https://docs.stripe.com/payments/checkout/customization.md) - [Abonnements über das Kundenportal verwalten](https://docs.stripe.com/billing/subscriptions/build-subscriptions.md?payment-ui=checkout&ui=stripe-hosted) # Direct API Verwenden Sie diesen Leitfaden, um ein *Abonnement* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis) mit [iDEAL](https://docs.stripe.com/payments/ideal.md) als Zahlungsmethode einzurichten. iDEAL ist eine Zahlungsmethode für die [einmalige Nutzung](https://docs.stripe.com/payments/payment-methods.md#usage), bei der Kundinnen und Kunden jede Zahlung [authentifizieren](https://docs.stripe.com/payments/payment-methods.md#customer-actions) müssen. Bei dieser Integration berechnet Stripe Ihrer Kundschaft 0,01 EUR über iDEAL, um deren Bankdaten zu erfassen. Nachdem Ihre Kundin oder Ihr Kunde die Zahlung authentifiziert hat, erstattet Stripe die Zahlung und speichert die [IBAN](https://en.wikipedia.org/wiki/International_Bank_Account_Number) Ihrer Kundin/Ihres Kunden in der Zahlungsmethode [SEPA-Lastschrift](https://docs.stripe.com/payments/sepa-debit.md). Sie können dann die [Zahlungsmethode ](https://docs.stripe.com/api/payment_methods.md)SEPA-Lastschrift zur Zahlung des Abos verwenden. > Um iDEAL zur Einrichtung von SEPA-Lastschriftzahlungen zu verwenden, müssen Sie SEPA-Lastschrift im [Dashboard](https://dashboard.stripe.com/account/payments/settings) aktivieren. Außerdem müssen Sie die [Allgemeinen Geschäftsbedingungen von iDEAL](https://stripe.com/ideal/legal) und die [Allgemeinen Geschäftsbedingungen für SEPA-Lastschriften](https://stripe.com/sepa-direct-debit/legal) erfüllen. ## Produkt und Preis erstellen [Dashboard] [Produkte](https://docs.stripe.com/api/products.md) stehen für den von Ihnen angebotenen Artikel oder Dienst. [Preise](https://docs.stripe.com/api/prices.md) geben an, wie viel und wie häufig Sie für ein Produkt berechnen. Dies schließt ein, wie viel ein Produkt kostet, welche Währung Sie akzeptieren und ob es sich um eine einmalige oder eine wiederkehrende Zahlung handelt. Wenn Sie nur ein paar wenige Produkte und Preise haben, können Sie diese im Dashboard erstellen und verwalten. In diesem Leitfaden wird ein Stock-Foto-Service als Beispiel verwendet, für den Kund/innen ein monatliches Abonnement mit dem Betrag von 15 EUR berechnet werden. Um dies zu modellieren: 1. Gehen Sie zur Seite [Produkte](https://dashboard.stripe.com/products?active=true) und klicken Sie auf **Produkt erstellen**. 1. Geben Sie einen **Namen** für das Produkt an. Sie können optional eine **Beschreibung** hinzufügen und ein Bild des Produkts hochladen. 1. Wählen Sie einen **Produktsteuercode** aus. Erfahren Sie mehr über [Produktsteuercodes](https://docs.stripe.com/tax/tax-codes.md). 1. Wählen Sie **Wiederkehrend** aus. Geben Sie im Anschluss daran **15** für den Preis ein und wählen Sie **EUR** als Währung aus. 1. Wählen Sie, ob die **Steuer im Preis berücksichtigt** werden soll. Sie können entweder den Standardwert aus Ihren [Steuereinstellungen](https://dashboard.stripe.com/test/settings/tax) verwenden oder den Wert manuell festlegen. Wählen Sie in diesem Beispiel **Auto** aus. 1. Wählen Sie **Monatlich** als **Abrechnungszeitraum** aus. 1. Klicken Sie auf **Weitere Preisoptionen**. Wählen Sie dann **Pauschalpreis** als Preismodell für dieses Beispiel aus. Erfahren Sie mehr über [Pauschalpreise](https://docs.stripe.com/products-prices/pricing-models.md#flat-rate) und andere [Preismodelle](https://docs.stripe.com/products-prices/pricing-models.md). 1. Fügen Sie eine interne **Preisbeschreibung** und einen [Lookup-Schlüssel](https://docs.stripe.com/products-prices/manage-prices.md#lookup-keys) hinzu, um bestimmte Preise in Zukunft zu organisieren, abzufragen und zu aktualisieren. 1. Klicken Sie auf **Weiter**. Klicken Sie dann auf **Produkt hinzufügen**. Zeichnen Sie nach Erstellen des Produkts und des Preises die Preis-ID auf, sodass Sie diese in nachfolgenden Schritten verwenden können. Die ID wird auf der Preisseite angezeigt und sieht in etwa so aus: `price_G0FvDp6vZvdwRZ`. ## Vor der Einrichtung eine Kundin oder einen Kunden erstellen oder abrufen [Serverseitig] Um eine von iDEAL eingeleitete Zahlungsmethode SEPA-Lastschrift für zukünftige Zahlungen wiederzuverwenden, muss sie einer/einem *Kundin/Kunden* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) zugeordnet werden. Erstellen Sie ein Kundenobjekt, wenn ein Kunde/eine Kundin ein Konto bei Ihrem Unternehmen anlegt. Verknüpfen Sie die ID des Kundenobjekts mit Ihrer internen Darstellung eines Kunden/einer Kundin, um die gespeicherten Angaben zur Zahlungsmethode zu einem späteren Zeitpunkt abzurufen und zu verwenden. Wenn der Kunde/die Kundin kein Konto erstellt hat, können Sie jetzt trotzdem ein Kundenobjekt erstellen und es zu einem späteren Zeitpunkt mit Ihrer internen Darstellung des Kundenkontos verknüpfen. ```curl curl -X POST https://api.stripe.com/v1/customers \ -u "<>:" ``` ## SetupIntent erstellen [Serverseitig] Erstellen Sie ein `SetupIntent` mit der ID der Kundin/des Kunden und fügen Sie `ideal` dem Array [payment_method_types](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_types) hinzu. Das `SetupIntent` verfolgt die Schritte des Einrichtungsprozesses. Für iDEAL | Wero umfasst dies das Einholen eines [SEPA-Lastschriftmandats](https://www.europeanpaymentscouncil.eu/what-we-do/sepa-direct-debit/sdd-mandate) von der Kunden/vom Kunden sowie die Überwachung seiner Gültigkeit. #### Accounts v2 ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -d "payment_method_types[]=ideal" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -d "payment_method_types[]=ideal" \ -d customer={{CUSTOMER_ID}} ``` ## Zahlungsdaten erfassen und bestätigen [Clientseitig] Verwenden Sie das [Payment Element](https://docs.stripe.com/payments/payment-element.md), um Details zur Zahlungsmethode zu erfassen und den SetupIntent zu bestätigen. Das Payment Element kümmert sich um die Weiterleitung der Kundin/des Kunden zu iDEAL zur Authentifizierung. Erfassen Sie Zahlungsdetails auf dem Client mit dem [Payment Element](https://docs.stripe.com/payments/payment-element.md). Das Payment Element ist eine vorgefertigte Komponente der Nutzeroberfläche, die die Erfassung von Zahlungsdaten für eine Vielzahl von Zahlungsmethoden vereinfacht. Das Payment Element enthält einen iFrame, der Zahlungsinformationen über eine sichere HTTPS-Verbindung an Stripe sendet. Vermeiden Sie es, das Payment Element in einem anderen iFrame zu platzieren, da einige Zahlungsmethoden die Weiterleitung an eine andere Seite zur Zahlungsbestätigung voraussetzen. Wenn Sie sich für die Verwendung eines Iframes entscheiden und Apple Pay oder Google Pay akzeptieren möchten, muss das Attribut [Zulassen](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-allowpaymentrequest) des Iframes auf `"payment*"` gesetzt sein. Die Adresse der Bezahlseite muss mit `https://` beginnen, nicht mit `http://`, damit Ihre Integration funktioniert. Sie können Ihre Integration ohne HTTPS testen. Denken Sie jedoch daran, dieses zu [aktivieren](https://docs.stripe.com/security/guide.md#tls), wenn Sie bereit sind, Live-Zahlungen zu akzeptieren. #### HTML + JS ### Stripe.js einrichten Das Payment Element ist ein Feature von Stripe.js und steht damit automatisch zur Verfügung. Fügen Sie das Stripe.js-Skript auf Ihrer Bezahlseite ein, indem Sie es in den `head` Ihrer HTML-Datei einbinden. Laden Sie Stripe.js immer direkt von js.stripe.com, um die PCI-Konformität zu gewährleisten. Fügen Sie das Skript nicht in ein Paket ein und hosten Sie selbst keine Kopie davon. ```html Checkout ``` Erstellen Sie auf Ihrer Bezahlseite eine Instanz von Stripe mit dem folgenden JavaScript: ```javascript // Set your publishable key: remember to change this to your live publishable key in production // See your keys here: https://dashboard.stripe.com/apikeys const stripe = Stripe('<>'); ``` ### Payment Element Ihrer Bezahlseite hinzufügen Das Payment Element benötigt einen festen Platz auf Ihrer Zahlungsseite. Erstellen Sie einen leeren DOM-Knoten (Container) mit einer eindeutigen ID in Ihrem Zahlungsformular: ```html
``` Wenn das vorherige Formular geladen wurde, erstellen Sie eine Instanz des Payment Element und verbinden es mit dem DOM-Knoten (Container). Übergeben Sie das [Client-Geheimnis](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-client_secret) aus dem vorherigen Schritt an `options`, wenn Sie die [Elements](https://docs.stripe.com/js/elements_object/create)-Instanz erstellen: ```javascript const options = { clientSecret: '{{CLIENT_SECRET}}', // Fully customizable with appearance API. appearance: {/*...*/}, }; // Set up Stripe.js and Elements to use in checkout form, passing the client secret obtained in a previous stepconst elements = stripe.elements(options); // Optional: Autofill user's saved payment methods. If the customer's // email is known when the page is loaded, you can pass the email // to the contactDetailsElement on mount: // // contactDetailsElement.mount("#contact-details-element", { // defaultValues: { // email: 'jenny.rosen@example.com', // } // }) // Create and mount the Payment Element const paymentElementOptions = { layout: 'accordion'}; const paymentElement = elements.create('payment', paymentElementOptions); paymentElement.mount('#payment-element'); ``` #### React ### Stripe.js einrichten Installieren Sie [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) und den [Stripe.js-Loader](https://www.npmjs.com/package/@stripe/stripe-js) aus dem öffentlichen npm-Register: ```bash npm install --save @stripe/react-stripe-js @stripe/stripe-js ``` ### Den Elements-Anbieter zu Ihrer Zahlungsseite hinzufügen und konfigurieren Um die Payment Element-Komponente zu verwenden, schließen Sie die Komponente Ihrer Bezahlseite in einen [Elements-Anbieter](https://docs.stripe.com/sdks/stripejs-react.md#elements-provider) ein. Rufen Sie `loadStripe` mit Ihrem veröffentlichbaren Schlüssel auf und übergeben Sie das zurückgegebene `Promise` an den `Elements`-Anbieter. Übergeben Sie auch das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) aus dem vorherigen Schritt als `options` an den `Elements`-Anbieter. ```jsx import React from 'react'; import ReactDOM from 'react-dom'; import {Elements} from '@stripe/react-stripe-js'; import {loadStripe} from '@stripe/stripe-js'; import SetupForm from './SetupForm'; // Make sure to call `loadStripe` outside of a component's render to avoid // recreating the `Stripe` object on every render. const stripePromise = loadStripe('<>'); function App() { const options = { // passing the client secret obtained in step 3 clientSecret: '{{CLIENT_SECRET}}', // Fully customizable with appearance API. appearance: {/*...*/}, }; return ( ); }; ReactDOM.render(, document.getElementById('root')); ``` ### Payment Element hinzufügen Verwenden Sie die Komponente `PaymentElement`, um Ihr Formular zu erstellen: ```jsx import React from 'react'; import {PaymentElement} from '@stripe/react-stripe-js'; const SetupForm = () => { return (
); }; export default SetupForm; ``` Senden Sie statt des gesamten SetupIntent-Objekts das [Client-Geheimnis](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-client_secret) des SetupIntent-Objekts an den Client. Dies unterscheidet sich von Ihren API-Schlüsseln, die Stripe-API-Anfragen authentifizieren. Gehen Sie sorgfältig mit dem Client-Geheimnis um, da die Einrichtung damit abgeschlossen werden kann. Protokollieren Sie es nicht, betten Sie es nicht in URLs ein und geben Sie es nur an die Kundin oder den Kunden weiter. Verwenden Sie [Stripe.confirmSetup](https://docs.stripe.com/js/payment_intents/confirm_setup), um den SetupIntent mit Daten aus dem Payment Element abzuschließen. Geben Sie eine [return_url](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-return_url) für diese Funktion an, um zu bestimmen, wohin Stripe die Nutzer/innen nach Abschluss des SetupIntent weiterleitet. Ihre Nutzer/innen werden zunächst zur Autorisierung an ihre Bank weitergeleitet und dann an die `return_url`. #### HTML + JS ```javascript const form = document.getElementById('payment-form'); form.addEventListener('submit', async (event) => { event.preventDefault(); const {error} = await stripe.confirmSetup({ elements, confirmParams: { return_url: 'https://example.com/order/123/complete', }, }); if (error) { const messageContainer = document.querySelector('#error-message'); messageContainer.textContent = error.message; } else { // Your customer is redirected to your `return_url`. } }); ``` #### React ```jsx import React, {useState} from 'react'; import {useStripe, useElements, PaymentElement} from '@stripe/react-stripe-js'; const CheckoutForm = () => { const stripe = useStripe(); const elements = useElements(); const [errorMessage, setErrorMessage] = useState(null); const handleSubmit = async (event) => { event.preventDefault(); if (!stripe || !elements) { return; } const {error} = await stripe.confirmSetup({ elements, confirmParams: { return_url: 'https://example.com/order/123/complete', }, }); if (error) { setErrorMessage(error.message); } else { // Your customer is redirected to your `return_url`. } }; return (
{errorMessage &&
{errorMessage}
} ) }; export default CheckoutForm; ``` ## Optional: Webhooks überwachen [Serverseitig] Verwenden Sie eine Methode wie Webhooks, um zu bestätigen, dass die Einrichtung erfolgreich von Ihrer Kundin/Ihrem Kunden autorisiert wurde, anstatt sich darauf zu verlassen, dass Ihre Kundin/Ihr Kunde zur Seite des Zahlungsstatus zurückkehrt. Sobald eine Kundin/ein Kunde die Einrichtung erfolgreich autorisiert, gibt der SetupIntent das Webhook-Ereignis `setup_intent.succeeded` aus. Wenn eine Kundin/ein Kunde die Einrichtung nicht erfolgreich autorisiert, gibt der SetupIntent das Webhook-Ereignis `setup_intent.setup_failed` aus und kehrt zum Status `requires_payment_method` zurück. ## Das Abonnement erstellen [Serverseitig] Nachdem der SetupIntent erfolgreich war, rufen Sie die generierte Zahlungsmethode SEPA-Lastschrift ab. Suchen Sie die ID der Zahlungsmethode SEPA-Lastschrift, indem Sie den SetupIntent [abrufen](https://docs.stripe.com/api/setup_intents/retrieve.md) und das Feld `latest_attempt` [erweitern](https://docs.stripe.com/api/expanding_objects.md), wo Sie die ID `generated_sepa_debit` innerhalb der `payment_method_details` finden: ```curl curl -G https://api.stripe.com/v1/setup_intents/{{SETUP_INTENT_ID}} \ -u "<>:" \ -d "expand[]=latest_attempt" ``` Verwenden Sie die ID der Zahlungsmethode `generated_sepa_debit` aus `latest_attempt.payment_method_details.generated_sepa_debit`, um ein [Abonnement](https://docs.stripe.com/api/subscriptions.md) mit den Kundendaten und der ID der Zahlungsmethode SEPA-Lastschrift zu erstellen: ```curl curl https://api.stripe.com/v1/subscriptions \ -u "<>:" \ -d customer=cus_Gk0uVzT2M4xOKD \ -d default_payment_method=pm_1F0c9v2eZvKYlo2CJDeTrB4n \ -d "items[0][price]=price_F52b2UdntfQsfR" \ -d "expand[0]=latest_invoice.payment_intent" \ -d off_session=true ``` Beim Erstellen von Abonnements werden Kundinnen und Kunden automatisch belastet, da die [standardmäßige Zahlungsmethode](https://docs.stripe.com/api/customers/create.md#create_customer-invoice_settings-default_payment_method) festgelegt ist. Nach erfolgreicher Zahlung ändert sich der Status im [Stripe-Dashboard](https://dashboard.stripe.com/test/subscriptions) in **Aktiv**. Der zuvor von Ihnen erstellte Preis bestimmt die nachfolgenden Abrechnungen. ## Abonnementstatus verwalten [Clientseitig] Wenn die erste Zahlung erfolgreich war, ist der Status des Abonnements `aktiv` und es sind keine weiteren Maßnahmen erforderlich. Wenn Zahlungen fehlschlagen, wird der Status in den **Abonnement-Status** geändert, der in Ihren [Einstellungen für den automatischen Einzug](https://docs.stripe.com/invoicing/automatic-collection.md) konfiguriert ist. Benachrichtigen Sie die Kundin/den Kunden nach einem Fehlschlag und [wickeln Sie die Zahlung mit einer anderen Zahlungsmethode](https://docs.stripe.com/billing/subscriptions/overview.md#requires-payment-method) ab. ## Ein Abonnement aktualisieren [Serverseitig] Wenn Sie ein Abo aktualisieren, müssen Sie `off_session=true` angeben. Andernfalls ist für jede neue Zahlung eine Bestätigung der Nutzerin oder des Nutzers erforderlich. Wenn Sie beispielsweise die Menge eines im Abo enthaltenen Postens ändern möchten, können Sie Folgendes verwenden: ```curl curl https://api.stripe.com/v1/subscriptions \ -u "<>:" \ -d customer=cus_Gk0uVzT2M4xOKD \ -d default_payment_method=pm_1F0c9v2eZvKYlo2CJDeTrB4n \ -d "items[0][price]=price_F52b2UdntfQsfR" \ -d "items[0][quantity]=2" \ -d off_session=true ``` ## Integration testen Bestätigen Sie den SetupIntent mit Ihren [Test-API-Schlüsseln](https://docs.stripe.com/keys.md#test-live-modes). Nach der Bestätigung werden Sie an eine Testseite mit Optionen zur Autorisierung oder Ablehnung der Einrichtung der Zahlungsmethode weitergeleitet. - Klicken Sie auf **Authorize test payment** (Testzahlung autorisieren), um den Fall zu testen, wenn die Einrichtung erfolgreich durchgeführt wird. Die SetupIntent wechselt von `requires_action` zu `succeeded`. - Klicken Sie auf **Fail test payment** (Testzahlung ablehnen), um den Fall zu testen, wenn der/die Kund/in nicht authentifiziert werden kann. Die SetupIntent wechselt von `requires_action` zu `requires_payment_method`. ### Ihre Integration von SEPA-Lastschrift testen #### E-Mail-Adresse Setzen Sie `payment_method.billing_details.email` auf einen der folgenden Werte, um die `PaymentIntent`-Statusübergänge zu testen. Sie können Ihren eigenen benutzerdefinierten Text am Anfang der E-Mail-Adresse, gefolgt von einem Unterstrich, einfügen. Beispielsweise ergibt sich aus `test_1_generatedSepaDebitIntentsFail@example.com` eine SEPA-Lastschrift-PaymentMethod, die immer fehlschlägt, wenn sie mit einem `PaymentIntent` verwendet wird. | E-Mail-Adresse | Beschreibung | | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------- | | `generatedSepaDebitIntentsSucceed@example.com` | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `erfolgreich`. | | `generatedSepaDebitIntentsSucceedDelayed@example.com` | Der Status des `PaymentIntent` wechselt nach drei Minuten von `wird bearbeitet` zu `erfolgreich`. | | `generatedSepaDebitIntentsFail@example.com` | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `requires_payment_method`. | | `generatedSepaDebitIntentsFailDelayed@example.com` | Der Status des `PaymentIntent` wechselt nach mindestens drei Minuten von `wird bearbeitet` zu `requires_payment_method`. | | `generatedSepaDebitIntentsSucceedDisputed@example.com` | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `erfolgreich`, aber es wird sofort eine Zahlungsanfechtung erstellt. | | `generatedSepaDebitIntentsFailsDueToInsufficientFunds@example.com` | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `requires_payment_method` mit dem Fehlercode `insufficient_funds`. | #### PaymentMethod Verwenden Sie diese PaymentMethods, um die `PaymentIntent`-Statusübergänge zu testen. Diese Token sind nützlich für automatisierte Test, um die PaymentMethod sofort zum SetupIntent auf dem Server hinzuzufügen. | Zahlungsmethode | Beschreibung | | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | | `pm_ideal_generatedSepaDebitIntentsSucceed` | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `erfolgreich`. | | `pm_ideal_generatedSepaDebitIntentsSucceedDelayed` | Der Status des `PaymentIntent` wechselt nach drei Minuten von `wird bearbeitet` zu `erfolgreich`. | | `pm_ideal_generatedSepaDebitIntentsFail` | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `requires_payment_method`. | | `pm_ideal_generatedSepaDebitIntentsFailDelayed` | Der Status des `PaymentIntent` wechselt nach mindestens drei Minuten von `wird bearbeitet` zu `requires_payment_method`. | | `pm_ideal_generatedSepaDebitIntentsSucceedDisputed` | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `erfolgreich`, aber es wird sofort eine Zahlungsanfechtung erstellt. | | `pm_ideal_generatedSepaDebitIntentsFailsDueToInsufficientFunds` | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `requires_payment_method` mit dem Fehlercode `insufficient_funds`. | ## Optional: Den Rechnungsstellungszeitraum festlegen Wenn Sie ein Abonnement erstellen, wird der Abrechnungszyklus automatisch auf Standard eingestellt. Wenn ein Kunde/eine Kundin beispielsweise am 7. September einen monatlichen Plan abonniert, wird dies danach am 7. jedes Monats in Rechnung gestellt. Manche Unternehmen legen ihren Abrechnungszyklus lieber selbst fest, damit sie ihren Kundinnen/Kunden jeden Zyklus zur selben Zeit in Rechnung stellen können. Das Argument [Abrechnungszyklusanker](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-billing_cycle_anchor) macht dies möglich. #### Accounts v2 ```curl curl https://api.stripe.com/v1/subscriptions \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "items[0][price]={{PRICE_ID}}" \ -d billing_cycle_anchor=1611008505 ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/subscriptions \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -d "items[0][price]={{PRICE_ID}}" \ -d billing_cycle_anchor=1611008505 ``` Durch manuelles Festlegen des Abrechnungszyklus wird dem Kunden/der Kundin automatisch ein anteilsmäßig verrechneter Betrag für die Zeit zwischen der Erstellung des Abonnements und dem Abrechnungszyklusanker berechnet. Wenn Sie Kundinnen/Kunden diesen Zeitraum nicht in Rechnung stellen möchten, können Sie das Argument [proration_behavior](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-proration_behavior) auf `none` setzen. Sie können den Abrechnungszyklusanker auch mit [Testzeiträumen](https://docs.stripe.com/billing/subscriptions/ideal.md#trial-periods) kombinieren, um Nutzern und Nutzerinnen kostenlosen Zugriff auf Ihr Produkt zu gewähren und ihnen dann einen anteiligen Betrag zu berechnen. ## Optional: Abonnement-Testzeiträume Kostenlose Testphasen ermöglichen Kundinnen/Kunden, Ihr Produkt für einen begrenzten Zeitraum ohne Gebühren zu nutzen. Die Nutzung kostenloser Testphasen unterscheidet sich vom Festlegen bdes [proration_behavior](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-proration_behavior) auf `none`, da Sie die Dauer der kostenlosen Testphase anpassen können. Übergeben Sie einen Zeitstempel im [Ablauf der Testphase](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-trial_end), um den Testzeitraum festzulegen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/subscriptions \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "items[0][price]={{PRICE_ID}}" \ -d trial_end=1610403705 ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/subscriptions \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -d "items[0][price]={{PRICE_ID}}" \ -d trial_end=1610403705 ``` Sie können einen [Abrechnungszyklusanker](https://docs.stripe.com/billing/subscriptions/ideal.md#billing-cycle) auch mit einer kostenlosen Testphase kombinieren. Angenommen, es ist der 15. September und Sie möchten Ihrem Kunden/Ihrer Kundin eine kostenlose siebentägige Testphase schenken und am 1. Oktober mit dem normalen Abrechnungszyklus starten. Sie können den Ablauf der kostenlosen Testphase auf den 22. September festlegen und den Abrechnungszyklusanker auf den 1. Oktober. So kann der Kunde/die Kundin sieben Tage lang eine kostenlose Testversion nutzen und für den Zeitraum zwischen Ablauf der Testphase und dem 1. Oktober wird ein anteilsmäßig verrechneter Betrag berechnet. Am 1. Oktober berechnen Sie dem Kunden/der Kundin dann den normalen Abonnementbetrag für seinen/ihren ersten vollen Abrechnungszyklus.